Tutorial: Build a Tomcat web app with Azure App Service on Linux and MySQL

Article
09/15/2024

This tutorial shows how to build, configure, and deploy a secure Tomcat application in Azure App Service that connects to a MySQL database (using Azure Database for MySQL). Azure App Service is a highly scalable, self-patching, web-hosting service that can easily deploy apps on Windows or Linux. When you're finished, you have a Tomcat app running on Azure App Service on Linux.

Screenshot of Tomcat application storing data in MySQL.

In this tutorial, you learn how to:

Create a secure-by-default architecture for Azure App Service and Azure Database for MySQL.
Secure connection secrets using a managed identity and Key Vault references.
Deploy a Tomcat sample app to App Service from a GitHub repository.
Access App Service app settings in the application code.
Make updates and redeploy the application code.
Stream diagnostic logs from App Service.
Manage the app in the Azure portal.
Provision the same architecture and deploy by using Azure Developer CLI.
Optimize your development workflow with GitHub Codespaces and GitHub Copilot.

Prerequisites

An Azure account with an active subscription. If you don't have an Azure account, you can create one for free.
A GitHub account. you can also get one for free.
Knowledge of Java with Tomcat development.
(Optional) To try GitHub Copilot, a GitHub Copilot account. A 30-day free trial is available.

An Azure account with an active subscription. If you don't have an Azure account, you can create one for free.
Azure Developer CLI installed. You can follow the steps with the Azure Cloud Shell because it already has Azure Developer CLI installed.
Knowledge of Java with Tomcat development.
(Optional) To try GitHub Copilot, a GitHub Copilot account. A 30-day free trial is available.

You can quickly deploy the sample app in this tutorial and see it running in Azure. Just run the following commands in the Azure Cloud Shell, and follow the prompt:

mkdir msdocs-tomcat-mysql-sample-app
cd msdocs-tomcat-mysql-sample-app
azd init --template msdocs-tomcat-mysql-sample-app
azd up

1. Run the sample

First, you set up a sample data-driven app as a starting point. For your convenience, the sample repository, includes a dev container configuration. The dev container has everything you need to develop an application, including the database, cache, and all environment variables needed by the sample application. The dev container can run in a GitHub codespace, which means you can run the sample on any computer with a web browser.

Step 1: In a new browser window:

Sign in to your GitHub account.
Navigate to https://github.com/Azure-Samples/msdocs-tomcat-mysql-sample-app/fork.
Unselect Copy the main branch only. You want all the branches.
Select Create fork.

Step 2: In the GitHub fork:

Select main > starter-no-infra for the starter branch. This branch contains just the sample project and no Azure-related files or configuration.
Select Code > Create codespace on starter-no-infra. The codespace takes a few minutes to set up.

Step 3: In the codespace terminal:

Run mvn jetty:run.
When you see the notification Your application running on port 80 is available., select Open in Browser. You should see the sample application in a new browser tab. To stop the Jetty server, type Ctrl+C.

Tip

You can ask GitHub Copilot about this repository. For example:

@workspace What does this project do?
@workspace What does the .devcontainer folder do?

Having issues? Check the Troubleshooting section.

2. Create App Service and MySQL

First, you create the Azure resources. The steps used in this tutorial create a set of secure-by-default resources that include App Service and Azure Database for MySQL. For the creation process, you specify:

The Name for the web app. It's used as part of the DNS name for your app in the form of https://<app-name>-<hash>.<region>.azurewebsites.net.
The Region to run the app physically in the world. It's also used as part of the DNS name for your app.
The Runtime stack for the app. It's where you select the version of Java to use for your app.
The Hosting plan for the app. It's the pricing tier that includes the set of features and scaling capacity for your app.
The Resource Group for the app. A resource group lets you group (in a logical container) all the Azure resources needed for the application.

Step 1: In the Azure portal:

Enter "web app database" in the search bar at the top of the Azure portal.
Select the item labeled Web App + Database under the Marketplace heading. You can also navigate to the creation wizard directly.

Step 2: In the Create Web App + Database page, fill out the form as follows.

