What is Docker?
Imagine that Docker is like a big ship carrying containers. Well, inside the
containers will contain the merchandise. Hypothesize that the merchandise
are "Docker images", so structure of docker similar :
1. What is the container?
What is the containers?
Container is like virtual environment in python. It's contain several Docker
image, Docker image is instance or object of container.
Container is a way to package applications with all the necessary
dependencies and configuration.
Easily shared and moved around between a development team or
deployment and operations team
Makes development and deployment more efficient
2. Different before container & after container
👍How did we develop applications before the containers?Usually when you
have a team of developers working on some application, you would have to
install most of the services on your operating system directly. Alright, for
example developing some Javascript application. And every developer in the
team would configure them and run them on the local development
environment and depending on which operating system they are using
installation process will look actually different. Also, another thing with
installing services like this is that you have multiple steps of installation, but
several steps going wrong and error happening is actually pretty high. And
this approach of setting up a new environment can actually be pretty
tedious, depending on how complex your application. For example, if you
have 10 services that your application is using then you would have to do
that 10 times on each operating system environment.
Installation process different on each OS environment
Many steps where something could go wrong
👍So now let's see how containers solve some of these problems with
containers. With containers, you actually do not have to install any of the
services directly on your operating system. Because the container is own
isolated operating system layer with Linux based image. So you have
the PostgresSQL, pakage with a configuration in the start script inside
of one container. And the download step is just one docker command which
fetches the container and starts it at the same time. So we have 10
applications that your Javascript application uses and depends on, you would
just have to run 10 docker commands for each container and that will be it.
Which makes the setting up your local development enviroment actually
much easier and much more efficient than the previous version.Also, you can
actually have different versions of the same application running on your local
environment without having any conflict.
own isolated environment
package with all needed configuration
one command to install the app
run same app with 2 different versions
Docker compare to Virtual Machine
Docker virtualize is the application layer. So, when you dowload a docker
image, it actually contains the applications layer of the operating system and
some other applications installed on top of it. And it use the kernel of the
host because it doesn't have its own kernel.
Virtual Machine (VM) has the applications layer and its own kernel, so
virtualize is the complete operating system, which means that when you
download a virtual machine image on your host, it doesn't use your kernel. It
puts up its own.
So what is this difference between Docker and Virtual Machine actually mean
? So first of all, the size of Docker images are much smaller because they just
have to implement one layer. A second one is the speed so you can run and
start docker container much faster than VM. The third difference is
compatibility.
Installation docker
Docker can install on the multiple flatforms, such as : Mac, Linux, Window.
Link tutorial Iam working with deep learning then by default you use ubuntu.
Detail description install : link
1. Set up the responsitory
$ sudo apt-get update
$ sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --
dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
$ echo \
"deb [arch=$(dpkg --print-architecture)
signed-by=/usr/share/keyrings/docker-archive-keyring.gpg]
https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list >
/dev/null
2. Install Docker Engine
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
3. Inspect install
$ sudo docker run hello-world
If result is " Hello from docker ", the installation was successful.
Base commands in docker
docker ps : list running containers
docker ps -a : lists running and stopped container
docker images: list images
docker rmi: remove image
docker rmi <image_id>
docker build: building image
docker build -t <image_name> .
docker run: start new container with a command
docker run -it --rm -d -p <port_host>:<container_host> --name <name>
<image_name>
docker pull: pull docker image from docker hub
docker push: push image to docker hub
docker login
docker tag <container_name> <user_name>/<responsitory>:<tag>
docker push <user_name>/<responsitory>:<tag>
docker stop: stop the container
docker stop <container_name>
docker start: start stopped container
docker logs: debug containers
docker logs <containers_id>
docker exec -it: use review or debug containers
docker exec -it <container_id> /bin/bash
You can refer to PhamDinhKhanh's article very good.
Build docker
Structure :
1. Build Dockerfile
Dockerfile is used to create an image for our application. This image will run
on any host or environment with Docker installed.
Let's have an overview of whats in our Dockerfile:
FROM: A Dockerfile must start with a From instruction with an
argument that has anather image.
FROM okwrtdsh/anaconda3:cpu
RUN: Will execute terminal commands during build image.
RUN pip install -r requirements.txt <br>
RUN pip install tensorflow
WORKDIR: It is similar to the cd command.
WORKDIR /app
LABEL: Provide metadata information for images such as: email,
company,author,...
EXPOSE: Port
COPY: This command copies files from the local system onto the
Docker image.
COPY ./app
ADD: similar COPY
CMD: This command specifies the program or file that will be
excecuted when the container initializes.
Syntax: CMD ["executable", "param1","param2"]
CMD ["python3","app.py"]
ENV: parameters environment
ARG: similar argument parser in python
Eg Dockerfile:
