Published
Jul 22 2022 12:05 PM
4,904
Views
How to containerize and deploy a Java app to Azure
Use containers for platform independence
An application that runs in a container behaves the same, wherever you run it. That's because the container provides a stable infrastructure environment that doesn't change. You just take it to wherever you want to run it.
This also enables you to run self-contained applications that do not rely on a runtime, like the Java runtime, to be installed on its host. And this experience is enhanced with cloud-based management and features when you run your containers in a service like Azure Kubernetes Service.
In this post, we'll containerize a Java application, push it to Azure Container Registry, and run it in Azure Kubernetes Service.
Prerequisites
If you want to follow along, you'll need the following:
* An Azure subscription (If you don't have an Azure subscription, create a free account before you begin)
* The latest version of Visual Studio Code
* The Git CLI
* And the latest version of the Azure CLI
Containerize a Java app and deploy it to Azure Kubernetes Service
In this post, we'll focus on the containerization and deployment of a Java application. Because of that, we start with an existing Azure Kubernetes Service and an Azure Container Registry. Let's get started.
1. Open Visual Studio Code
2. Go to View > Command Palette and type Git: Clone and select the first result
3. Enter the following URL, which is for a sample Java application:
https://github.com/Azure-Samples/containerize-and-deploy-Java-app-to-Azure.git4. Hit Enter and select a location to clone the Git repo
5. When asked, click "Open" to open the Java application
(Sample Java application in VS Code)
6. We need to add a Dockerfile to the code to be able to containerize it. Navigate to Project > Airlines in the source code and add a new file with the name "Dockerfile", without a file extension
7. When VS Code detects that you added a Dockerfile, it will prompt you to install the Docker extension. Click Install to install the extension
8. Go back to the newly created Dockerfile and paste in the following code. This specifies a build and package process to containerize the application:
#
# Build stage
#
FROM maven:3.6.0-jdk-11-slim AS build
WORKDIR /build
COPY pom.xml .
COPY src ./src
COPY web ./web
RUN mvn clean package
#
# Package stage
#
FROM tomcat:8.5.72-jre11-openjdk-slim
COPY tomcat-users.xml /usr/local/tomcat/conf
COPY --from=build /build/target/*.war /usr/local/tomcat/webapps/FlightBookingSystemSample.war
EXPOSE 8080
CMD ["catalina.sh", "run"]
9. Next, we'll build the container. Open a terminal window by right-clicking on the Airlines folder in the file explorer of VS Code, and selecting "Open in integrated terminal"
10. In the terminal, execute the following command to build the container:
docker build -t flightbookingsystemsample
11. When the build is complete, test the application locally by running the command below:
docker run -p 8080:8080 flightbookingsystemsample
12. You'll be able to use the application when you open http://localhost:8080/FlightBookingSystemSample in a local browser
(The containerized Java application running locally)
13. Now that we've successfully containerized the application, we will push it to Azure Container Registry and run it in Azure Kubernetes Service. Make sure that you have the names of the resource group that these services are deployed in, and that you have the names of the Azure Container Registry and Azure Kubernetes Service
(The resource group and service names in Azure)
14. We'll feed the resource group and service names into parameters that we can use in later scripts by executing the following command: (replace the values with your own)
AZ_RESOURCE_GROUP=kubernetes
AZ_CONTAINER_REGISTRY=myjavaregistry
AZ_KUBERNETES_CLUSTER=javacluster
15. First, make sure that you are logged into Azure by running:
az login
//optionally execute the following to select the correct Azure subscription
az account list --output table
az account set --subscription "<YOUR_SUBSCRIPTION_ID>"
16. Next, log into the Azure Container Registry:
az acr login -n $AZ_CONTAINER_REGISTRY
17. Now tag the previously built container image with your Azure Container Registry:
docker tag flightbookingsystemsample $AZ_CONTAINER_REGISTRY.azurecr.io/flightbookingsystemsample
18. Push the container to Azure Container Registry:
docker push $AZ_CONTAINER_REGISTRY.azurecr.io/flightbookingsystemsample
(Push the container to Azure Container Registry)
19. To deploy the container to Azure Kubernetes Service, we'll add a new file to the source code. In the Project > Airlines folder, add a file with the name "deployment.yml"
20. Paste the following code into the file. Replace the name of the Azure Container Registry with your own. These are instructions to take the container from Azure Container Registry and deploy it into Azure Kubernetes Service:
apiVersion: apps/v1
kind: Deployment
metadata:
name: flightbookingsystemsample
spec:
replicas: 1
selector:
matchLabels:
app: flightbookingsystemsample
template:
metadata:
labels:
app: flightbookingsystemsample
spec:
containers:
- name: flightbookingsystemsample
image: <AZ_CONTAINER_REGISTRY>.azurecr.io/flightbookingsystemsample:latest
resources:
requests:
cpu: "1"
memory: "1Gi"
limits:
cpu: "2"
memory: "2Gi"
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: flightbookingsystemsample
spec:
type: LoadBalancer
ports:
- port: 8080
targetPort: 8080
selector:
app: flightbookingsystemsample
21. To enable the Azure CLI to deploy the container, we need to install the CLI AKS extension with this command:
az aks install-cli
22. Next, connect to your Kubernetes cluster:
az aks get-credentials --resource-group $AZ_RESOURCE_GROUP --name $AZ_KUBERNETES_CLUSTER
23. Now apply the deployment file to start the deployment:
kubectl apply -f deployment.yml
24. Check the deployment with the command below. When it is finished, you'll see that your pod has the status "Running". You can now use the external-ip from service/flightbookingsystemsample to use the application:
(The containerized Java application running in Azure Kubernetes Service)
Conclusion
Containers provide a programming-language agnostic platform in which to run applications. And with Azure Container Registry and Azure Kubernetes Service, managing and running your containerized applications is easier and more performant. To learn more, create a trial account today and go and check it out!