Resource Group: Select Create new and use a name of msdocs-tomcat-mysql-tutorial.
Region: Any Azure region near you.
Name: msdocs-tomcat-mysql-XYZ, where XYZ is any three random characters.
Runtime stack: Java 17.
Java web server stack: Apache Tomcat 10.1.
Engine: MySQL - Flexible Server is selected for you by default as the database engine. If not, select it. Azure Database for MySQL - Flexible Server is a fully managed MySQL database as a service on Azure, compatible with the latest community editions.
Hosting plan: Basic. When you're ready, you can scale up to a production pricing tier.
Select Review + create.
After validation completes, select Create.

Step 3: The deployment takes a few minutes to complete. Once deployment completes, select the Go to resource button. You're taken directly to the App Service app, but the following resources are created:

Resource group: The container for all the created resources.
App Service plan: Defines the compute resources for App Service. A Linux plan in the Basic tier is created.
App Service: Represents your app and runs in the App Service plan.
Virtual network: Integrated with the App Service app and isolates back-end network traffic.
Azure Database for MySQL Flexible Server: Accessible only from the virtual network. A database and a user are created for you on the server.
Private DNS zones: Enable DNS resolution of the database server in the virtual network.

Having issues? Check the Troubleshooting section.

3. Secure connection secrets

The creation wizard generated the database connectivity string for you already as an app setting. However, the security best practice is to keep secrets out of App Service completely. You move your secrets to a key vault and change your app setting to a Key Vault reference with the help of Service Connectors.

Step 1: Retrieve the existing connection string

In the left menu of the App Service page, select Settings > Environment variables.
Select AZURE_MYSQL_CONNECTIONSTRING. It contains a JDBC connection string. If you add an app setting that contains a valid Oracle, SQL Server, PostgreSQL, or MySQL connection string, App Service injects it as a Java Naming and Directory Interface (JNDI) data source in the Tomcat server's context.xml file.
In Add/Edit application setting, in the Value field, find the password= part at the end of the string.
Copy the password string after Password= for use later. This app setting lets you connect to the MySQL database secured behind a private endpoint. However, the secret is saved directly in the App Service app, which isn't the best. You'll change this.

Step 2: Create a key vault for secure management of secrets

In the top search bar, type "key vault", then select Marketplace > Key Vault.
In Resource Group, select msdocs-tomcat-mysql-tutorial.
In Key vault name, type a name that consists of only letters and numbers.
In Region, set it to the same location as the resource group.

Step 3: Secure the key vault with a Private Endpoint

Select the Networking tab.
Unselect Enable public access.
Select Create a private endpoint.
In Resource Group, select msdocs-tomcat-mysql-tutorial.
In Name, type a name for the private endpoint that consists of only letters and numbers.
In Region, set it to the same location as the resource group.
In the dialog, in Location, select the same location as your App Service app.
In Resource Group, select msdocs-tomcat-mysql-tutorial.
In Name, type msdocs-tomcat-mysql-XYZVaultEndpoint.
In Virtual network, select msdocs-tomcat-mysql-XYZVnet.
In Subnet, msdocs-tomcat-mysql-XYZSubnet.
Select OK.
Select Review + create, then select Create. Wait for the key vault deployment to finish. You should see "Your deployment is complete."

Step 4: Configure the Service Connector

In the top search bar, type msdocs-tomcat-mysql, then the App Service resource called msdocs-tomcat-mysql-XYZ.
In the App Service page, in the left menu, select Settings > Service Connector. There's already a connector, which the app creation wizard created for you.
Select checkbox next to the connector, then select Edit.
In the Basics tab, set Client type to Java.
Select the Authentication tab.
In Password, paste the password you copied earlier.
Select Store Secret in Key Vault.
Under Key Vault Connection, select Create new. A Create connection dialog is opened on top of the edit dialog.

Step 5: Establish the Key Vault connection

In the Create connection dialog for the Key Vault connection, in Key Vault, select the key vault you created earlier.
Select Review + Create. You should see that System assigned managed identity is set to Selected.
When validation completes, select Create.

Step 6: Finalize the Service Connector configuration

You're back in the edit dialog for defaultConnector. In the Authentication tab, wait for the key vault connector to be created. When it's finished, the Key Vault Connection dropdown automatically selects it.
Select Next: Networking.
Select Save. Wait until the Update succeeded notification appears.

