Docker Overview

Docker implements container-based virtualization, offering near-native performance compared to full virtualization solutions. The technology leverages Linux containers (LXC) and other kernel-level features to provide lightweight OS virtualization.

Core Components:

• Images: Read-only templates used to create containers
• Containers: Isolated runtime environments runing applications
• Client: CLI tool communicating with Docker daemon via API
• Host: Physical or virtual machine running the Docker daemon
• Registry: Storage location for Docker images (e.g., Docker Hub)
• Machine: CLI utility simplifying Docker installation

Installation

CentOS 6

yum install -y docker-io
service docker start

CentOS 7

yum -y install docker
systemctl start docker
systemctl enable docker

Image Operations

Searching and Pulling Images

docker search ubuntu
docker pull ubuntu:latest

Listing and Removing Images

docker images
docker rmi ubuntu:latest
docker rmi -f image_id  # force removal

Export and Import

docker save ubuntu > /opt/ubuntu_backup.tar.gz
docker save -o /opt/ubuntu_backup.tar.gz ubuntu:22.04

docker load < /opt/ubuntu_backup.tar.gz
docker load --input /opt/ubuntu_backup.tar.gz

Tagging Images

docker tag nginx nginx_1.14.0
docker tag nginx_1.14.0:latest nginx:latest

Container Lifecycle

Creating and Starting Containers

docker run --name webserver -itd ubuntu /bin/bash
docker start ab  # using first two characters of container ID

Inspecting Containers

docker ps -a
docker ps -a -q  # list all container IDs
docker inspect container_name
docker inspect -f '{{.Architecture}}' nginx

Stopping and Removing

docker stop container_id
docker kill container_id
docker rm container_id
docker rm -f container_id  # force remove running container
docker rm $(docker ps -a -q)  # remove all stopped containers

Accessing Running Containers

Using attach:

docker attach container_id
# Note: All attached sessions sync display; blocking in one affects others

Using exec (recommanded):

docker exec -it webserver /bin/bash

Using nsenter:

yum install -y util-linux
PID=$(docker inspect --format '{{.State.Pid}}' container_id)
nsenter -t $PID -m -u -i -n -p

Container Export/Import

docker export container_id > container.tar.gz
cat container.tar.gz | docker import - ubuntu:custom

Essential Docker Commands

docker build        # create image from Dockerfile
docker commit       # create image from container
docker cp           # copy files between container and host
docker create       # create new container (not started)
docker diff         # show changes in filesystem
docker events       # real-time events from daemon
exec                # run command in running container
docker export       # export container as tar archive
docker history      # show image layer history
docker images       # list local images
docker info         # system information
docker inspect      # detailed container/image metadata
docker kill         # stop container immediately
docker load         # load image from tar archive
docker login/logout # registry authentication
docker logs         # container log output
docker pause/unpause # suspend/resume containers
docker port         # show port mappings
docker ps           # list containers
docker pull/push    # image registry operations
docker rename       # rename container
docker restart      # restart container
docker rm/rmi       # remove containers/images
docker run          # create and start container
docker save         # save image to tar archive
docker search       # search registry
docker start/stop   # manage container state
docker stats        # resource usage statistics
docker tag          # tag image
docker top          # running processes in container
docker update       # update container configuration
docker version      # client/server versions
docker wait         # wait for container exit

Port Mapping

# Map all interfaces
docker run -d -p 8080:80 nginx
docker run -d -p 8080:80 -p 443:443 nginx

# Map to specific host address
docker run -d -p 127.0.0.1:8080:80 nginx

# Map to random port on specific address
docker run -d -p 127.0.0.1::80 nginx

# Display port mappings
docker port container_name

Data Management

Data Volumes

docker run -itd --name webapp -v /host/data:/container/data ubuntu
# Host directory mounted to container directory

Data Volume Containers

# Create container with data volume
docker run -it -v /dbdata --name dbstore ubuntu

# Mount volume from dbstore to new container
docker run -it --volumes-from dbstore --name db1 ubuntu

# Multiple volumes
docker run -itd --name db3 --volumes-from db1 --volumes-from db2 ubuntu

# Note: Volume containers need not be running; removing container doesn't delete volumes
# Use docker rm -v to remove container with volumes

Data Migration

Backup:

docker run --volumes-from dbstore -v /backup:/backup --name backup ubuntu \
  tar cvf /backup/backup.tar /dbdata

Restore:

docker run -itd -v /dbdata --name newdb ubuntu
docker run --volumes-from newdb -v /backup:/backup --name restore ubuntu \
  tar xvf /backup/backup.tar

Creating Images

Manual Method

# Start base container
docker run -itd --name custom_app ubuntu

# Install dependencies inside container
docker exec -it custom_app bash
apt-get update
apt-get install -y nginx
useradd -s /sbin/nologin -M www-data

# Create image from modified container
docker commit -m "nginx installed" container_id myuser/nginx:v1

