Docker学习笔记05---Docker Compose、Docker Swarm分布式部署

zoukankan html css js c++ java

Docker学习笔记05---Docker Compose、Docker Swarm分布式部署
Docker学习笔记05---Docker Compose、Docker Swarm分布式部署

Docker Compose

简介

之间的DockerFile部署模式 DockerFile build run 手动操作，单个容器！

如果是一个微服务，上百个微服务怎么办，这个时候就用到 Docker Compose 来轻松高效的管理容器，自定义运行多个容器！

三个步骤：
1. Dockerfile保证我们的项目在任何地方运行。
2. services 是什么服务
3. docker-compose.yml
4. 启动项目
自己的理解:

Compose是Docker官方开源的项目，需要安装！

Compose
```
version: "3.9"  # optional since v1.27.0
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}
```
docker-compose up 100个服务

Compose:重要的概念
1. 服务service，容器，应用（web，redis，mysql。。）
2. 项目project，一组关联的容器。博客，web，mysql，wp等
安装

1、下载
```
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# 推荐使用下面的连接，较快
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
```
2、对二进制文件应用可执行权限
```
赋权：sudo chmod +x /usr/local/bin/docker-compose

执行：docker-compose version
```
pip的安装
```
pip install docker-compose
```
体验

python应用，做一个计数器，使用redis工具；
1. 应用 app.py
2. Dockerfile 文件应用打包为镜像
3. Docker-compose yml 文件（定义整个服务，需要的环境，web，redis）完整的上线服务！
4. 启动compose项目（docker-compose up）
流程：
1. 创建网络
2. 执行docker-compose yml
3. 启动服务
docker-compose yml

1、创建文件夹
```
[root@localhost /]# cd home/
[root@localhost home]# ls
ccq
[root@localhost home]# mkdir composetest
[root@localhost home]# cd composetest/
[root@localhost composetest]# ls
```
2、创建一个app.py文件
```
[root@localhost composetest]# vim app.py
[root@localhost composetest]# ls
app.py
```
```
# 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)

if __name__ == "__main__":
    app.run(host=0.0.0.0,debug=True)
```
3、创建requirements.txt
```
[root@localhost composetest]# vim requirements.txt
[root@localhost composetest]# ls
app.py  requirements.txt
```
```
#requirements.txt
flask
redis
```
4、创建Dockerfile
```
[root@localhost composetest]# vim Dockerfile
[root@localhost composetest]# ls
app.py  Dockerfile  requirements.txt
```
```
# syntax=docker/dockerfile:1
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"]

#Dockerfile

FROM python:3.6-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
```
5、创建docker-compose.yml
```
[root@localhost composetest]# vim docker-compose.yml
[root@localhost composetest]# ll
总用量 16
-rw-r--r--. 1 root root 569 8月  17 15:31 app.py
-rw-r--r--. 1 root root 135 8月  17 15:40 docker-compose.yml
-rw-r--r--. 1 root root 252 8月  17 15:38 Dockerfile
-rw-r--r--. 1 root root  12 8月  17 15:34 requirements.txt
```
```
#docker-compose.yml

version: "3.8"
services:
  web:
    build: .
    ports:
      - 5000:5000
    volumes:
      - .:/code
  redis:
    image: "redis:alpine"
    
#docker-compose.yml
version: "3.3"
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"
    
    
```
6、执行docker-compose up
```
[root@localhost composetest]# docker-compose up
Creating network "composetest_default" with the default driver
Building web
Step 1/10 : FROM python:3.7-alpine
3.7-alpine: Pulling from library/python
29291e31a76a: Pull complete
3626a090061d: Pull complete
```
默认的服务名命名规则为文件名_服务器__num

多个服务器，集群，A B _num 副本数量

服务器redis 服务=>4个副本

集群状态，服务都不可能只有一个运行实例，弹性 10 HA 高并发

kubectl service 负载均衡。

3、网络规则

10个服务==>项目（项目中的内容都在同一个网络下，域名访问）

如果在同一个网络下、我们可以直接通过域名访问！

停止：docker-compose down CTRL+C

小结

docker-compose

以前都是单个 docker run容器

docker-compose，通过 docker-compose编写yml配置文件、可以通过compose 一键启动所有的容器，停止！

docker小结
1. Dockers镜像 run===>容器
2. DockerFile构建镜像（服务打包）
3. docker-compose 启动项目（编排，多个微服务/环境）
4. Docker网络！
yml规则

