docker_进阶

安装

# 安装工具包
yum install bridge-utils
yum install yum-utils
# 国内镜像位置
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 更新索引
yum makecache fast
# 安装
yum install docker-ce docker-ce-cli containerd.io
# 启动
systemctl docker start
# 测试
docker run hello-world
# 卸载
systemctl stop docker
yum -y remove docker-ce  docker-ce-cli containerd.io
rm -rf /var/lib/docker

# 加速镜像
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json<< -'EOF'
{
"registry-mirrors":["https://自己的阿里云加速地址"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

Docker 基础，原理，网络，服务，集群，错误排查，日志

Docker Compose

• 没有compose：dockerfile --》build--》run

• 高效的定义，管理，运行多个容器：批量容器编排

  • 定义DOCKERFILE
  • 定义docker-compose.yml
  • docker-compose up

安装，官网下载很慢

curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m`>/usr/local/docker-compose
chmod +x /usr/local/docker-compose
docker-compose version

示例

mkdir test
cd test

# app.py
import time
import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.
'.format(count)

# requirements.txt
flask
redis

# Dockerfile
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

# docker-compose.yml
version: '3'
services:
  web:
    build: .   # 使用当前Dockerfile构建镜像
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"  # 使用现成镜像

# build
docker-compose build
# 启动
docker-compose up -d

• 创建网络

• 执行docker-compose.yml

• 启动服务

  • 就是里面的镜像

• 默认服务名：文件名_服务名__num（运行实例个数）

• 网络

  • docker network ls
  • 通过compose启动，就会生成网络，因此项目中网络都是一个
  • 访问时不用ip，使用服务名，更简洁，在springboot配置文件中 spring.redis.host=redis

version: "3.8"
services:

  redis: # 服务
    image: redis:alpine
    ports:
      - "6379"
    networks:
      - frontend
    deploy:
      replicas: 2
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure

  db: # 服务
    image: postgres:9.4
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend
    deploy:
      placement:
        max_replicas_per_node: 1
        constraints:
          - "node.role==manager"

  vote:
    image: dockersamples/examplevotingapp_vote:before
    ports:
      - "5000:80"
    networks:
      - frontend
    depends_on:
      - redis
    deploy:
      replicas: 2
      update_config:
        parallelism: 2
      restart_policy:
        condition: on-failure

  result:
    image: dockersamples/examplevotingapp_result:before
    ports:
      - "5001:80"
    networks:
      - backend
    depends_on:
      - db
    deploy:
      replicas: 1
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure

  worker:
    image: dockersamples/examplevotingapp_worker
    networks:
      - frontend
      - backend
    deploy:
      mode: replicated
      replicas: 1
      labels: [APP=VOTING]
      restart_policy:
        condition: on-failure
        delay: 10s
        max_attempts: 3
        window: 120s
      placement:
        constraints:
          - "node.role==manager"

  visualizer:
    image: dockersamples/visualizer:stable
    ports:
      - "8080:8080"
    stop_grace_period: 1m30s
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
    deploy:
      placement:
        constraints:
          - "node.role==manager"

networks:
  frontend:
  backend:

volumes:
  db-data:

# java dockerfile例子
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8888"]
EXPOSE 8888
ENTRYPOINT ["java","-jar","/app.jar"]

version: '3.8'
services:
	javaservice:
		build: .
		image: javaservice
		depends_on:
			- redis
		ports:
			- "8888:8888"
	redis:
		image: "redis:alpine"

集群 Docker Swarm

• 集群方式部署，主机更多的时候使用k8s
  • xshell命令同步操作安装docker
• 工作模式

# swarm 集群初始化
docker swarm init --advertise-addr ip1 # 初始化节点 默认是lader，是管理节点
# 令牌生成
docker swarm join-token worker
docker swarm join-token manager
# 加入集群work。manager使用令牌加入
# worker，manager：Reachable，loader
# 一般情况管理节点大于等于3个，此时有损坏的开可以使用，若2管理节点，损坏一个后就不能使用了，即最少2个管理可使用，否则就会docker集群就不能使用了，raft协议：保证大多数节点存活
# docker node ls 查看节点
# docker swarm leave 离开集群

docker service，之前的集群，不能动态扩容，缩容

• 容器---》服务--》副本

# nginx 集群
# 服务启动 滚动更新，扩容，缩容，docker run不可以
docker service -p 8888:80 --name my_nginx nginx # 会随机在worker启动
# 查看服务信息
docker service ps my_nginx
# 查看服务列表
docker service ls
# my_nginx 创建副本
docker service update --relipcas 3 my_nginx
# 作用同上
docker service scale my_nginx=3
# 访问时访问集群中任何一个都可以 https://ip1:8888,https://ip2:8888,即使ip2没有服务，但它在集群中
# 缩小
docker service update --relipcas 1 my_nginx

# 移除服务
docker service rm my_nginx

扩展：网络模式

overlay：集群中不同主机上的docker是不能ping的，此模式使用虚拟ip，完成此功能

imgress：overlay的进一步开发，有负载均衡作用

Docker stack

# 单机docker-compose
docker-compose up -d
# 集群docker stack
docker stack deploy
# 也是基于yaml文件，与compose格式类似

Docker secret

统一秘钥管理

Docker config

统一配置管理

扩展到k8s

• 云原生时代，直接云端下载应用，购买服务器，部署k8s即可使用

• go语言，天生的并发语言，docker，kvs，v8等都是go开发的