This post is not meant for any Docker/Microsoft Azure e­xpert. But for people like me, who already wrote some Java code and may have peeked a little bit into the Docker topic. Who have never touched “the cloud”, but are interested to see if this is possible without that much background or even if it can be done without spending any money in the first place. To see how you can achieve this in just a few hours of work…

• If you already have a suitable Java project, start with step 2.
• If you already have a dockerized Java application, you can start with step 3.
• If it is crashing for you in step 3, you can give it a try or you may go back to step 1.
• If you already have some Docker container running in Azure, you are in the wrong place here ;-)

Step 1: Let’s have a small and simple Java application

Because I wanted to start quickly with the actual deployment, I decided to go for a new SpringBoot project. However, it should also work with most of the “basic” Java projects you can find out there.

If you have a project yourself, just try it out. If you just don’t feel like making things on your own, here is what I chose to do.

I decided to build a tiny RESTful web service and added the following controller class to the project.

 To check if this works I also added the following line to the application.properties file.

You should now be able to build and run your application. To test this in a browser go to: localhost:8085/azure/docker/hello

Your browser should lie to you now, but hopefully not for long.

If you found this boring, you should have jumped directly to step 2. If this was new for you: congratulations, you run your first SpringBoot RESTful service. If you feel ready, continue to the next level.

Step 2: Put it in a Docker container

Now we want to deploy our application inside a Docker container. “Why one should do such a thing” and how to install Docker on your machine will not be covered here, so I jump right into what I did next. To build a new Docker image we create a Dockerfile within the project repository.

Along with our application we have to put all needed dependencies and libraries as well. Fortunately, there are plenty of images out there you can build on. All we need is a version of the openjdk image provided by the public repository on DockerHub. I decided to go for the latest alpine release, because it leads to smaller images which will be beneficial especially in the cloud.

Adding our recently created application and opening the port 8085the Dockerfile will look as follows:

To get a better name for the build artifact I just add the following lines to the build.gradle file.

To build the new image, run the following command in the Powershell (inside your project’s repository):

To check if we didn’t mess things up, we try to create a container instance from the image we just created.

If you see this output, you did it right.

Again, we can simply test it: localhost:8085/azure/docker/hello

Congratulations! If you still see the message in your browser, now a bit less exaggerating than before, you have a running Java application, this time deployed inside a Docker container.

If you find it tedious to build a local Docker image as in the intermediate step when we only want to run the container in Azure, you should have a look at this alternative way.

Step 3: Finally, deploy your container to the cloud

Last but not least, we can finally take a look at the cloud provider, namely Microsoft Azure. When you visit the website it–hopefully still–tells you that you can have a free Azure account for at least some time. Please create yourself an account by following the instructions there.

Hopefully, you could successfully create an account for yourself. When you now head to the portal home you are greeted by quite an overloaded but simple to use GUI overview. I will show you how to use it to run your first Java code inside the cloud in no time.

Add all the following components to your account by selecting “Create a resource …”.

First you need to create a “Resource group”, where you’ll put all the components that belong together later on.

You only need to select a name and region. Which values you choose doesn’t matter too much for now. For simplicity just keep the default selection. Then add a “Container Registry”, where we can push our recently created Docker image.

It is also possible to skip this step and work without an own “Container Registry” on Azure. You can also use a local repository or some other repository to which you have access to. For example, you can use your DockerHub repository. But then you need to upload the image each time you want to redeploy it.

Here is my selection, which is sufficient for a small example like ours. Please make sure to enable “Admin user” if you want to use the docker login option later.

To push our image to the right place we first have to tag it accordingly. In the Powershell do:

To actually push the image to this registry you need to first login with your account credentials. There are several ways to do this, and some of them seem quite troublesome. I decided to use Azure CLI, which you can either run in the Cloud Shell or install on your machine (that’s what I did). Now you simply log in with your account credentials. This generates a token, which is automatically reused in the subsequent steps. In the shell do:

You can now log in to your “Container Registry” without further authentication. All further Docker commands are now also provided with the access token.

If you don’t want to go for the Azure CLI option, you can also log in with Docker. Having enabled “Admin user” in the “Container Registry” you can get the credentials from “deployjavaregistry/Access keys”.

Hopefully, you overcome the authentication step and we can push our image to the cloud. In case you have problems with authentication, this page may help you.

This may take some time depending on your connection. Check in “deployjavaregistry/Repositories” if the image safely arrived. If so, we can finally deploy it by choosing the image and select “Run instance”.

Give it a name and select port 8085. After the process finished you should find a new “Container instance” in your “Resource group”. By selecting it, you should be able to get its public IP address.

Let’s see if our code stopped spreading fake news: {IPAddress}:8085/azure/docker/hello

Well done! You have deployed a containerized Java application in Azure!

Now, feel free to play around with your account and image. If you care about the cost, make sure you delete the services you don’t need anymore.

I hope you could follow along and enjoyed the little trip to the cloud. Stay tuned for further posts to come.