如果您对Docker容器化部署Python应用感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于Docker容器化部署Python应用的详细内容，我们还将为您解答docker容

如果您对Docker 容器化部署 Python 应用感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于Docker 容器化部署 Python 应用的详细内容，我们还将为您解答docker容器化python开发环境的相关问题，并且为您提供关于18. docker 容器部署 python-redis、5 分钟，教你用 Docker 部署一个 Python 应用！、AspNetCore容器化(Docker)部署(四) —— Jenkins自动化部署、BI 系统打包 Docker 镜像及容器化部署的具体实现的有价值信息。

• Docker 容器化部署 Python 应用（docker容器化python开发环境）
• 18. docker 容器部署 python-redis
• 5 分钟，教你用 Docker 部署一个 Python 应用！
• AspNetCore容器化(Docker)部署(四) —— Jenkins自动化部署
• BI 系统打包 Docker 镜像及容器化部署的具体实现

Docker 容器化部署 Python 应用（docker容器化python开发环境）

1. 简介

Docker 是目前主流 IT 公司广泛接受和使用的，用于构建、管理和保护它们应用程序的工具。

容器，例如 Docker 允许开发人员在单个操作系统上隔离和运行多个应用程序，而不是为服务器上的每个应用程序专用一个虚拟机。使用容器更轻量级，可以降低成本、更好地使用资源和发挥更高的性能。

本文将使用 Flask 开发一个简单的 Python web 应用程序，并为 “容器化” 做好准备。然后创建一个 Docker 映像，并将其部署到测试和生产环境中。

注意： 请确保机器上已安装 Docker，如果没有请参考 Docker 官方安装教程。

2. Docker 介绍

Docker 是一种工具，它使开发人员能够交付他们的应用程序 (以及库或其他依赖项)，确保他们可以使用正确的配置运行，而不受部署环境影响。

这是通过将应用程序隔离在单独的容器中来实现的，这些应用程序虽然被容器分隔开，但是却可以共享操作系统和其他资源。

Docker 包含两部分:

• Docker Engine — 应用打包工具，用于封装应用程序。

• Docker Hub — 用于管理云上容器应用程序的工具。

3. 为何选择容器

了解容器的重要性和实用性非常重要，虽然它和直接将应用部署到服务器没有多大区别，但是当涉及到比较复杂的且相当吃资源的应用，尤其是多个应用部署在同一台服务器，或是同一应用要部署到多台服务器时。容器就变得非常有用。

在容器之前，这是通过 VMWare 和 Hypervisor 等虚拟机解决的，但是它们在效率、速度和可移植性方面已被证明并不是最佳选择。

Docker 容器是虚拟机的轻量级的替代品 - 与 VM 不同，我们不需要为它预先分配 RAM、CPU 或其他资源，也不需要为每个应用程序启动一个 VM，仅仅只需要一个操作系统即可。

使用容器开发人员就不需要为不同环境制定特殊版本，这样可以专注于应用程序的核心业务逻辑。

4. 创建 Python 应用

Flask 是 Python 的一个轻量级 Web 应用框架，简单易用，可以很快速地创建 web 应用。我们用它来创建此 demo 应用。

如果还没有安装 Flask 模块，可以使用下面命令安装:

$ pip install flask

安装成功后，新建一个应用目录，命名为 FlaskDemo。并在该目录下创建应用代码文件 app.py。

在 app.py 中，首先引入 Flask 模块，然后创建一个 web 应用:

from flask import Flask

app = Flask(__name__)

然后定义路由 / 和其对应的请求处理程序:

@app.route("/")
def index():  
  return """
  <h1>Python Flask in Docker!</h1>
  <p>A sample web-app for running Flask inside Docker.</p>
  """

最后，添加运行主程序并启动该脚本:

if __name__ == "__main__":  
    app.run(debug=True, host=''0.0.0.0'')

$ python app.py

然后在浏览器中访问 http://localhost:5000/, 可以看到 Dockerzing Python app using Flask 这样的页面。

5.Dokcer 打包应用

要在 Docker 上运行应用程序，首先必须构建一个容器，而且必须包含使用的所有依赖项 —— 在我们的例子中只有 Flask。因此，新建一个包含所有依赖包的 requirements.txt 文件，然后创建一个 Dockerfile，该文件用来描述构建映像过程。