# Run new image
docker run -d -p 8080:80 myuser/nginx:v1 nginx -g 'daemon off;'

Automated Build with Dockerfile

FROM ubuntu:22.04
MAINTAINER developer

RUN apt-get update && apt-get install -y \
    wget gcc make libssl-dev libpcre3-dev

ADD http://nginx.org/download/nginx-1.24.0.tar.gz /
RUN tar zxvf nginx-1.24.0.tar.gz

RUN useradd -s /sbin/nologin -M www-data
RUN cd nginx-1.24.0 && ./configure --prefix=/usr/local/nginx \
    --user=www-data --group=www-data && make && make install

COPY nginx.conf /usr/local/nginx/conf/nginx.conf
RUN echo 'daemon off;' >> /usr/local/nginx/conf/nginx.conf

EXPOSE 80
ENTRYPOINT ["/usr/local/nginx/sbin/nginx"]

docker build -t myuser/nginx:v2 /path/to/dockerfile/
docker images
docker run -itd -p 92:80 myuser/nginx:v2

Dockerfile Instructions:

• FROM: Base image
• MAINTAINER: Image maintainer
• RUN: Execute commands during build
• ADD: Add files (supports URLs, auto-extracts tar)
• WORKDIR: Set working directory
• VOLUME: Create mount point
• EXPOSE: Expose ports
• CMD: Default command at runtime
• ENV: Environment variables
• COPY: Copy files (no URL support)
• ENTRYPOINT: Fixed entry command
• USER: Runtime user
• ARG: Build-time variables
• SHELL: Default shell

Resource Limits

CPU Constraints

# CPU share (relative weight, default 1024)
docker run -d --cpu-shares 512 nginx

# Limit to specific cores
docker run -d --cpus 1.5 nginx

# Bind to CPU cores
docker run -d --cpuset-cpus=0,1 nginx

Memory Constraints

docker run -d -m 512m nginx
docker run -d -m 512m --memory-swap 1g nginx
docker run -d -m 512m --memory-swappiness=0 nginx
docker run -d -m 512m --memory-reservation 256m nginx
docker run -d -m 512m --oom-kill-disable nginx

I/O Limits

docker run -d --blkio-weight=100 nginx
docker run -d --device /dev/sda:/dev/sda --device-read-bps /dev/sda:1mb nginx
docker run -d --device /dev/sda:/dev/sda --device-write-bps /dev/sda:1mb nginx

Resource Inspection

# View CPU binding
docker exec container_id taskset -c -p 1

# Check memory limits
cat /cgroup/memory/docker/container_id/memory.limit_in_bytes
cat /cgroup/memory/docker/container_id/memory.memsw.limit_in_bytes

Private Registry

Setup

docker run -d -p 5000:5000 registry

# Persistent storage
docker run -d -p 5000:5000 -v /data/registry:/var/lib/registry registry

Push and Pull

docker tag nginx 192.168.1.100:5000/mynginx:v1
docker push 192.168.1.100:5000/mynginx:v1

# Configure insecure registry
# Edit /etc/docker/daemon.json
{
  "insecure-registries": ["192.168.1.100:5000"]
}
# Restart Docker

docker pull 192.168.1.100:5000/mynginx:v1

# Verify
curl http://192.168.1.100:5000/v2/_catalog

Web Management Interface

Shipyard Installation

# Configure Docker API access
# Edit /etc/sysconfig/docker
other_args="-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock"
systemctl restart docker

# Start RethinkDB data volume
docker run -itd --name shipyard-rethinkdb-data \
  --entrypoint /bin/bash shipyard/rethinkdb -l

# Start RethinkDB
docker run -itd -P --name shipyard-rethinkdb \
  --volumes-from shipyard-rethinkdb-data shipyard/rethinkdb

# Start Shipyard controller
docker run -itd -p 8080:8080 --name shipyard \
  --link shipyard-rethinkdb:rethinkdb shipyard/shipyard

Access via browser: http://host_ip:8080 (admin/shipyard)

Quick Install

curl -sSL https://shipyard-project.com/deploy | bash -s

Networking

# List networks
docker network ls

# Network drivers: bridge (default), host, none

# Use host networking
docker run -it --net=host ubuntu bash

# Disable networking
docker run -itd --net=none --name isolated ubuntu

Custom Bridge Network

ip link set docker0 down
brctl delbr docker0
brctl addbr br0
ip addr add 192.168.100.1/24 dev br0
ip addr del 192.168.1.10/24 dev eth0
brctl addif br0 eth0
ip link set br0 up
route add default gw 192.168.100.254

Process Management with Supervisor

[supervisord]
nodaemon=true

[program:nginx]
command=/usr/sbin/nginx
autostart=true
autorestart=true

[program:php-fpm]
command=/usr/sbin/php-fpm
autostart=true
autorestart=true

[program:mysql]
command=/usr/bin/mysqld_safe
autostart=true
autorestart=true