docker，Dockerfile，docker私有仓库，dockercompose介绍，dockercompose部署flask+redis项目，doclercompose一键部署路飞项目

内容回顾

容器操作

docker start 容器id  启动容器
docker stop 容器id   停止容器
docker rm	容器id   删除容器
ocker rm `docker ps -aq`  # 正在运行的容器不能删除
docker exec 容器id 命令  让容器执行命令
docker cp 宿主机目录 容器id:容器目录 #目录要存在
docker cp 容器id:容器目录 宿主机目录  #目录要存在
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
两个容器ping
nginx容器，底层操作系统不是centos是debin
	apt-get install
    yum install 

应用部署

mysql:一定要做目录映射，做了目录映射后，删除容器，在重写运行一个容器，数据都在

	-mysql
    docker run  -di -v /home/mysql/data/:/var/lib/mysql -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/my.cnf:/etc/mysql/my.cnf -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7 
    -nginx
    	docker run -id --name nginx -p 80:80 -v /root/html:/usr/share/nginx/html nginx
    -redis
    	docker run -id  -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf

容器必须有个前台进程在运行，否则就会停掉

迁移于备份

把容器做成镜像
	docker commit 镜像名称 容器id
把镜像保存成压缩包
	docker save -o 保存的文件名 镜像id
把压缩包还原成镜像
	docker load -i 镜像文件名

Dockerfile

用来构建镜像

名字必须叫Dockerfile

写一个命令：run

docker build -t='容器名' .

内容详情

Dockerfile常用和不常用命令

FROM: 指定基础镜像
RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改。
ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
EXPOSE：设置对外暴露的端口。
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
COPY：将本地文件或目录拷贝到镜像的文件系统中。
VOLUME：添加数据卷
USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
WORKDIR：设置工作目录
ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令
STOPSIGNAL：设置容器退出时发出的关闭信号。
HEALTHCHECK：设置容器状态检查。
SHELL：更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。

Dockerfile构建一个django项目

第一步：有一个项目，pycharm开发着，开发完后

第二步：在项目路径下新建Dockerfile写入

FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requirements.txt /soft/requirements.txt
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
CMD ["python","manage.py","runserver","0.0.0.0:8080"]
# 可以这样CMD python manage.py runserver 0.0.0.0:8080

第三步：把代码提交到git

第四步：上线人员：上下机器上，把代码拉下来

git clone https://gitee.com/liuqingzheng/books.git

第五步：构建镜像

docker build -t flask_demo .

如果出现了类似下面报错，可以尝试重启docker,重启服务器

第六步：运行容器

docker run -it --name books -v ./:/soft/ -p 8080:8080 flask_demo

第七步：其他人访问宿主机的8080端口就能看到项目了

第八步：开发人员继续提交代码

第九步：运维人员pull代码，重启容器，用户就可以看到最新的了重启docker容器即可（第三方依赖变了）》重构镜像，运行容器

docker私有仓库

有个远程仓库，docker官方提供的》我们可以八我们的镜像上传上去

公司做的镜像，一般步放在远程仓库，公司会自己搭建私有仓库（公司制作的镜像传到私有仓库）

镜像传到官方仓库

第一步：在远端创建仓库

第二步：给镜像打标签

docker tag 镜像id clevercat(自己dockerhub上的用户名)/flask_demo:tagname
 
    
docker tag 7790e0482744 clevercat/flask_demo:v1

第二步：登录到远程

docker login

用户名 必须要用户名不能是邮箱

密码

docker logout 退出登录

第三步：提交

docker push liuqingzheng/centos_vim:v1

第四步：别人就可以下载了

docker push liuqingzheng/centos_vim:v1

镜像分层

每一个Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完毕后，将容器进行提交通过查看下载下来的镜像，发现历史层信息的层ID是missing,i其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID）

docker history 镜像id

好处

构建块，分发方便，如果本地有某一层了，着一层就不需要下载了

补充：Dockerfile写命令，建议多条命令和为一条

RUN python -m pip install --upgrade pip &&\
    python -m pip install --upgrade setuptools &&\
    pip install -r requirements.txt

私有仓库搭建

自己搭建私有仓库

harbor:企业级私有仓库》https://blog.csdn.net/Gf19991225/article/details/121982824

registry:用docker搭建私有仓库