Step 7: Verify the Key Vault integration

From the left menu, select Settings > Environment variables again.
Next to AZURE_MYSQL_CONNECTIONSTRING, select Show value. The value should be @Microsoft.KeyVault(...), which means that it's a key vault reference because the secret is now managed in the key vault.

To summarize, the process involved retrieving the MySQL connection string from the App Service's environment variables, creating an Azure Key Vault for secure secret management with private access, and updating the service connector to store the password in the key vault. A secure connection between the App Service app and key vault was established using a system-assigned managed identity, and the setup was verified by confirming the connection string uses a Key Vault reference.

Having issues? Check the Troubleshooting section.

4. Confirm JNDI data source

If you add an app setting that contains a valid JDBC connection string for Oracle, SQL Server, PostgreSQL, or MySQL, App Service adds a Java Naming and Directory Interface (JNDI) data source for it in the Tomcat server's context.xml file. In this step, you use the SSH connection to the app container to verify the JNDI data source. In the process, you learn how to access the SSH shell for the Tomcat container.

Step 1: Back in the App Service page:

In the left menu, select SSH.
Select Go.

Step 2: In the SSH terminal, run cat /usr/local/tomcat/conf/context.xml. You should see that a JNDI resource called jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS was added. You use this data source later.

Note

Only changes to files in /home can persist beyond app restarts. For example, if you edit /usr/local/tomcat/conf/server.xml, the changes won't persist beyond an app restart.

Having issues? Check the Troubleshooting section.

5. Deploy sample code

In this step, you configure GitHub deployment using GitHub Actions. It's just one of many ways to deploy to App Service, but also a great way to have continuous integration in your deployment process. By default, every git push to your GitHub repository kicks off the build and deploy action.

Like the Tomcat convention, if you want to deploy to the root context of Tomcat, name your built artifact ROOT.war.

Step 1: Back in the App Service page, in the left menu, select Deployment Center.

Step 2: In the Deployment Center page:

In Source, select GitHub. By default, GitHub Actions is selected as the build provider.
Sign in to your GitHub account and follow the prompt to authorize Azure.
In Organization, select your account.
In Repository, select msdocs-tomcat-mysql-sample-app.
In Branch, select starter-no-infra. This is the same branch that you worked in with your sample app, without any Azure-related files or configuration.
For Authentication type, select User-assigned identity.
In the top menu, select Save. App Service commits a workflow file into the chosen GitHub repository, in the .github/workflows directory. By default, the deployment center creates a user-assigned identity for the workflow to authenticate using Microsoft Entra (OIDC authentication). For alternative authentication options, see Deploy to App Service using GitHub Actions.

Step 3: Back in the GitHub codespace of your sample fork, run git pull origin starter-no-infra. This pulls the newly committed workflow file into your codespace.

Step 4 (Option 1: with GitHub Copilot):

Start a new chat session by clicking the Chat view, then clicking +.
Ask, "@workspace How does the app connect to the database?" Copilot might give you some explanation about the jdbc/MYSQLDS data source and how it's configured.
Ask, "@workspace I want to replace the data source defined in persistence.xml with an existing JNDI data source in Tomcat but I want to do it dynamically.". Copilot might give you a code suggestion similar to the one in the Option 2: without GitHub Copilot steps below and even tell you to make the change in the ContextListener class.
Open src/main/java/com/microsoft/azure/appservice/examples/tomcatmysql/ContextListener.java in the explorer and add the code suggestion in the contextInitialized method. GitHub Copilot doesn't give you the same response every time, you might need to ask more questions to fine-tune its response. For tips, see What can I do with GitHub Copilot in my codespace?.

Step 4 (Option 2: without GitHub Copilot):

Open src/main/java/com/microsoft/azure/appservice/examples/tomcatmysql/ContextListener.java in the explorer. When the application starts, this class loads the database settings in src/main/resources/META-INF/persistence.xml.
In the contextIntialized() method, find the commented code (lines 29-33) and uncomment it. This code checks to see if the AZURE_MYSQL_CONNECTIONSTRING app setting exists, and changes the data source to java:comp/env/jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS, which is the data source you found earlier in context.xml in the SSH shell.

Step 5:

Select the Source Control extension.
In the textbox, type a commit message like Configure Azure data source.
Select Commit, then confirm with Yes.
Select Sync changes 1, then confirm with OK.

Step 6: Back in the Deployment Center page in the Azure portal:

Select Logs. A new deployment run is already started from your committed changes.
In the log item for the deployment run, select the Build/Deploy Logs entry with the latest timestamp.

Step 7: You're taken to your GitHub repository and see that the GitHub action is running. The workflow file defines two separate stages, build and deploy. Wait for the GitHub run to show a status of Complete. It takes about 5 minutes.

Having issues? Check the Troubleshooting section.

6. Browse to the app

Step 1: In the App Service page:

From the left menu, select Overview.
Select the URL of your app.

Step 2: Add a few tasks to the list. Congratulations, you're running a web app in Azure App Service, with secure connectivity to Azure Database for MySQL.

Having issues? Check the Troubleshooting section.

7. Stream diagnostic logs

Azure App Service captures all messages output to the console to help you diagnose issues with your application. The sample application includes standard Log4j logging statements to demonstrate this capability, as shown in the following snippet:

@WebServlet(urlPatterns = "/")
public class ViewServlet extends HttpServlet {
    private static Logger logger = LogManager.getLogger(ViewServlet.class.getName());
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        logger.info("GET /");