此外，当启动容器时还需要放开应用程序的 HTTP 端口。

准备工作

requirements.txt 文件非常简单，只需要填入项目的依赖包和其对应版本即可：

Flask==1.0.2 

接下来，需要将应用程序运行所需的所有 Python 文件都放在顶层文件夹中，例如，名为 app 的目录。

同时建议将主入口程序命名为 app.py ，将脚本中创建的 Flask 对象命名为 app 是一种通常的做法，这样也可以简化部署。

FlaskApp  
    ├── requirements.txt
    ├── Dockerfile
    └── app
        └── app.py
        └── <other .py files>

创建 Dockerfile

Dockerfile 本质上是一个文本文件，其中明确定义了如何为我们的项目构建 Docker 镜像。

接下来创建一个基于 Ubuntu 16.04 和 Python 3.X 的 Dokcer 镜像:

FROM ubuntu:16.04

MAINTAINER jhao104 "j_hao104@163.com"

RUN apt-get update -y && \  
    apt-get install -y python3-pip python3-dev

COPY ./requirements.txt /requirements.txt

WORKDIR /

RUN pip3 install -r requirements.txt

COPY . /

ENTRYPOINT [ "python3" ]

CMD [ "app/app.py" ] 

Dockerfile 的基本指令有十三个，上面用到了部分；

• FROM - 所有 Dockerfile 的第一个指令都必须是 FROM ，用于指定一个构建镜像的基础源镜像，如果本地没有就会从公共库中拉取，没有指定镜像的标签会使用默认的 latest 标签，如果需要在一个 Dockerfile 中构建多个镜像，可以使用多次。

• MAINTAINER - 描述镜像的创建者，名称和邮箱。

• RUN - RUN 命令是一个常用的命令，执行完成之后会成为一个新的镜像，通常用于运行安装任务从而向映像中添加额外的内容。在这里，我们需更新包，安装 python3 和 pip 。在第二个 RUN 命令中使用 pip 来安装 requirements.txt 文件中的所有包。

• COPY - 复制本机文件或目录，添加到指定的容器目录，本例中将 requirements.txt 复制到镜像中。

• WORKDIR - 为 RUN、CMD、ENTRYPOINT 指令配置工作目录。可以使用多个 WORKDIR 指令，后续参数如果是相对路径，则会基于之前命令指定的路径。

• ENTRYPOINT - 在启动容器的时候提供一个默认的命令项。

• RUN - 运行 app 目录中的 app.py 。

Docker 镜像构建原理

Docker 镜像是使用 Docker build 命令构建的。在构建镜像时，Docker 创建了所谓的 “层 (layers)”。每一层都记录了 Dockerfile 中的命令所导致的更改，以及运行命令后镜像的状态。

Docker 在内部缓存这些层，这样在重新构建镜像时只需要重新创建已更改的层。例如，这里使用了 ubuntu:16.04 的基础镜像，相同容器的所有后续构建都可以重用它，因为它不会改变。但是，因为项目修改，在下次重新构建过程中 app 目录的内容可能会有所不同，因此只会重新构建这一层。

需要注意的是，每当重新构建某一层时，Dockerfile 中紧随其后的所有层也都需要重新构建。例如，我们首先复制 requirements.txt 文件，然后再复制应用程序的其余部分。这样之前安装的依赖项只要没有新的依赖关系，即使应用程序中的其他文件发生了更改，也不需要重新构建这一层。这一点在创建 Dockerfiles 时一定要注意。

因此，通过将 pip 安装与应用程序其余部分的部署分离，可以优化容器的构建过程。

构建 Docker 镜像

现在 Dockerfile 已经准备好了，而且也了解了 Docker 的构建过程，接下来为我们的应用程序创建 Docker 映像:

docker build -t docker-flask:0.1 .

调试模式运行

根据前面讲到的容器化的优点，开发的应用程序通过容器部署，这从一开始就确保了应用程序构建的环境是干净的，从而消除了交付过程中的意外情况。

但是呢，在开发应用程序的过程中，更重要的是要快速重新构建和测试，以检查验证过程中的每个中间步骤。为此，web 应用程序的开发人员需要依赖于 Flask 等框架提供的自动重启功能（Debug 模式下，修改代码自动重启）。而这一功能也可以在容器中使用。

