Docker基本知识：编写Dockerfile、docker-compose一键部署项目

yum remove docker docker-common  docker-selinux docker-engine
rm -rf /var/lib/docker

# 安装
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sudo yum install docker-ce -y

# 查看版本
docker -v  # Docker version 23.0.4, build f480fb1

# 第一步：查看docker状态
systemctl status docker
# 第二步：启动docker
systemctl start docker
# 第三步：进入文件路径，并粘贴如下配置
vim /etc/docker/daemon.json

{
  "registry-mirrors": ["https://x1566319.mirror.aliyuncs.com"]
}
# 第四步：执行如下命令进行重新加载并重启
sudo systemctl daemon-reload
sudo systemctl restart docker

# 启动docker：
systemctl start docker

# 停止docker：
systemctl stop docker

# 重启docker：
systemctl restart docker

# 查看docker状态：
systemctl status docker

# 开机启动：
systemctl enable docker

# 查看docker概要信息
docker info

# 查看docker帮助文档
docker --help

# 查找镜像(建议去hub.docker.com 直接搜，更直观)
docker search image_name  

# 拉取镜像 如果不指定标签，会下载最新
命令语法：docker pull imagename:tag
docker pull centos:7
docker pull centos
docker pull centos:latest

# 查看本地镜像
docker images

# 删除镜像 可以同时删多个
docker rmi image_ID

# 删除所有镜像
docker rmi `docker images -q`

# 查看容器
docker ps
# 启动容器
docker start docker_id
# 停止容器
docker stop docker_id
# 容器的文件copy到宿主机上（不是在容器内执行）
语法：docker cp 容器名称:容器目录 需要拷贝的文件或目录
docker cp  20fd8:/home/lqz.txt /home/lqz.txt
# 宿主机的文件copy到容器中
语法：docker cp 需要拷贝的文件或目录 容器名称:容器目录
docker cp ./lqz.txt 20fd894a3f20:/home/lqz.txt
docker inspect 容器名称  # 查看容器的详细描述，很多
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

# 查看容器IP地址    
docker inspect 容器名称  # 查看容器的详细描述，很多
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
# 删除容器（删除已停止的容器）
docker rm 容器id  
docker rm `docker ps -a -q`
# 查看正在运行的容器
"""
-a 参数是查看所有容器
-l 参数是查看最后一次运行的容器
"""
docker ps
docker ps -a
docker ps -l

# 运行容器
"""
把镜像运行成容器其实是两个命令create和run
会有很多参数，下面回详细的介绍每一个参数
-i：表示运行容器
-t：表示容器启动后会进入容器命令行
-d：会创建一个守护式容器在后台运行
--name :为创建的容器命名，如果不写，随机生成一个名字
-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录）
-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口
"""
# 运行容器的核心命令其实就是docker run，此外会有很多参数
docker run
# 启动一个centos容器,名字叫mycentos，并且进入
docker run -it --name=mycentos centos:7
# 启动一个centos容器,名字叫mycentos，不进入
docker run -id  centos:7
# 启动容器
docker start mycentos
# 进入到容器内部（本质是让容器执行命令）
语法： docker exec 容器id 命令
docker exec f82e8578b9b1 ls # 可以查看该容器内部的内容
docker exec -it  f82e8578b9b1 /bin/bash  # 进入到容器内部
# 退出
exit
# -v参数：目录映射
docker run -id --name=mycentos -v /home/mycentos:/mycentos centos:7
# -p参数：端口映射、netstat -nlp |grep 80  查看本机80端口占用情况
docker run -id --name=mysql -p 80:3306  -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

# 1.拉取MySQL镜像、并查看镜像
docker pull mysql:5.7
docker images
# 2.创建文件夹目录映射需要
mkdir /home/mysql
mkdir /home/mysql/conf.d
mkdir /home/mysql/data/
# 3.创建并进入my.cnf
vim /home/mysql/my.cnf
# 4.写入一下配置
[client]
default-character-set=utf8
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000
# 5.保存退出
先敲a再右键粘贴配置、再敲esc键并输入:wq、最后敲enter
# 6.把镜像运行成容器、做目录映射、做端口映射
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  
# 7.查看正在运行的容器
docker ps -a
# 8.进入容器内部就可以执行数据库相关操作，退出容器敲exit即可
docker exec -it  f82e8578b9b1 /bin/bash
# 9.先退出数据库再退出容器
quit
exit

# 1.拉取redis镜像
docker pull redis
# 2.创建文件夹
mkdir /root/data
# 3.进入Redis配置文件
vim /root/redis.conf
# 4.修改配置
bind 0.0.0.0
daemonize NO
protected-mode no
requirepass 123456
# 5.运行容器
docker run -id  -p 63790:63790 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf

# 1.拉取镜像
docker pull nginx
# 2.运行容器
docker run -id --name nginx -p 80:80 -v /root/html:/usr/share/nginx/html nginx

以centos7镜像作为例子，从拉取镜像到
# 1.先拉取
docker pull centos:7
# 2.镜像运行成容器
docker run -id --name centos_vim centos:7
# 3.进入容器内
docker exec -it 4648fe0 /bin/bash
# 4.进入容器内部之后，在容器内部执行了以下操作
    1  yum instal vim -y
    2  yum install vim -y
    3  ls
    4  mkdir mire
    5  ls
    6  cd mire/
    7  vim mire.py
    8  python mire.py
    9  hitory
   10  history
# 5.退出容器
exit
# 6.容器做成镜像、语法：docker commit 容器名 镜像名
docker commit centos_vim centos_vim_image
# 7.把centos_vim 容器删除
docker rm -f centos_vim
# 8.基于新构建的镜像，运行成容器
docker run -id --name centos_vim centos_vim_image:latest
# 9.进入到容器中，查看，软件都在
docker exec -it id号 /bin/bash
# 10.把镜像做备份
docker save -o centos_vim_image.tar centos_vim_image
# 11.根据备份恢复镜像
docker load -i centos_vim_image.tar