        EntityManagerFactory emf = (EntityManagerFactory) req.getServletContext().getAttribute("EMFactory");

Step 1: In the App Service page:

From the left menu, select App Service logs.
Under Application logging, select File System.
In the top menu, select Save.

Step 2: From the left menu, select Log stream. You see the logs for your app, including platform logs and logs from inside the container.

Learn more about logging in Java apps in the series on Enable Azure Monitor OpenTelemetry for .NET, Node.js, Python, and Java applications.

Having issues? Check the Troubleshooting section.

8. Clean up resources

When you're finished, you can delete all of the resources from your Azure subscription by deleting the resource group.

Step 1: In the search bar at the top of the Azure portal:

Enter the resource group name.
Select the resource group.

Step 2: In the resource group page, select Delete resource group.

Step 3:

Confirm your deletion by typing the resource group name.
Select Delete.
Confirm with Delete again.

2. Create Azure resources and deploy a sample app

In this step, you create the Azure resources and deploy a sample app to App Service on Linux. The steps used in this tutorial create a set of secure-by-default resources that include App Service and Azure Database for MySQL.

The dev container already has the Azure Developer CLI (AZD).

From the repository root, run azd init.

azd init --template tomcat-app-service-mysql-infra

When prompted, give the following answers:

Question	Answer
The current directory is not empty. Would you like to initialize a project here in '<your-directory>'?	Y
What would you like to do with these files?	Keep my existing files unchanged
Enter a new environment name	Type a unique name. The AZD template uses this name as part of the DNS name of your web app in Azure (`<app-name>-<hash>.azurewebsites.net`). Alphanumeric characters and hyphens are allowed.

Sign into Azure by running the azd auth login command and following the prompt:
```
azd auth login
```
Create the necessary Azure resources and deploy the app code with the azd up command. Follow the prompt to select the desired subscription and location for the Azure resources.
```
azd up
```
The azd up command takes about 15 minutes to complete (the Redis cache takes the most time). It also compiles and deploys your application code, but you modify your code later to work with App Service. While it's running, the command provides messages about the provisioning and deployment process, including a link to the deployment in Azure. When it finishes, the command also displays a link to the deploy application.

This AZD template contains files (azure.yaml and the infra directory) that generate a secure-by-default architecture with the following Azure resources:
- Resource group: The container for all the created resources.
- App Service plan: Defines the compute resources for App Service. A Linux plan in the B1 tier is created.
- App Service: Represents your app and runs in the App Service plan.
- Virtual network: Integrated with the App Service app and isolates back-end network traffic.
- Azure Database for MySQL Flexible Server: Accessible only from the virtual network through the DNS zone integration. A database is created for you on the server.
- Azure Cache for Redis: Accessible only from within the virtual network.
- Private endpoints: Access endpoints for the key vault and the Redis cache in the virtual network.
- Private DNS zones: Enable DNS resolution of the key vault, the database server, and the Redis cache in the virtual network.
- Log Analytics workspace: Acts as the target container for your app to ship its logs, where you can also query the logs.
- Key vault: Used to keep your database password the same when you redeploy with AZD.
Once the command finishes creating resources and deploying the application code the first time, the deployed sample app doesn't work yet because you must make small changes to make it connect to the database in Azure.

Having issues? Check the Troubleshooting section.

3. Verify connection strings

The AZD template you use generated the connectivity variables for you already as app settings and outputs the them to the terminal for your convenience. App settings are one way to keep connection secrets out of your code repository.

In the AZD output, find the app setting AZURE_MYSQL_CONNECTIONSTRING. Only the setting names are displayed. They look like this in the AZD output:
```
 App Service app has the following connection strings:
         - AZURE_MYSQL_CONNECTIONSTRING
         - AZURE_REDIS_CONNECTIONSTRING
         - AZURE_KEYVAULT_RESOURCEENDPOINT
         - AZURE_KEYVAULT_SCOPE
 
```
AZURE_MYSQL_CONNECTIONSTRING contains the connection string to the MySQL database in Azure. You need to use it in your code later.
For your convenience, the AZD template shows you the direct link to the app's app settings page. Find the link and open it in a new browser tab.

If you add an app setting that contains a valid Oracle, SQL Server, PostgreSQL, or MySQL connection string, App Service adds it as a Java Naming and Directory Interface (JNDI) data source in the Tomcat server's context.xml file.

Having issues? Check the Troubleshooting section.

4. Confirm JNDI data source

In this step, you use the SSH connection to the app container to verify the JNDI data source in the Tomcat server. In the process, you learn how to access the SSH shell for the Tomcat container.

In the AZD output, find the URL for the SSH session and navigate to it in the browser. It looks like this in the output:
```
 Open SSH session to App Service container at: https://<app-name>-<hash>.scm.azurewebsites.net/webssh/host
 
```
In the SSH terminal, run cat /usr/local/tomcat/conf/context.xml. You should see that a JNDI resource called jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS was added. You use this data source later.

Note

Only changes to files in /home can persist beyond app restarts. For example, if you edit /usr/local/tomcat/conf/server.xml, the changes won't persist beyond an app restart.

Having issues? Check the Troubleshooting section.

In the GitHub codespace, start a new chat session by clicking the Chat view, then clicking +.
Ask, "@workspace How does the app connect to the database?" Copilot might give you some explanation about the jdbc/MYSQLDS data source and how it's configured.
Ask, "@workspace I want to replace the data source defined in persistence.xml with an existing JNDI data source in Tomcat but I want to do it dynamically." Copilot might give you a code suggestion similar to the one in the Option 2: without GitHub Copilot steps below and even tell you to make the change in the ContextListener class.
Open src/main/java/com/microsoft/azure/appservice/examples/tomcatmysql/ContextListener.java in the explorer and add the code suggestion in the contextInitialized method.

GitHub Copilot doesn't give you the same response every time, you might need to ask other questions to fine-tune its response. For tips, see What can I do with GitHub Copilot in my codespace?.
In the codespace terminal, run azd deploy.
```
azd deploy
```

From the explorer, open src/main/java/com/microsoft/azure/appservice/examples/tomcatmysql/ContextListener.java. When the application starts, this class loads the database settings in src/main/resources/META-INF/persistence.xml.
In the contextIntialized() method, find the commented code (lines 29-33) and uncomment it.
```
String azureDbUrl= System.getenv("AZURE_MYSQL_CONNECTIONSTRING");
if (azureDbUrl!=null) {
    logger.info("Detected Azure MySQL connection string. Adding Tomcat data source...");
    props.put("jakarta.persistence.nonJtaDataSource", "java:comp/env/jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS");
}
```
This code checks to see if the AZURE_MYSQL_CONNECTIONSTRING app setting exists, and changes the data source to java:comp/env/jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS, which is the data source you found earlier in context.xml in the SSH shell.
Back in the codespace terminal, run azd deploy.
```
azd deploy
```

Tip

You can also just use azd up always, which does all of azd package, azd provision, and azd deploy.

To find out how the War file is packaged, you can run azd package --debug by itself.

Having issues? Check the Troubleshooting section.

6. Browse to the app

In the AZD output, find the URL of your app and navigate to it in the browser. The URL looks like this in the AZD output:

 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: https://<app-name>-<hash>.azurewebsites.net/

Add a few tasks to the list.

Congratulations, you're running a web app in Azure App Service, with secure connectivity to Azure Database for MySQL.

Having issues? Check the Troubleshooting section.

7. Stream diagnostic logs

Azure App Service can capture console logs to help you diagnose issues with your application. For convenience, the AZD template already enabled logging to the local file system and is shipping the logs to a Log Analytics workspace.

The sample application includes standard Log4j logging statements to demonstrate this capability, as shown in the following snippet:

@WebServlet(urlPatterns = "/")
public class ViewServlet extends HttpServlet {
    private static Logger logger = LogManager.getLogger(ViewServlet.class.getName());
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        logger.info("GET /");

