# Docker

# Concepts

# Main components

• Docker Hub: store Docker Image
• Docker Engine: create Docker Image & run Docker Container
• Docker Machine: create Docker Engine on Server
• Docker Compose: run application by defining Docker Container configuration in file
• Docker Image: (immutable)
• Docker Container: …

# Benifits

# How it works

Docker's architecture comprises three main components:

🔹 Docker Client This is the interface through which users interact. It communicates with the Docker daemon.

🔹 Docker Host Here, the Docker daemon listens for Docker API requests and manages various Docker objects, including images, containers, networks, and volumes.

🔹 Docker Registry This is where Docker images are stored. Docker Hub, for instance, is a widely-used public registry.

Read more (opens new window)

# Workflow

# Use cases

# Reduce Docker Image Size

# 1. Using distroless/minimal base images.

Use Alpine: Lightweight, Minimalist, Security-focused

# 2. Multistage builds

FROM node:16

COPY . .

RUN npm install

EXPOSE 8080

CMD [ "node", "index.js" ]

FROM node:16 as build

WORKDIR /app
COPY package.json index.js env ./
RUN npm install

FROM node:alpine as main

COPY --from=build /app /
EXPOSE 8080
CMD ["index.js"]

# 3. Minimizing the number of layers

Docker images work in the following way – each RUN, COPY, FROM Dockerfile instructions add a new layer & each layer adds to the build execution time & increases the storage requirements of the image.

# 4. Understanding caching

As Docker uses layered filesystem, each instruction creates a layer. Due to which, Docker caches the layer and can reuse it if it hasn’t changed. => installing dependencies & packages earlier inside the Dockerfile before the COPY commands.

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update -y && \
    apt-get upgrade -y && \
    apt-get install -y vim net-tools dnsutils

COPY . .

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive

COPY . .

RUN apt-get update -y && \
    apt-get upgrade -y && \
    apt-get install -y vim net-tools dnsutils

# 5. Keeping data elsewhere

• As a rule, only the necessary files need to be copied over the docker image. Docker can ignore the files present in the working directory if configured in the .dockerignore file.
• Storing application data in the image will unnecessarily increase the size of the images.
• It’s highly recommended to use the volume feature of the container runtimes to keep the image separate from the data.

# Commands

# Image

docker images

docker pull <image:tag>
# E.g: 
docker pull centos:6.10 

docker inspect  <ID or NAME>

docker rm <ID or NAME>

docker rm -f <ID or NAME>

docker rmi $(docker images) -f

docker save --output <filename> <ID or NAME>
# e.g:
docker save --output myimage.tar khank-ubuntu

docker load -i <filename>

docker tag f <image-name:tag>

# Container

docker ps 

docker ps -a 

docker start <ID or NAME>

docker stop  <ID or NAME>

docker attach <ID>

Ctrl + P, Ctrl + Q

docker rm -f <ID or NAME>

docker kill $(docker ps -q)

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <ID or NAME>

# Save as Image

Container must be stoped before committing.

docker commit <container-name> <new-image-name:tag>

# Run

# Expose Port

docker run -d -p 5801:5800 --name vnc1 myvnc 

multi ports

docker run -d -p 5801:5801 -p 5802:5802 .....

# Volume

docker run -it -v <path-host>:<container-path> <ID or NAME>
# E.g:
docker run -it -v /Users/nguyenkhank/Desktop/jav:/home/dulieu ubuntu

Use the same data:

docker run -it --name C2 --volumes-from C1 ubuntu:latest

# With Volume

docker run -it --name <container-name> --mount source=<volume-name>,target=<container-path> <image-name:tag>
# E.g:
docker run -it --name C1 --mount source=D1,target=/home/dulieu ubuntu:16.0.4

Case volume mounted with device

docker run -it --name <container-name> --mount source=<volume-name>,target=<container-path> <image-name:tag>
# E.g:
docker run -it --name C1 -v DISK1:/home/dulieu ubuntu:16.0.4

# Exit

# Exit and Stop Docker Container

• Ctrl+C to send the SIGINT signal and stop the process. Next, press Ctrl+D to exit and stop the container.
• Alternatively, type exit

# Exit Docker Container without Stopping It

• press Ctrl+P followed by Ctrl+Q. This operation detaches the container and allows you to return to your system's shell.

# Volume

docker volume ls

docker volume create <Volume-name>
# E.g:
docker volume create D1

docker create --opt device=<path-host> --opt type=none --opt o=bind <volume-name>
# E.g
docker create --opt device=/Users/nguyenkhank/Desktop/jav --opt type=none --opt o=bind DISK1

docker volume inspect <Volume-name>
# E.g
docker volume inspect D1

docker volume rm <Volume-name>
# E.g
docker volume rm D1

# Network

Detail (opens new window) Detail (opens new window)

docker network ls 

docker network create –-driver DRIVER_NAME name 
# E.g
docker network create –-driver bridge new_nw 

docker network connect <NetworkName>  <container-name>
# E.g
docker network connect my_network my_container

docker network inspect <NetworkName> 

# Other

Info

docker info
docker -v

Help

docker image --help

Search

docker search <keyword>

# Simple build

const app = express();

// your code
const PORT = 8080;
const HOST = '0.0.0.0';
app.listen(PORT, HOST);

{
    "scripts": {
        "start": "node server.js"
    }
    // dependencies

    // dev dependencies
}

FROM node:16

WORKDIR /app

COPY package*.json /app/

RUN npm install

COPY . .

EXPOSE 8080

CMD ["node", "server. js"]

docker build -t yourname/yourapp:v1

docker build -t yourname/yourapp:v2

docker images

docker push yourname/yourapp:v1

docker push yourname/yourapp:v2

docker run -d -p 8080:8080 yourname/yourapp:v1

docker run -d -p 8080:8081 yourname/yourapp:v2

# Docker vs K8S