总结一下迁移与备份
"""
1 把容器做成镜像
docker commit 容器名字 镜像名字
2 把镜像保存成压缩包
docker save -o centos_vim_image.tar 镜像名字
3 把压缩包还原成镜像
docker load -i centos_vim_image.tar
""

FROM 基础镜像                        # 基于哪个基础镜像来构建
MAINTAINER mire                     # 声明镜像的创建者
ENV key value                       # 设置环境变量 (可以写多条)
RUN command                         # 是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file   # 将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file  # 和ADD相似，但是如果有压缩文件并不能解压
WORKDIR mire                        # 设置工作目录，运行这个容器需要来到这个路径

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

# 日常开发工作中使用Docker开发的工作流程
第一步：在开发机器上开一个项目
第二步：开发完成之后该项目的根目录下新建Dockerfile(文件名一定要Dockerfile，不然不行) 
第三步：在该文件里面写入如下内容

FROM python:3.8
MAINTAINER mire
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"]

第四步：把代码提交到git
------------------
第五步：上线人员：在上线机器上，把代码啦下来
git clone https://gitee.com/liuqingzheng/books.git
第六步：构建镜像
docker build -t='django_books' .
第七步：运行容器
docker run -id --name=books -v /root/lqz/books:/soft -p 8080:8080 django_books:latest
第八步：其它人访问宿主机的8080端口就能看到项目了

---------
第九步：开发人员继续提交代码
第十步：运维人员pull代码，重启容器，用户就可以看到最新的了
重启docker容器即可(第三方依赖变了)--》重写构建镜像，运行容器

# 查看镜像分层的命令
docker history liuqingzheng/centos_vim:v1
# 好处：
构建快，分发方便，如果本地有某一层了，这一层就不需要下载了
# 补充：Dcokerfile写命令，建议多条命令合为一条
RUN python -m pip install --upgrade pip &&\
    python -m pip install --upgrade setuptools &&\
    pip install -r requirements.txt

# 搭建步骤
# 第一步：拉取镜像 
docker pull registry

# 第二步：运行容器
docker run -di --name=registry -p 5000:5000 registry

# 第三步：打开浏览器 输入地址http://36.133.79.122:5000/v2/_catalog
看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空

# 第四步：修改daemon.json 
# 中括号里面IP和port是自己机器的，不要一味地复制粘贴，动点脑子
vi /etc/docker/daemon.json

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

# 第五步：重启docker 让配置生效
systemctl restart docker
docker start registry

# 第六步：把某个镜像tag成私有仓库的镜像任意一个镜像打标签
docker tag eeb6ee3f44bd 36.133.79.122:5000/mymysql/m:v1

# 第七步：提交到私有仓库
docker push 36.133.79.122:5000/mymysql/m:v1

# 第八步：其他人，只要配置了私有仓库就可以直接拉取
docker pull 36.133.79.122:5000/mymysql/m:v1

# 下载docker-compose
wget https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64
 # docker-compose的目录放到/usr/local/bin/docker-compose下
cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose
# 下载完成之后，需要执行如下命令，加执行权限 +x
chmod +x /usr/local/bin/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管理的容器
docker-compose images # docker-compose管理的镜像
docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内

1. 新建的luffy文件夹在pycharm中打开，并terminal中拉取前后端项目
注意：前后端项目都是基于原有的仓库clone下来的，所以把他们的.gitignore文件和.git文件夹都要删掉，不然影响push

2. 来到D:\pythonProject\luffy\luffy_city\src\assets\js\settings.js路径修改地址，修改成服务器地址
export default {
    BASE_URL: 'http://36.133.79.122:8000/api/v1'
}

3. 在D:\pythonProject\luffy\luffy_city>路径下下载依赖之后编译
cnpm install
npm run build

4. 编写docker-compose相关配置文件
具体内容下面回罗列的

5. 修改后端项目MySQL和Redis的地址
'HOST': 'luffy_mysql',  # IP地址写容器名字
"CLIENT_CLASS": "django_redis.client.DefaultClient",  # IP地址写容器名字

6. 来到D:\pythonProject\luffy>路径下 把项目提交到git
git init
git add .
git commit -m "上线"
git remote add origin https://gitee.com/almira998/luffy.git
git push -u origin "master"

7. 在服务器中执行如下命令(需要下载git) 一键部署项目
mkdir project
ls
cd project/
git clone https://gitee.com/almira998/luffy.git
cd luffy/
ls
docker_compose up


"""
一键部署项目会很慢，需要等待一些时间，但是这个不是问题，
关键是编写docker-compose和Dockerfile的相关配置和文件时注意路径
"""

server {
  listen 80;
  server_name  127.0.0.1;
  charset utf-8;
  location / {
    root /var/www/html;
    index index.html;
    try_files $uri $uri/ /index.html; # 解决单页面应用刷新404问题
  }
}
server {
  listen 8000;
  server_name  127.0.0.1;
  charset utf-8;
  location / {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://luffy_django:8080;
  }
  # 新增的配置静态文件
  location /static {
    alias /home/project/luffy_api/luffy_api/static;
  }
}

bind 127.0.0.1
port 6379
daemonize no

pidfile /var/run/redis_6379.pid
databases 16

save 900 1
save 300 10
save 60 10000
dbfilename dump.rdb
dir ./

MYSQL_ROOT_PASSWORD=lqz12345
MYSQL_DATABASE=luffy
MYSQL_USER=luffy
MYSQL_PASSWORD=Luffy123?
TZ=Asia/Shanghai

#依赖镜像名称和ID
FROM python:3.8
#指定镜像创建者信息
MAINTAINER mire
#切换工作目录
RUN mkdir /soft
WORKDIR /soft
COPY ./requirements.txt /soft/requirements.txt
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
#CMD ["uwsgi", "-x", "./luffy.xml"]
CMD ["uwsgi", "./luffy.ini"]
#CMD ["python", "manage_pro.py", "runserver"]

[uwsgi]
chdir = /soft
master = true
wsgi-file = luffy_api/wsgi.py
http = 0.0.0.0:8080
chmod-socket = 755
processes = 2
pidfile = /soft/luffy_api/uwsgi.pid
#设置缓冲
post-buffering = 4096

<uwsgi>
   <socket>0.0.0.0:8080</socket> <!-- 内部端口，自定义 -->
   <chdir>/soft/</chdir> <!-- 项目路径 -->
   <module>luffy_api.wsgi</module>  <!-- luffy_api为wsgi.py所在目录名-->
   <processes>4</processes> <!-- 进程数 -->
</uwsgi>

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:

这个文件上的项目的SQL语句，这个可以根据数据库导出来的，所以就没贴上去