docker-compose.yml是核心
```
# 一共有三层

version: '' # 版本
server: # 版本
	服务1:web
	#  服务配置
        images
        build
        network
        .....
	服务2：redis
	....
	服务3:redis
# 其他配置 网络/卷、全局规则
Volumes:
network:
configs:
```
开源项目测试：

搭建博客：

下载程序、安装数据库、配置。。。。

compose应用===> 一键启动

1、下载项目(docker-compose.yml)

2、如果需要文件按、Dockerfile

3、文件准备齐全（直接一键启动项目！）

前台启动

docker -d

后台启动

docker-compose up -d

实战

1、编写项目微服务

2、dockerfile构建镜像

3、docker-compose.yml编排项目

4、丢到服务器 docker-compose up
```
# 1、创建一个空的项目目录。
[root@localhost home]# mkdir my_wordpress/
# 2、切换到您的项目目录。
[root@localhost home]# cd my_wordpress/
# 3、创建一个docker-compose.yml文件来启动您的 WordPress博客和一个单独的MySQL实例，该实例具有用于数据持久性的卷挂载 
[root@localhost my_wordpress]# vim docker-compose.yml
version: "3.3"
    
services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    
  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}
# 4、构建项目
#现在，docker-compose up -d从您的项目目录运行。
#这docker-compose up在分离模式下运行，拉取所需的 Docker 镜像，并启动 wordpress 和数据库容器，如下面的示例所示。
[root@localhost my_wordpress]# docker-compose up -d
# 5、docker-machine ip MACHINE_VM获取机器地址，然后http://MACHINE_VM_IP:8000在 Web 浏览器中打开 .
```
测试启动
```
docker-compose up
docker-compose build
```
小结：

未来项目只要有 docker-compose文件，按照这个规则，启动编排容器！

公司：docker-compose 直接启动

网上的开源项目：docker-compose 一键启动

假设项目需要重新部署打包
```
docker-compose up --build # 重新构建
```
小结

工程、服务、容器

项目 compose:三层
1. 工程Porject
2. 服务服务
3. 容器运行实例！ docker k8s 容器
Docker Swarm

购买服务器

集群至少3台

购买4台服务器 2G

1、点击控制台

2、选择云服务器

3、创建实例

5、购买集群

6、网络安全组

7、系统配置

8、分组设置、确认订单

9、查看实例

用4台机器安装docker

工作模式

操作都在manager

swarm搭建集群

初始化节点 docker swarm init

私网、公网

172.24.82.149

docker swarm join

docker swarm join
```
# 获取令牌
docker swarm join-token manager
docker swarm join-token worker
```
生成的令牌在任何一个manager上就可以了

1、生成主节点init

2、加入（管理者、worker)

目标：双主从节点！（一般至少三个主节点）

1、生成主节点

2、加入管理节点和工作节点
```
# 创建工作节点
docker swarm join-token worker
```
```
# 创建管理节点
docker swarm join-token manager
```
3、查看节点内容

Raft协议

双主双从：假设一个节点挂了！其他节点是否可以使用！

Raft协议：保证大多数节点存活才可以使用。只要>1,集群至少大于3台

实验：

1、将docker1机器停止，宕机！双主，另外一台主节点也不可以使用！

2、可以将其他节点离开

3、wrok就是工作的、管理节点的操作！ 3台机器设置为管理节点。

十分简单：集群，可用！3个主节点。大于1台管理节点存活！

Raft协议：保证大多数节点存活，才可以使用，高可用！
```
# 重启集群，自己的身份会改变
docker node ls
```
离开集群

生成令牌再次加入

体会

命令只能在manager上执行

弹性、扩缩容！集群

以后告别 docker run ！

docker-compose up！启动一个项目单机

集群：swarm docker serivce

容器=>服务

容器=>服务=>副本

redis服务=>10个副本(同时开启10个redis容器)

体验：创建服务、动态扩展服务、动态更新服务

灰度发布：金丝雀发布
```
docker run 容器启动！不具有扩缩容器
docker service 服务 具有扩缩容器 滚动更新！
```
查看服务 REPLICAS

1、启动创建项目
```
docker service create -p 8888:80 --name my-nginx nginx
# docker service 服务 具有扩缩容器 滚动更新！
```
2、查看是否启动成功
```
docker service ps my-nginx
docker service ls
```
3、查看网络信息
```
docker service inspect my-nginx
```
4、随机分布在集群上，动态扩缩容，创建多个副本
```
docker service update --replicas 3 my-nginx
# 服务，集群中任意一个节点都可以访问。服务可用有多个副本动态扩缩容实现高可用！
```
```
# 动态括缩容
docker service scale my-nginx
```
5、移除服务