为了启用自动重启，在启动 Docker 容器时将主机中的开发目录映射到容器中的 app 目录。这样 Flask 就可以监听主机中的文件变化 (通过映射) 来发现代码更改，并在检测到更改时自动重启应用程序。

此外，还需要将应用程序的端口从容器转发到主机。这是为了能够让主机上的浏览器访问应用程序。

因此，启动 Dokcer 容器时需要使用 volume-mapping 和 port-forwarding 选项：

docker run --name flask_app -v $PWD/app:/app -p 5000:5000 docker-flask:0.1

改命令将会执行以下操作:

• 基于之前构建的 docker-flask 镜像启动一个容器；

• 这个容器的名称被设置为 flask_app 。如果没有 ——name 选项，Docker 将为容器生成一个名称。显式指定名称可以帮助我们定位容器 (用来停止等操作)；

• -v 选项将主机的 app 目录挂载到容器；

• -p 选项将容器的端口映射到主机。

现在可以通过 http://localhost:5000 或者 http://0.0.0.0:5000/ 访问到应用:

如果我们在容器运行的时候，修改应用程序代码，Flask 会检测到更改并重新启动应用程序。

要停止容器的话，可以使用 Ctrl + C, 并运行 docker rm flask_app 移除容器。

生产模式运行

虽然直接使用 Flask 裸跑运行应用程序对于开发来说已经足够好了，但是我们需要在生产中使用更健壮的部署方法。

目前主流的部署方案是 nginx + uwsgi，下面我们将介绍如何为生产环境部署 web 应用程序。Nginx 是一个开源 web 服务器，uWSGI 是一个快速、自我修复、开发人员和系统管理员友好的服务器。

首先，我们创建一个入口脚本，用来控制以开发模式还是生产模式启动我们的应用程序，这两者区别是选择直接运行 python 还是 nginx 模式。

然后再写一个简单 shell 启动脚本 entry-point.sh:

#!/bin/bash

if [ ! -f /debug0 ]; then  
  touch /debug0

  while getopts ''hd:'' flag; do
    case "${flag}" in
      h)
        echo "options:"
        echo "-h        show brief help"
        echo "-d        debug mode, no nginx or uwsgi, direct start with ''python3 app/app.py''"
        exit 0
        ;;
      d)
        touch /debug1
        ;;
      *)
        break
        ;;
    esac
  done
fi

if [ -e /debug1 ]; then  
  echo "Running app in debug mode!"
  python3 app/app.py
else  
  echo "Running app in production mode!"
  nginx && uwsgi --ini /app.ini
fi  

然后创建 uWSGI 配置文件 app.ini:

[uwsgi]
plugins = /usr/lib/uwsgi/plugins/python3  
chdir = /app  
module = app:app  
uid = nginx  
gid = nginx  
socket = /run/uwsgiApp.sock  
pidfile = /run/.pid  
processes = 4  
threads = 2 

和 nginx 配置文件 nginx.conf:

user nginx;
worker_processes  4;
pid /run/nginx.pid;

events {
    worker_connections  20000;
}

http {
    include    mime.types;
    sendfile on;
    keepalive_timeout  65;
    gzip off;

    server {
        listen 80;
        access_log off;
        error_log off;

        location / { try_files $uri @flaskApp; }
        location @flaskApp {
            include uwsgi_params;
            uwsgi_pass unix:/run/uwsgiApp.sock;
        }
    }
}

最后，修改 Dockerfile 将 nginx 和 uWSGI 安装到镜像，将配置文件复制到镜像中，并设置运行 nginx 所需的用户权限:

FROM ubuntu:16.04

MAINTAINER jhao104 "j_hao104@163.com"

RUN apt-get update -y && \
    apt-get install -y python3-pip python3-dev && \
    apt-get install -y nginx uwsgi uwsgi-plugin-python3

COPY ./requirements.txt /requirements.txt
COPY ./nginx.conf /etc/nginx/nginx.conf

WORKDIR /

RUN pip3 install -r requirements.txt

COPY . /

