Docker实战

1 MySQL高可用集群-PXC

PXC官网：https://www.percona.com/

多主 + 同步复制的方案 + 强一致性

docker中PXC镜像就是将mysql镜像包装了一层，以便进行高可用集群的搭建，搭建步骤如下：

#拉取percona-xtradb-cluster的镜像
docker pull percona/percona-xtradb-cluster:5.7.21

#tag一下
docker tag percona/percona-xtradb-cluster:5.7.21 pxc
docker images

#创建一个单独的网段，给mysql数据库集群使用
docker network create --subnet=172.19.0.0/24 pxc-cluster-net
docker network ls
docker network inspect pxc-cluster-net

#创建volume，为了给3个container持久化数据使用
docker volume create pxc-v1
docker volume create pxc-v2
docker volume create pxc-v3
docker volume ls

#创建node1容器
docker run -d --name=node1 -p 3301:3306 -v pxc-v1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=test666 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=test666 --net=pxc-cluster-net --priviledge pxc
docker ps
docker inspect node1
#创建node2容器
docker run -d --name=node2 -p 3302:3306 -v pxc-v2:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=test666 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=test666 --net=pxc-cluster-net -e CLUSTER_JOIN=node1 pxc
docker ps
docker inspect node2
#创建node3容器
docker run -d --name=node3 -p 3303:3306 -v pxc-v3:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=test666 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=test666 --net=pxc-cluster-net -e CLUSTER_JOIN=node1 pxc
docker ps
docker inspect node3

MYSQL其他高可用集群方案：

1. MMM: Master-Master Replication Manager for MySQL：支持故障转移、主从切换
2. MHA：Master High Availability：支持故障主持、主从切换

2 Docker Compose-实战

官网：https://docs.docker.com/compose/

Docker Compose能够在 Docker 节点上，以单引擎模式(Single-Engine Mode)进行多容器应用的部署和管理。也就是单节点的容器编排工具。

2.1 需求

访问一个网页地址，每次能够得到访问的次数，采用Python+Redis实现 Python写后台代码，Redis作为次数存储 python写好业务代码，将其通过Dockerfile生成image，然后创建一个container redis镜像直接从镜像仓库获取。

2.2 创建py业务代码的image

1. 创建文件夹compose-case

mkdir compose-case
cd compose-case

2. 编写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.\n'.format(count)

3. 在compose-case下新建requirements.txt文件

flask
redis

4. 编写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
COPY . .
CMD ["flask", "run"]

5. 根据Dockerfile构建image并查看

docker build -t python-app-image .
docker images

2.3 之前的方式

# 创建网络
docker network create --subnet=172.20.0.0/24 app-net
# 创建python程序的container，并指定网段
docker run -d --name web -p 5000:5000 --network app-net python-app-image
# 创建redis的container，并指定网段
docker run -d --name redis --network app-net redis:alpine
# 访问测试
curl centosip:5000

2.4 docker-compose实现

1. 安装docker-compose

#或者手动下载安装包并放到指定目录下重命名
sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/dockercompose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose
docker-compose version

2. 创建docker-compose.yaml文件

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    networks:
      - app-net
  redis:
    image: "redis:alpine"
    networks:
      - app-net

networks:
  app-net:
    driver: bridge

3. 启动并访问测试

docker-compose up -d
curl centosip:5000

4. 扩容

docker-compose up --scale web=5 -d
docker-compose ps
docker-compose logs web

5. docker-compose使用指南

(1) 查看版本
	docker-compose version
(2) 根据yml创建service
	docker-compose up
	指定yml：docker-compose up -f xxx.yml
	后台运行：docker-compose up -d
(3) 查看启动成功的service
	docker-compose ps
	也可以使用docker ps
(4) 查看images
	docker-compose images
(5) 停止/启动service
	docker-compose stop/start
(6) 删除service[同时会删除掉network和volume]
	docker-compose down
(7) 进入到某个service
	docker-compose exec redis sh

3 Docker Swarm

Docker Swarm是管理跨节点容器的编排工具，相较于Docker Compose而言，Compose只能编排单节点上的容器，Swarm将一群Docker节点虚拟化为一个主机，使得用户只要在单一主机上操作就能完成对整个容器集群的管理工作。

目前使用较多的是K8S，Swarm使用较少