虽然是在docker-1机器上创建的，但1、2、4上都没有这个docker进程

跑到了3上，docker-3也是manager节点

动态更新nginx成3个副本，1上没有，2、3、4都有nginx。但用1的ip访问也能访问到nginx

如果开10个时，四个节点上分别跑3、3、2、2个nginx容器。
同样的命令也可以再设置成只有1个副本

服务，集群中任意一个节点都可以访问。服务可用有多个副本动态扩缩容实现高可用！

弹性、扩缩容！

10台！10000台！虚拟化

服务的高可用，任何企业，云

k8s!云原生应用

相对而言：docker swarm 其实并不难

只要会搭建集群、会启动服务、动态管理容器就可以了

k8s更难、功能更多。swarm相当于简单版的k8s

概括总结

swarm

集群的管理和编号。docker可以初始化一个swarm集群，其他节点可以加入。（管理、工作者）

Node

就是一个docker节点。多个节点就组成了一个网络集群。（管理、工作者）

Service

任务，可以在管理节点或者工作节点来运行。核心！用户访问！

Task

容器内的命令，细节任务！

Service

命令--管理--api--调度--工作节点--（创建Task容器维护创建）

kubectl get pod

kubectl service api

服务副本于全局服务

调整service以什么方式运行
```
--mode string
Service mode (replicated or global)(default "replicated")
docker service create --mode replicated --name mytom tomcat:7 默认的

docker service create --mode global --name haha alpine ping baidu.com

# 场景？ 日志收集
每一个节点都有自己的日志收集器，过滤，把所有的日志最终再传给日志中心
服务监控 状态性能
```
拓展：网络模式：’PublishMode“：”ingress“

Swarm

Overlay

ingress：特殊的Overlay网络！负载均衡的功能！IPVS VIP

虽然docker在4台机器上，实际网络是同一个！ ingress网络，是一个特殊的Overlay网络

Overlay可使多个相互；ping不同的机器联通并变成一个整体

Docker Stack

docker-compose 单机部署项目
Docker Stack 部署，集群部署
```
# 单机
docker-compose up -d wordpress.yml
# 集群
docker stack deploy wordpress-yml
# docker-compose 文件
```
Dockers Secret

安全！配置密码！证书！

k8s中也有这个概念，学k8s的时候再说

Docker Config

拓展到K8s

云原生时代

Go语言！

超过10台用k8s不用swarm
愿路途漫长，以后莫失莫忘。愿你不骄不躁，安稳顺心。

归档：我的知识栈：目录(更新中...）

作者：菜鸟-传奇

本文版权归作者和博客园共有，不以任何盈利为目的，欢迎转载。
查看全文

相关阅读:
Android Training
Android Training
简述Activity与Window关系
 简述Activity生命周期
 Python基础之元组及range
python基础数据类型之列表
 python之字符串
 python基础之int整型
 python基础知识之格式化
 Python基础知识初识 (二)

原文地址：https://www.cnblogs.com/cainiao-chuanqi/p/15157272.html

Docker学习笔记05---Docker Compose、Docker Swarm分布式部署

Docker学习笔记05---Docker Compose、Docker Swarm分布式部署

Docker Compose

简介

Compose

安装

1、下载

2、对二进制文件应用可执行权限

pip的安装

体验

流程：

1、创建文件夹

2、创建一个app.py文件

3、创建requirements.txt

4、创建Dockerfile

5、创建docker-compose.yml

小结

yml规则

开源项目测试：

搭建博客：

实战

小结：

小结

Docker Swarm

购买服务器

1、点击控制台

2、选择云服务器

3、创建实例

5、购买集群

6、网络安全组

7、系统配置

8、分组设置、确认订单

9、查看实例

用4台机器安装docker

工作模式

swarm搭建集群

1、生成主节点

2、加入管理节点和工作节点

3、查看节点内容

Raft协议

实验：

离开集群

生成令牌再次加入

体会

1、启动创建项目

2、查看是否启动成功

3、查看网络信息

4、随机分布在集群上，动态扩缩容，创建多个副本

5、移除服务

概括总结

Docker Stack

Dockers Secret

Docker Config

拓展到K8s

愿路途漫长，以后莫失莫忘。 愿你不骄不躁，安稳顺心。

愿路途漫长，以后莫失莫忘。愿你不骄不躁，安稳顺心。