How does a Docker commit work

What is docker

With Docker, we can pack our application and the associated platform (operating system, runtime environment, libraries ...) into an image and have it played on any device. The basic requirement is that Docker is installed on the device. Docker can read the image and creates a container that runs on all devices, whether on a computer, laptop or cloud.

Install Docker

So that Docker can be installed and also works on Mac and Windows, we need an additional program: boot2docker. Once boot2docker is downloaded and installed, it can be started. In the terminal we have to enter. As soon as: is executed in the terminal and there is no error message such as: no such file or directory. Are you trying to connect to a TLS-enabled daemon without TLS? Is everything ok.

What should I do if I get an error message?

In your terminal window you have to initialize boot2docker: Execute the following command: and try again with. If you like you can add $ (boot2docker shellinit) to your .bash_profile. After that, boot2docker should start automatically with each new terminal window.

Install Docker on Linux

Docker runs natively on Linux. Simply select the distribution and follow the instructions: Docker installation

Docker image

An image is a kind of template. This template can be an operating system (e.g. Ubuntu), which in turn contains an NGINX, PHP or Node.js installation. The application itself can also be stuck in an image. We can easily share our image with other developers. The image can be used anywhere with Docker. Docker also offers its own for images.

We can also use our terminal to look for images:

Load image

Once we run docker pull nginx we can add an image to our docker. With docker images we can list all images.

Docker container

A container is an image that is currently being executed. When an image is also executed, it is called a container. It is like a process. We can list all containers with docker ps (similar to Linux ps).

Control containers

A container can be stopped with. If one is also executed, the container will be removed. If you want to start a container, you first have to find out the ID of the container. shows only running containers. If you also want to see all finished containers, enter the following:. Your container will be restarted with. Otherwise it works with.

Container vs Images

What is the difference between an image and a container?

An image is a blueprint for Docker. An image only has "read-only" rights and can only be read. A container is an instance of an image and can be changed at runtime.

Create image

There are two ways to create or expand an image. Once with Dockerfile or with "Commits", the latter being a little more necessary than a commit. But more on that later. Let's start with the Dockerfile first.

Dockerfile

We create a "Dockerfile" in our project folder. A Dockerfile contains all commands for creating an image. In the following list, I have listed a selection of the Dockerfile commands.

FROM

From contains an image that we want to use. As a basis we can use an operating system e.g. FROM ubuntu: latest. The prerequisite for this is that the image has been pulled before!

RUN

Run contains a Linux command for the shell e.g.

ADD

With add files can be loaded into the container or overwritten. Useful when config files need to be overwritten. Example: ADD ./our-config/nginx.conf /etc/nginx/nginx.conf.

EXPOSE

With Expose, containers can be bound to a specific port. e.g. EXPOSE 80

Here is a Dockerfile example:

Once we have our Dockerfile, we can make an image of it using the following Docker command:

With -t we can assign a tag name to our image. Start the image as a container:

The "-d" ensures that the container runs in the background.

If we call up http://127.0.0.1 in the browser, our "my-image-name" should run. If you use my example file you should see "echo phpinfo ()". For those using boot2docker, http://127.0.0.1 will not work. To do this, you must first call up the terminal and use the IP displayed. For me it is: 192.168.59.103

Alternative to Dockerfile

Images and containers can also be created without a Dockerfile by using the command. In the next section, I'll explain how to create a Node.js image. I don't use a Dockerfile for this, but instead.

Load Ubuntu from the repository

We open our terminal. The first step with Docker is to pull an operating system.

We get the ubuntu image:. Then we start the Ubuntu container:. The "-i" and "-t" allow us to control the ubuntu console. With some images an additional "/ bin / bash" is required! . After that we should be in Ubuntu.

Start the Ubuntu Container

First we need to refresh our package list. Because no packages can be installed beforehand. apt-get update. After the update we can download "nodejs" and "npm" packages.

If we run npm -v and nodejs -v we should see version numbers. Then we create a / www folder and in this we save an index.js file.

Now the index.js file has to be written. We either edit it in the container or on our system and overwrite the index.js. If it is to be edited on the server, an editor should be installed beforehand:

Then the index.js can be edited with nano:

or if there is already an index.js on your system, this can also be loaded onto the container. But I'll skip that at this point. In the end, the index.js should look like this:

Docker commit

Now nodejs and npm are installed on our container. In addition, there is also an index.js, which should represent our application. Now we want to make an image out of our container. To do this, we leave ubuntu with the exit command. With exit we close the container. When we run docker ps, no container should be running anymore. However, we need the ubuntu container ID for the next step. We can call this with docker ps -a. We run docker ps -a and note the container ID (copy)

With docker commit we can make an image of our container.

If you want to overwrite the ubuntu image:

If you want to create a new image:

Now we should have a "my-nodejs" image. We can start this in the background:

If we call up http://127.0.0.1:8000 or http://192.168.59.103:8000 in the browser, we should see our application.

A little note about index.js:

With we can replace the index.js with our local one instead of having to edit with nano.

By using our services, you consent to our use of cookies. Privacy Policy