RUN adduser --disabled-password --gecos '''' nginx\
  && chown -R nginx:nginx /app \
  && chmod 777 /run/ -R \
  && chmod 777 /root/ -R

ENTRYPOINT [ "/bin/bash", "/entry-point.sh"]

然后重新打包镜像:

docker build -t docker-flask:0.1 .

然后使用 nginx 启动应用程序：

docker run -d --name flaskapp --restart=always -p 8091:80 docker-flask:0.1

该镜像包含 python、ngix、uwsgi 完整环境，只需要在部署时指定端口映射便可以自动部署应用。要停止并删除此容器，请运行下面命令：

docker stop flaskapp && docker rm flaskapp

此外，如果我们仍然需要上面调试功能或修改部分代码，也可以像上面一样以调试模式运行容器:

docker run -it --name flaskapp -p 5000:5000 -v $PWD/app:/app docker-flask:0.1 -d debug

6. 管理外部依赖

如果将应用程序作为容器交付时，需要记住的一个关键事项是，开发人员管理依赖项的责任增加了。除了识别和指定正确的依赖项和版本之外，还需要负责在容器环境中安装和设置这些依赖项。

在 Python 项目中管理安装依赖比较容易，可以使用 requirements.txt 指定依赖项和对应版本，然后通过 pip 安装。

需要重申的是是，无论何时修改 requirements.txt 文件，都需要重新构建 Docker 镜像。

启动时安装依赖项

可能在某次版本更新时需要安装额外的依赖项。比如，在开发过程中使用了一个新的包。如果不希望每次都重新构建 Docker 镜像，或者希望在启动时使用最新的可用版本。可以通过修改启动程序在应用程序启动时运行安装程序来实现这一点。

同样，我们也可以安装额外的系统级包依赖项。修改 entry-point.sh:

#!/bin/bash

if [ ! -f debug0 ]; then
  touch debug0
  
  if [ -e requirements_os.txt ]; then
    apt-get install -y $(cat requirements_os.txt)
    
   fi
   if [-e requirements.txt ]; then
    pip3 install -r requirements.txt
   fi

  while getopts ''hd:'' flag; do
    case "${flag}" in
      h)
        echo "options:"
        echo "-h        show brief help"
        echo "-d        debug mode, no nginx or uwsgi, direct start with ''python3 app/app.py''"
        exit 0
        ;;
      d)
        touch debug1
        ;;
      *)
        break
        ;;
    esac
  done
fi

if [ -e debug1 ]; then
  echo "Running app in debug mode!"
  python3 app/app.py
else
  echo "Running app in production mode!"
  nginx && uwsgi --ini /app.ini
fi

这样我们可以在 requirements_os.txt 中指定将要安装的系统软件包名称，这些包名以空格分隔放在同一行。他们将和 requirements.txt 中的 Python 依赖库一样在应用程序启动之前安装。

尽管这样对应用的迭代开发期间提供了便利，但是出于几个原因，在启动时安装依赖项不是一个好的实践：

• 它破坏了容器化的目标之一，即修复和测试由于部署环境的变化而不会改变的依赖关系；

• 增加了应用程序启动的额外开销，这将增加容器的启动时间；

• 每次启动应用程序时需要安装依赖项，这样对网络资源有要求。

18. docker 容器部署 python-redis

1. 编写 Vagrantfile 并创建虚拟机 并虚拟机绑定外部 192.168.205.10:8888 ip:port

# -*- mode: ruby -*-

# vi: set ft=ruby :

Vagrant.require_version ">= 1.6.0"

boxes = [

    {

        :name => "docker-node1",

        :eth1 => "192.168.205.10",

        :mem => "1024",

        :cpu => "1",

        :port => "8888"

    }

]

Vagrant.configure(2) do |config|

  config.vm.box = "centos/7"

  boxes.each do |opts|

      config.vm.define opts[:name] do |config|

        config.vm.hostname = opts[:name]

        config.vm.network "forwarded_port", guest: 80, host: opts[:port]

        config.vm.provider "vmware_fusion" do |v|

          v.vmx["memsize"] = opts[:mem]

          v.vmx["numvcpus"] = opts[:cpu]

        end

        config.vm.provider "virtualbox" do |v|

          v.customize ["modifyvm", :id, "--memory", opts[:mem]]

          v.customize ["modifyvm", :id, "--cpus", opts[:cpu]]

        end

        config.vm.network :private_network, ip: opts[:eth1]

      end

  end

  config.vm.synced_folder "./labs", "/home/vagrant/labs"

  config.vm.provision "shell", privileged: true, path: "./setup.sh"

end

2. 创建 labs 文件夹 及编写 setup.sh 文件

　　mkdir labs

　　vim setup.sh

#setup.sh 

#/bin/sh

　　# install some tools

　　sudo yum install -y wget

　　sudo mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo_bak

　　sudo wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

　　sudo yum makecache

　　sudo yum -y update

　　sudo yum install -y git vim gcc glibc-static telnet bridge-utils

# install docker

　　curl -fsSL get.docker.com -o get-docker.sh

　　sh get-docker.sh

# start docker service

　　sudo groupadd docker

　　sudo usermod -aG docker vagrant

　　sudo systemctl start docker

　　rm -rf get-docker.sh

　　sudo tee /etc/docker/daemon.json <<-''EOF''

　　{

  　　　　"registry-mirrors": ["https://v2ltjwbg.mirror.aliyuncs.com"]

　　}

　　EOF

　　sudo systemctl daemon-reload

　　sudo systemctl restart docker

　　docker version

3. 创建虚拟机

　　vagrant up

4. 创建 redis 容器  不用使用 -p 将 docker 参数暴露

　　docker run -d --name redis redis

5. 编写 dockerFile 文件

　　FROM python:2.7　　　　# 基础镜像为 python:2.7

　　LABEL maintaner="eaon eaon123@docker.com"  #创建者为 eaon

　　COPY . /app　　　　　　　　　　　　# 复制当前的文件到 /app 下

　　WORKDIR /app　　　　　　　　　　　　# 工作目录为 /app

　　RUN pip install flask redis　　　　　　# 安装 flask 和 redis

　　EXPOSE  5000　　　　　　　　　　   # 暴露 5000 端口进行访问

　　CMD　["python", "app.py"]　　　　　　# 运行 python app.py

6. build Dockerfile  创建镜像

　　docker build -t ''flask-redis'' .

7. 编写 python 文件 app.py

　from flask import Flask　　　　

　from redis import Redis

　import os

　import socket

　app = Flask(__name__)

   redis = Redis(host=os.environ.get(''REDIS_HOST'', ''127.0.0.1''), port=6379)

　@app.route(''/'')

　def hello ():　　　　// 定义 hello 函数　　1. 添加每次自增 hits  2 返回一句话

　　redis.incr(''hits'')

　　return ''Hello Container World! I have been seen %s times and my hostname is %s.\n'' % (redis.get(''hits''),socket.gethostname())

if __name__ == "__main__":

　　　app.run(host="0.0.0.0", port=5000, debug=True)

8. 创建 redis-flask 容器

　　docker run -d --link redis --name redis-flask -e REDIS_HOST=redis redis-flask

　　-d 为后台运行

　　--link redis 表示链接 redis 容器

　　--name 表示容器名为 redis-flask

　　-e 设置环境变量 REDIS_HOST=redis

　　最后为启动镜像的名称

9. 虚拟机内访问

　　将 redis-flask 添加参数 -p 4321:5000 并重新 创建容器　(前面是虚拟机的端口，后面是容器端口)

　　docker stop redis-flask && docker rm redis-flask

　　docker run -d --link redis --name redis-flask -p 4321:5000  -e REDIS_HOST=redis redis-flask

　　在虚拟机内 (容器外) 使用 curl 127.0.0.1:4321 即可访问 容器内的应用

10 在外部访问 虚拟机内的容器

　　将 redis-flask 修改参数 -p 8888:5000 并重新 创建容器　(前面是虚拟机的端口，后面是容器端口)

　　docker stop redis-flask && docker rm redis-flask

　　docker run -d --link redis --name redis-flask -p 8888:5000  -e REDIS_HOST=redis redis-flask

　　在浏览器使用 192.168.205.10:8888 即可访问 虚拟机的容器内的应用

11. 环境变量 设置

　　使用 -e env 可以自定义配置参数

　　创建镜像

　　docker run -d --name test -e EAON=eaon44 busybox /bin/sh -c "while true; do sleep 3600; done"

　　运行镜像

　　docker exec -it test /bin/sh

　　查看环境变量

　　env

5 分钟，教你用 Docker 部署一个 Python 应用！

我们在写完 python 程序之后，如果想要运行在服务器上，你会如何操作？

今天我就来和大家聊聊这个话题。

我们在使用传统物理机或云服务器上部署项目都会存在一些痛点，比如：项目部署速度慢、资源浪费、迁移难且扩展低。

而使用 Docker 部署项目的优势包含：

• 高效利用系统资源
• 服务启动更快
• 环境一致，迁移更加方便

今天将给大家介绍 Docker 部署一个 Python 项目的常规流程。

1. Dockerfile 描述文件

Dockerfile 是一个放置在项目根目录下的描述文件，可以利用 Docker 命令基于该文件构建一个镜像常用的指令包含：

• FROM

  用于定义基础镜像

• MAINTAINER

  指定维护者信息，可以省略不写

• RUN

  和「 安装命令 」连接在一起，可用于安装工具依赖包

• ADD

  将宿主机的文件，并进行解压

• COPY

  和 ADD 指令功能一样，但是不会进行解压操作

• WORKDIR

  用于切换工作目录

• VOLUME

  配置宿主机与容器的目录映射

• EXPOSE

  配置容器内项目对外暴露的端口号

• CMD

  指定容器启动后，运行的命令

  比如，可以运行某个命令启动项目

2. 实战一下

使用 Docker 部署应用的常规流程是：

• 开发项目并本地测试通过
• 编写 Dockerfile 放置到项目根目录
• 打包镜像文件
• 运行镜像容器
• 测试

为了演示方便，这里以一个简单的 Flask 项目为例进行讲解

2-1  项目开发

from flask import Flask

# 安装依赖
# pip3 install -U flask

app = Flask(__name__)


@app.route(''/'')
def index():
    return "测试容器部署!"


if __name__ == ''__main__'':
    app.run(host=''0.0.0.0'', port=8888)

# 浏览器访问测试
# http://127.0.0.1:8888/

项目开发完成，并在本地测试通过后就可以编写 Dockerfile 文件了

2-2  编写 Dockerfile

在项目根目录下，创建一个 Dockerfile 文件，使用上面的指令编写描述脚本需要注意的是，这里使用「 EXPOSE 」指令暴露的端口号与入口文件定义的端口号保持一致

# Dockerfile

FROM centos:7.9.2009
RUN yum makecache fast;
RUN yum install python3-devel python3-pip -y
RUN pip3 install -i https://pypi.douban.com/simple flask
COPY main.py /opt
WORKDIR /opt
EXPOSE 8888
CMD ["python3","main.py"]

2-3  构建镜像

# 在当前文件夹下，根据Dockerfile文件构建一个镜像
# 镜像名称：xag/my_flask_web
# --no-cache：不使用旧的缓存进行镜像构建
docker build --no-cache -t "xag/my_flask_web" .

2-4  运行镜像容器

使用 docker run 命令基于镜像运行一个容器

其中

• -d：代表容器在后台运行，不是基于前台运行
• --name：用于执行容器的别名
• -p：用于配置宿主机与容器的端口映射

# -d：后台运行
# 宿主机（9999）映射容器内的8888（上面Dockerfile已经暴露了8888端口）
docker run -d --name flask_web -p 9999:8888 xag/my_flask_web  

2-5  测试一下

最后在浏览器中，通过宿主机暴露的端口号 9999 访问项目了

3. 总结

今天的文章我们以一个简单的 Web 项目阐述了利用 Docker 部署项目的常规流程。

实际上，Dockerfile 非常的灵活，它还支持 ARG/ENV 设置环境变量，VOlUME 指令挂载目录，ENTRYPOINT 配置启动程序和参数等。

以上就是本次分享的所有内容，如果你觉得文章还不错，欢迎关注公众号：Python编程学习圈，每日干货分享，发送“J”还可领取大量学习资料。或是前往编程学习网，了解更多编程技术知识。

AspNetCore容器化(Docker)部署(四) —— Jenkins自动化部署

一.前言

                                                 （Jenkins、Docker、Git/Svn组建一套简单的自动化发布流程）

 文章中用到的相关服务器角色

PS C:\Users\Administrator> docker run -u root -d -p 8080:8080 -p 50000:50000 -v /e/DockerData:/var/jenkins_home -v /var/run/docker.sock:/var/run/docker.sock jenkinsci/blueocean
c8222a3716a327ce82770aa729fe80169cbcc28c4d2ada8891cf49ed0b38f3e3
PS C:\Users\Administrator> docker ps -a
CONTAINER ID        IMAGE                 COMMAND                  CREATED              STATUS                      PORTS                                              NAMES
c8222a3716a3        jenkinsci/blueocean   "/sbin/tini -- /usr/…"   About a minute ago   Up About a minute           0.0.0.0:8080->8080/tcp, 0.0.0.0:50000->50000/tcp   serene_feistel
66ff08eda2ae        c42e9f575fc4          "dotnet HelloWorld.d…"   2 days ago           Up 2 days                   0.0.0.0:81->80/tcp                                 netcore_helloworld
5357b641a7b1        9c18561d7ab3          "nginx -g ''daemon of…"   2 days ago           Up 2 days                   0.0.0.0:80->80/tcp, 0.0.0.0:801->801/tcp           mynginx

PS C:\Users\Administrator> docker exec -it c8222a3716a3 bash
bash-4.4# docker version
Client:
 Version:           18.09.1-ce
 API version:       1.39
 Go version:        go1.11.4
 Git commit:        4c52b901c6cb019f7552cd93055f9688c6538be4
 Built:             Fri Jan 11 15:41:33 2019
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          18.09.2
  API version:      1.39 (minimum version 1.12)
  Go version:       go1.10.6
  Git commit:       6247962
  Built:            Sun Feb 10 04:13:06 2019
  OS/Arch:          linux/amd64
  Experimental:     false

PS C:\Users\Administrator> docker-compose -v  #查看宿主机docker-compose版本
docker-compose version 1.23.2, build 1110ad01
PS C:\Users\Administrator> docker exec -it c8222a3716a3 bash  #进入jenkins容器
bash-4.4# curl -L --fail https://github.com/docker/compose/releases/download/1.23.2/run.sh -o /usr/local/bin/docker-compose   #bash脚本安装compose
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   596    0   596    0     0    587      0 --:--:--  0:00:01 --:--:--   587
100  1666  100  1666    0     0    831      0  0:00:02  0:00:02 --:--:--  2127
bash-4.4# chmod +x /usr/local/bin/docker-compose
bash-4.4#
Unable to find image ''docker/compose:1.23.2'' locally
1.23.2: Pulling from docker/compose
4fe2ade4980c: Pull complete                                                                                                                                                                                                                                                    658ccff8d4f1: Pull complete                                                                                                                                                                                                                                                    71166c3c8d42: Pull complete                                                                                                                                                                                                                                                    c246ed86dd59: Pull complete                                                                                                                                                                                                                                                    Digest: sha256:f6e4963cd17f709fb57f7cf0842e269ed6ba173c3490055b50c701a257feb860
Status: Downloaded newer image for docker/compose:1.23.2
bash-4.4# docker-compose -v   #查看jenkins容器内compose版本
docker-compose version 1.23.2, build 1110ad01

#定义变量
$IMAGE_VERSION=''latest''
$REGISTRY_USER=''镜像仓库账号''
$REGISTRY_PWD=''镜像仓库密码''
$REGISTRY_HOST=''ccr.ccs.tencentyun.com''
$REGISTRY_NAMESPACE=''镜像仓库namespace''
$SERVICE_HELLOWORLD=''helloworld''
$SERVICE_MYNGINX=''mynginx''
#jenkins拉取的项目默认路径 “安装路径根目录/workspace/jenkins里面建的项目名”
$COMPOSE_PATH=''D:\Program Files (x86)\Jenkins\workspace\helloworld\docker-compose.yml''

echo "------------------------------ 构建镜像 ------------------------------"
docker-compose -f "${COMPOSE_PATH}" build

echo "------------------------------ 登录远程仓库 ------------------------------"
docker login --username=${REGISTRY_USER} --password=${REGISTRY_PWD} ${REGISTRY_HOST}

echo "------------------------------ 标记镜像 ------------------------------"
docker tag ${SERVICE_HELLOWORLD}:${IMAGE_VERSION} ${REGISTRY_HOST}/${REGISTRY_NAMESPACE}/${SERVICE_HELLOWORLD}:${IMAGE_VERSION}
docker tag ${SERVICE_MYNGINX}:${IMAGE_VERSION} ${REGISTRY_HOST}/${REGISTRY_NAMESPACE}/${SERVICE_MYNGINX}:${IMAGE_VERSION}

echo "------------------------------ 推送到远程仓库 ------------------------------"
docker push ${REGISTRY_HOST}/${REGISTRY_NAMESPACE}/${SERVICE_HELLOWORLD}:${IMAGE_VERSION}
docker push ${REGISTRY_HOST}/${REGISTRY_NAMESPACE}/${SERVICE_MYNGINX}:${IMAGE_VERSION}

echo "------------------------------ 清理None ------------------------------"
docker rmi $(docker images -f "dangling=true" -q)

version: ''3.4''

services:
  helloworld:
    image: ccr.ccs.tencentyun.com/wuuu/helloworld:latest
    environment: #环境变量
      - ASPNETCORE_ENVIRONMENT=Development
    ports: #端口映射
      - "81:80"
    container_name: netcore_helloworld
    deploy:
      restart_policy: #重启策略
        condition: on-failure
        delay: 5s
        max_attempts: 3
    networks: #指定network
      - newbridge
      
  mynginx:
    image: ccr.ccs.tencentyun.com/wuuu/mynginx:latest
    ports:
      - "80:80"
      - "801:801"
    container_name: mynginx
    deploy:
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    networks:
      - newbridge

networks:
  newbridge: #新的network
    #name: newbridge  #compose版本3.5开始才支持自定义名称

#!/bin/bash

#定义变量
REGISTRY_USER=''镜像仓库账号''
REGISTRY_PWD=''镜像仓库密码''
REGISTRY_HOST=''ccr.ccs.tencentyun.com''
COMPOSE_PATH=''mydockercompose/docker-compose.staging.yml''

echo ------------------------------ 登录远程仓库 ------------------------------
docker login --username=$REGISTRY_USER --password=$REGISTRY_PWD $REGISTRY_HOST

echo ------------------------------ 卸载服务 ------------------------------
docker-compose -f $COMPOSE_PATH down

echo ------------------------------ 拉取镜像 ------------------------------
docker-compose -f $COMPOSE_PATH pull

echo ------------------------------ 启动服务 ------------------------------
docker-compose -f  mydockercompose/docker-compose.staging.yml up -d

echo ------------------------------ 清除None ------------------------------
docker rmi $(docker images -f "dangling=true" -q)

PS C:\Users\Administrator> docker images
REPOSITORY                               TAG                 IMAGE ID            CREATED             SIZE
ccr.ccs.tencentyun.com/wuuu/helloworld   latest              4024cdbb87dc        About an hour ago   265MB
helloworld                               latest              4024cdbb87dc        About an hour ago   265MB
ccr.ccs.tencentyun.com/wuuu/mynginx      latest              daca457eb2a9        7 hours ago         109MB
mynginx                                  latest              daca457eb2a9        7 hours ago         109MB
mcr.microsoft.com/dotnet/core/sdk        2.2-stretch         e4747ec2aaff        4 weeks ago         1.74GB
mcr.microsoft.com/dotnet/core/aspnet     2.2-stretch-slim    f6d51449c477        4 weeks ago         260MB

root@VM-16-9-ubuntu:~# docker images
REPOSITORY                               TAG                 IMAGE ID            CREATED             SIZE
ccr.ccs.tencentyun.com/wuuu/helloworld   latest              4024cdbb87dc        About an hour ago   265MB
ccr.ccs.tencentyun.com/wuuu/mynginx      latest              daca457eb2a9        7 hours ago         109MB
root@VM-16-9-ubuntu:~# docker ps -a
CONTAINER ID        IMAGE                                           COMMAND                  CREATED             STATUS              PORTS                                      NAMES
e1dc94a1886b        ccr.ccs.tencentyun.com/wuuu/mynginx:latest      "nginx -g ''daemon of…"   8 minutes ago       Up 7 minutes        0.0.0.0:80->80/tcp, 0.0.0.0:801->801/tcp   mynginx
3ad3db4fbd94        ccr.ccs.tencentyun.com/wuuu/helloworld:latest   "dotnet HelloWorld.d…"   8 minutes ago       Up 8 minutes        0.0.0.0:81->80/tcp                         netcore_helloworld

sudo docker pull grapecitycn/wyn-enterprise

sudo docker run --name wyn -p 51980:51980 -d grapecitycn/wyn-enterprise

sudo docker pull grapecitycn/wyn-enterprise

sudo docker run --name wyn -p 51980:51980 -d grapecitycn/wyn-enterprise