搭建步骤：

第一步：拉取镜像 docker pull register

第二步运行容器 docker run -id --name register -p 5000:5000 registry

第三步：打开浏览器输入地址

http://服务ip:5000/v2/_catalog

看到{"repositories":[]}表示私有仓库搭建成功并且内容为空

第四步：修改daemon.json

vi /etc/docker/daemon.json

{
    "insecure-registries":["47.103.74.128:5000"]
} 

第五步：重启docker 让配置生效

systemctl restart docker
docker start registry

第六步：把某个镜像tag，然后上传私有仓库的镜像

docker tag 镜像名字/id  47.103.74.128:5000/django_books:v1

第七步：提交到私有仓库

docker push 47.103.74.128:5000/django_books:v1

第八步：其他人，只要配置了私有仓库就可以直接获取了

docker pull 47.103.74.128:5000/django_books:v1

Dockercompose介绍

使用了docker面临一个比较大的问题，如果一个django项目使用msyql，redis不要一次性把所有服务都放到一个容器中，每个服务一个容器，批量的管理多个容器，比较难以操作，于是有了docker-compose

Docker Compose是一个能一次性定义和管理多个Docker容器的工具，单机容器编排【定义和管理】

多机容器编排

docker swarm:公司里面用的不多

k8s是多机容器编排工具，go语言写了k8s

Compose中定义的启动的每一个容器相当于一个服务（service）

Compose中能定义和启动多个服务，且他们之间通常具有协调关系

​ 管理方式：

​ 使用YAML文件来配置我们应用程序的服务

​ 使用单个命令(docker-compose up)，就可以创建并启动配置文件中配置的所有服务

安装docker-compose（可执行文件，放在了github上，下载下来即可，速度很慢）https://github.com/docker/compose/releases

wget https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64
 
cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose
 
chmod +x /usr/local/bin/docker-compose

以后在任意位置敲docker-compose都可以

常用命令

启动管理容器

docker-compose up 会自动搜索当前路径下 的docker-compose.yml文件

docker-compose -f 指定文件 up

docker-compose up -d 后台执行，一般我们看日志输出不要这个

docker-compose stop 停止容器，不会删除容器和镜像

docker-compose down 停止，并且删除关联的容器

docker-compose start 启动yml文件管理的容器

docker-compose ps 正在运行的容器

docker-compose images docker-compose管理的镜像

docker-compose exec yml文件中写的service /bin/bash 进入到容器内

Docker-compose部署flask+redis项目

flask项目，使用redis服务》两个容器

新建flask项目app.py

from flask import Flask
from redis import Redis
import os
 
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
 
@app.route('/')
def hello(): 
    redis.incr('hits')
    return '你好! 查看 %s 次\n' % (redis.get('hits'))
 
 
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

编写Dockerfile》用于构建flask项目的镜像

FROM python:3.8
WORKDIR /app
RUN pip install flask redis -i https://pypi.tuna.tsinghua.edu.cn/simple
EXPOSE 5000
CMD [ "python", "app.py" ]

编写docker-compose的yaml文件docker-compose.yml

version: "3"
services:
  redis:
    image: redis
  web:
    build:
      dockerfile: ./Dockerfile
    volumes:
    - ./:/app
    ports:
      - 5000:5000
    depends_on:
      - redis
    environment:
      REDIS_HOST: redis
 

docker-compose启动

如果redis服务的名字叫redis，我在web服务中（容器中），根据redis名字就能拿到容器

ping redis
 
# 进入到了web，ping redis
# 安装ping命令，
apt-get update
apt-get install inetutils-ping
ping redis
 

docker-compose会自己做一个网段管理的容器在同一个网段

如果两个容器在同一网段下，每个容器里面监听的0.0.0.0那么容器之间是可以互相访问的，

宿主机默认网络模式，只要容器暴露端口，跟任何一个容器就可以连接。

容器可以ping不同网段下的网关，但是不能ping不同网段下的主机

所以上面docker-compose内redis暴露了6379端口,又在同一个网段下，flask项目才能连接到redis

一键部署：redis,和flask,每个都在一个容器中

docker-compose up

dockercompose一键部署路飞项目

一台服务器：

python3.8 环境 django+uwsgi+代码

nginx软件

mysql5.7

redis

每个都做成一个容器

