How to deploy your first application with Docker

In the previous article, you have installed Docker Desktop and enabled Kubernetes. Next, you can deploy applications in containerized form. Typically, the development workflow includes the following:

1. First create a Docker image to create and test individual containers for each component of the application.

2. Assemble the container and supporting infrastructure into a complete application, which can be achieved using Docker stack file or Kubernetes YAML.

3. Test, share, and deploy complete containerized applications.

In this post, we will focus on step 1 of this workflow: creating an image based on an existing container. Remember that a Docker image captures the private filesystem that the containerized process will run in; we need to create an image that contains exactly what our application needs to run.

A containerized development environment is easier to set up than a traditional development environment, once you learn how to build images, which we discuss below. This is because the containerized development environment isolates all the dependencies required by the application in the Docker image; in addition to Docker, there is no need to install anything on the development computer (that is, the deployment of the development environment depends only on the Docker image). This way, you can easily develop applications for different stacks without changing any environment on your development machine.

Configuration

1. Clone the sample project for demonstration from GitHub.

git clone -b v1 https://github.com/docker-training/node-bulletin-board

cd node-bulletin-board/bulletin-board-app

This is a simple bulletin board application written in node.js. For this example, let's assume that you wrote this application and are now trying to deploy it in a container. The directory structure is shown in Figure 1.1.

Figure 1.1

Look at the file named Dockerfile, which describes how to assemble a private file system for the container and also contains some metadata that describes how to run the container based on this image. The bulletin board application Dockerfile is shown in Figure 1.2.

Figure 1.2

The first step in deploying a containerized application is to write a Dockerfile. You can think of these Dockerfile commands as a single step to create an image. The steps are as follows:

1. Use the image with version number 6.11.5 as the base image for this build. 6.11.5 The basic image is the image provided by node.js official

2. Specify the working directory of the image file system as /usr/src/app, that is, each time you log in to a container created based on this image, the directory will automatically switch to /usr/src/app

3. Copy the package.json file to the current location of the image, i.e. /usr/src/app/package.json

4. Run the npm install command in the image file system (it will read package.json to determine the node dependencies of the application and install them)

5. Copy the rest of the application’s source code from the host into the image.

You can see that these steps are largely the same as what you might take to set up and install the application on your host, but using a Dockerfile allows us to build it again in a portable, standalone Docker image (the official Node.js image).

The above steps build the file system for the image, but there is one more line in the Dockerfile, the CMD command line. CMD ["Program to run", "Parameter 1", "Parameter 2"] tells the command or script to run when the container starts. The command in the Dockerfile tells this image that the containerized process to support is npm start.

Note: A Dockerfile can only have one CMD command. If there are multiple commands, the last one will be executed.

A Dockerfile always starts with a FROM command. The above is a simple Dockerfile. For more Dockerfile instructions, see the Dockerfile reference.

Build and test the image

Now that we have the source code and the Dockerfile, it’s time to build our first image and make sure that containers launched from that image work as expected.

Note: This example uses Linux containers. For users who use Docker Desktop, right-click the Docker logo in the system tray and make sure your environment is running Linux containers. If not, click “Switch to Linux containers...”. As shown in Figure 1.3, my current demonstration environment is already using Linux containers.

Figure 1.3

1. Enter Powershell and make sure your current directory is node-bulletin-board/bulletin-board-app, as shown in Figure 1.4, and execute the command

# docker image build -t bulletinboard:1.0 . 

Figure 1.4

At the end of the build, the following message will be output, indicating that the image is built successfully.

Successfully built 49f9b9fb7daf

Successfully tagged bulletinboard:1.0

The above command list creates an image named bulletinboard with tag 1.0, as shown in Figure 1.5.

Figure 1.5

2. Run a container named bb based on the bulletinboard image and run it in background mode, mapping the internal port 8080 of the container to port 8000 of the host machine.

# docker container run --publish 8000:8080 --detach --name bb bulletinboard:1.0

We can use the following command to see what parameters can be followed by the run command

# docker container run --help

We log in to the container and see that the current directory is the working directory set in the Dockerfile, as shown in Figure 1.6.

Figure 1.6

3. Access your application through http://localhost:8000. You will see the following interface, as shown in Figure 1.7, which means that the application container deployment is successful. The next step is to test, build, publish, and share.

Figure 1.7

4. Deleting a container means the life cycle of the container ends.

# docker container rm --force bb

Summarize

With the above in place, we have been able to perform a simple containerization of our application and confirm that our application is running successfully within its container. The next step will be to write the Kubernetes yaml files that describe how to run and manage containers on Kubernetes.

In addition, we should strengthen our practice of using Dockerfile to build images.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.