        EntityManagerFactory emf = (EntityManagerFactory) req.getServletContext().getAttribute("EMFactory");

In the AZD output, find the link to stream App Service logs and navigate to it in the browser. The link looks like this in the AZD output:

Stream App Service logs at: https://portal.azure.com/#@/resource/subscriptions/<subscription-guid>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name>/logStream

Learn more about logging in Java apps in the series on Enable Azure Monitor OpenTelemetry for .NET, Node.js, Python, and Java applications.

Having issues? Check the Troubleshooting section.

8. Clean up resources

To delete all Azure resources in the current deployment environment, run azd down and follow the prompts.

azd down

Troubleshooting

I see many <Class> scanned from multiple locations warnings with mvn jetty:run
The portal deployment view for Azure Database for MySQL Flexible Server shows a Conflict status
The deployed sample app doesn't show the tasks list app
I see a 404 Page Not Found error in the deployed sample app

I see many <Class> scanned from multiple locations warnings with mvn jetty:run

You can ignore the warnings. The Maven Jetty plugin shows the warnings because the app's pom.xml contains the dependency for jakarta.servlet.jsp.jstl, which the Jetty already provides out of the box. You need the dependency for Tomcat.

The portal deployment view for Azure Database for MySQL Flexible Server shows a Conflict status

Depending on your subscription and the region you select, you might see the deployment status for Azure Database for MySQL Flexible Server to be Conflict, with the following message in Operation details:

InternalServerError: An unexpected error occured while processing the request.

This error is most likely caused by a limit on your subscription for the region you select. Try choosing a different region for your deployment.

The deployed sample app doesn't show the tasks list app

If you see a Hey, Java developers! page instead of the tasks list app, App Service is most likely still loading the updated container from your most recent code deployment. Wait a few minutes and refresh the page.

I see a 404 Page Not Found error in the deployed sample app

Make sure that you made the code changes to use the java:comp/env/jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS data source. If you made the changes and redeployed your code, App Service is most likely still loading the updated container. Wait a few minutes and refresh the page.

Frequently asked questions

How much does this setup cost?
How do I connect to the MySQL server behind the virtual network with other tools?
How does local app development work with GitHub Actions?
I don't have permissions to create a user-assigned identity
What can I do with GitHub Copilot in my codespace?

How much does this setup cost?

Pricing for the created resources is as follows:

The App Service plan is created in Basic tier and can be scaled up or down. See App Service pricing.
The MySQL flexible server is created in B1ms tier and can be scaled up or down. With an Azure free account, B1ms tier is free for 12 months, up to the monthly limits. See Azure Database for MySQL pricing.
The Azure Cache for Redis is created in Basic tier with the minimum cache size. There's a small cost associated with this tier. You can scale it up to higher performance tiers for higher availability, clustering, and other features. See Azure Cache for Redis pricing.
The virtual network doesn't incur a charge unless you configure extra functionality, such as peering. See Azure Virtual Network pricing.
The private DNS zone incurs a small charge. See Azure DNS pricing.

How do I connect to the MySQL server behind the virtual network with other tools?

The Tomcat container currently doesn't have the mysql-client terminal too. If you want, you must manually install it. Remember that anything you install doesn't persist across app restarts.
To connect from a desktop tool like MySQL Workbench, your machine must be within the virtual network. For example, it could be an Azure VM in one of the subnets, or a machine in an on-premises network that has a site-to-site VPN connection with the Azure virtual network.
You can also integrate Azure Cloud Shell with the virtual network.

How does local app development work with GitHub Actions?

Using the autogenerated workflow file from App Service as an example, each git push kicks off a new build and deployment run. From a local clone of the GitHub repository, you make the desired updates and push to GitHub. For example:

git add .
git commit -m "<some-message>"
git push origin main

I don't have permissions to create a user-assigned identity

See Set up GitHub Actions deployment from the Deployment Center.

What can I do with GitHub Copilot in my codespace?

You might notice that the GitHub Copilot chat view was already there for you when you created the codespace. For your convenience, we include the GitHub Copilot chat extension in the container definition (see .devcontainer/devcontainer.json). However, you need a GitHub Copilot account (30-day free trial available).

A few tips for you when you talk to GitHub Copilot:

In a single chat session, the questions and answers build on each other and you can adjust your questions to fine-tune the answer you get.
By default, GitHub Copilot doesn't have access to any file in your repository. To ask questions about a file, open the file in the editor first.
To let GitHub Copilot have access to all of the files in the repository when preparing its answers, begin your question with @workspace. For more information, see Use the @workspace agent.
In the chat session, GitHub Copilot can suggest changes and (with @workspace) even where to make the changes, but it's not allowed to make the changes for you. It's up to you to add the suggested changes and test it.

Here are some other things you can say to fine-tune the answer you get:

Change this code to use the data source jdbc/AZURE_MYSQL_CONNECTIONSTRING_DS.
Some imports in your code are using javax but I have a Jakarta app.
I want this code to run only if the environment variable AZURE_MYSQL_CONNECTIONSTRING is set.
I want this code to run only in Azure App Service and not locally.

Next steps

Azure for Java Developers

Learn more about running Java apps on App Service in the developer guide.

Configure a Java app in Azure App Service

Learn how to secure your app with a custom domain and certificate.

Secure with custom domain and certificate

Share via

Tutorial: Build a Tomcat web app with Azure App Service on Linux and MySQL

Prerequisites

1. Run the sample

2. Create App Service and MySQL

3. Secure connection secrets

4. Confirm JNDI data source

5. Deploy sample code

6. Browse to the app

7. Stream diagnostic logs

8. Clean up resources

2. Create Azure resources and deploy a sample app

3. Verify connection strings

4. Confirm JNDI data source

5. Modify sample code and redeploy

6. Browse to the app

7. Stream diagnostic logs

8. Clean up resources

Troubleshooting

I see many <Class> scanned from multiple locations warnings with mvn jetty:run

The portal deployment view for Azure Database for MySQL Flexible Server shows a Conflict status

The deployed sample app doesn't show the tasks list app

I see a 404 Page Not Found error in the deployed sample app

Frequently asked questions

How much does this setup cost?

How do I connect to the MySQL server behind the virtual network with other tools?

How does local app development work with GitHub Actions?

I don't have permissions to create a user-assigned identity

What can I do with GitHub Copilot in my codespace?

Next steps

Feedback

Additional resources

Share via

Tutorial: Build a Tomcat web app with Azure App Service on Linux and MySQL

Prerequisites

Skip to the end

1. Run the sample

2. Create App Service and MySQL

3. Secure connection secrets

4. Confirm JNDI data source

5. Deploy sample code

6. Browse to the app

7. Stream diagnostic logs

8. Clean up resources

2. Create Azure resources and deploy a sample app

3. Verify connection strings

4. Confirm JNDI data source

5. Modify sample code and redeploy

6. Browse to the app

7. Stream diagnostic logs

8. Clean up resources

Troubleshooting

I see many <Class> scanned from multiple locations warnings with mvn jetty:run

The portal deployment view for Azure Database for MySQL Flexible Server shows a Conflict status

The deployed sample app doesn't show the tasks list app

I see a 404 Page Not Found error in the deployed sample app

Frequently asked questions

How much does this setup cost?

How do I connect to the MySQL server behind the virtual network with other tools?

How does local app development work with GitHub Actions?

I don't have permissions to create a user-assigned identity

What can I do with GitHub Copilot in my codespace?

Next steps

Feedback

Additional resources