django项目容器：python3.8构建的django，模块uwsgi代码

nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件

mysql容器创建，创建用户，密码，luffy库

redis 容器，跑起来即可

docker-compose yml文件配置，一键启动

git clone https://gitee.com/liuqingzheng/luffy.git

目录结构

# 一台服务器：
	-python3.8 环境 djagno +uwsgi+代码
    -nginx软件
    -mysql 5.7
    -redis 
    
# 每个都做成一个容器
	-djagno项目容器：python3.8 构建的django，模块，uwsgi，代码
    -nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
    -mysql 容器：创建，创用户，密码，luffy库
    -redis 容器，跑起来即可
    
    
# docker-compose yml文件配置，一键启动
	-git clone https://gitee.com/liuqingzheng/luffy.git
    -目录结构
    luffy
        luffy_api  # 后台项目
        	Dockerfile
		luffycity  # 前台项目
        docker_compose_files # 放数据的文件夹
        
        docker-compose.yml #ymal文件
	-docker-compose.yml内容
	-Dockefile 文件
    - 修改前端链接后台的地址：luffycity/src/access/xx.js
    -编译：npm run build
    
    -提交到git
    
    -要部署的服务器：git clone https://gitee.com/liuqingzheng/luffy.git
    -docker，docker-compose装好
    -docker-compose up
    -访问宿主机的 80 端口

项目目录结构

luffy
	-docker_compose_files  # nginx有自己的配置文件，redis自己的配置，mysql的配置
        nginx # 文件夹
        redis # 文件夹
        mysql.env#配置文件
    -luffy_api  # 原来路飞后端项目
    	-Dockerfile
        -luffy.ini  # luffy.xml uwsgi的配置文件
    -luffycity  # 前端项目
    
    -docker-compose.yml  # docker-compose的配置文件
    
    
# 把luffycity/dist 文件夹删除
# 把\luffy\luffycity\src\assets\js\settings.js后端地址改成上线地址(服务器地址)
# 来到前端路径下：luffy\luffycity
cnpm install  安装依赖
 
# 编译，在\luffy\luffycity\dist文件夹
npm run build
 
# 提交到git上
 
 
# 在部署的机器上，git clone 下来
# 进入到项目目录
docker-compose up

luffy_api/Dockerfile>构建uwsgi+django

FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requestment.txt /soft/requestment.txt
RUN pip install -r requestment.txt -i https://pypi.doubanio.com/simple
#CMD ["uwsgi", "-x", "./luffy.xml"]
CMD ["uwsgi", "./luffy.ini"]
#CMD ["python", "manage_pro.py", "runserver"]

docker-compose.yml

version: "3"
 
services:
  nginx:
    image: nginx
    container_name: luffy_nginx
    ports:
      - "80:80"
      - "8000:8000"
    restart: always
    volumes:
      - ./luffycity/dist:/var/www/html
      - ./docker_compose_files/nginx:/etc/nginx/conf.d
    depends_on:
      - django
    networks:
      - web
 
  django:
    build:
      context: ./luffy_api
      dockerfile: Dockerfile
    container_name: luffy_django
#    command: python manage_pro.py makemigrations && python manage_pro.py migrate && uwsgi ./luffy.ini
    restart: always
    ports:
      - "8080:8080"
    volumes:
      - ./luffy_api:/soft
    environment:
      - TZ=Asia/Shanghai
    depends_on:
      - mysql
      - redis
    networks:
      - web
  redis:
    image: redis:6.0-alpine
    container_name: luffy_redis
    ports:
      - "6379:6379"
    volumes:
      - ./docker_compose_files/redis/data:/data
      - ./docker_compose_files/redis/redis.conf:/etc/redis/redis.conf
    command: redis-server /etc/redis/redis.conf
    networks:
      - web
  mysql:
    image: mysql:5.7
    container_name: luffy_mysql
    restart: always
    ports:
      - "3306:3306"
    env_file:
      - ./docker_compose_files/mysql.env
    volumes:
      - ./docker_compose_files/mysql/data:/var/lib/mysql
      - ./docker_compose_files/mysql/logs:/var/log/mysql
      - ./docker_compose_files/mysql/conf:/etc/mysql/conf.d
    networks:
      - web
 
networks:
  web:

一键部署

docker-compose up