docker

Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 加了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在上进行维护。

容器化技术，区分于虚拟机，又类虚拟机，兼具虚拟机隔离的优点，又有速度快的优点
容器资源隔离，网络隔离
把容器当成一个虚拟机即可

docker 容器管理 
	-docker swarm
	-k8s

Docker 的基础是 Linux 容器（LXC）等技术

1 docker安装和配置

centos 7.9 安装

# 创建一个centos 7.9的虚拟机，在这个基础上装docker

# 如果之前装过，卸载
# yum remove docker docker-common  docker-selinux docker-engine
# rm -rf /var/lib/docker
yum update  # 更新yum仓库

# 安装
yum install -y yum-utils device-mapper-persistent-data lvm2

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
yum install docker-ce -y

# 查看安装的版本
docker --version

# 目前我们只装了 docker-ce，
	-只有：c  和 s端
    -没有docker-compose
    -没有图形化解码
    -跟docker-destop的区别
    
    
# 启动docker
systemctl status docker
systemctl start docker

# 配置：国内镜像站：阿里云 https://cr.console.aliyun.com/cn-shanghai/instances/mirrors
sudo mkdir -p /etc/docker # 如果有，就不需要创建了
vi /etc/docker/daemon.json 
    
# 加入
    {
      "registry-mirrors": ["https://x1566319.mirror.aliyuncs.com"]
    }
# 按 esc
# 输入  :wq  敲回车

systemctl daemon-reload   # 重新加载docker配置
systemctl restart docker  # 重启docker

2 docker镜像操作

# 0 搜索镜像
	-去网站搜：https://hub.docker.com/ 
	-使用命令行搜：docker search mysql
    
# 1 获取镜像，拉去镜像---》从register下载到本地--》阿里云镜像站--》加速拉取
	docker pull mysql:5.7 # 下载mysql 5.7镜像
	docker pull redis:latest # 下载redis最新的镜像
    docker pull nginx:latest  # 下载 nginx最新的镜像
    docker pull centos:centos7  # 下载 nginx最新的镜像
    
# 2 查看镜像
	docker images

# 3 删除镜像
	docker rmi redis:latest

3 容器操作

# 启动容器
	docker start 容器id
# 停止容器
	docker stop 容器id
    
# docker run 参数
    -i 表示运行容器
    -d 以守护式容器在后台运行，用这个参数创建出来的容器，命令行还在宿主机上，没有进入到容器内部
    -t 表示容器启动后会进入容器命令行。加入这参数后，容器创建就能登录进去。即分配一个伪终端。
    --name 指定容器名字，如果不指定，会随机一个名字
    -p 表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
    -v 表示目录映射关系（前者是宿主机目录，后者是容器的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上

# docker run -id --name=centos7 centos:centos7    
    
    
# docker exec  命令
	在宿主机，链接容器，执行命令，把命令结果返回给宿主机
# 一次性删除所有容器
	docker rm `docker ps -a -q`
# 一次性删除所有镜像
	docker rmi `docker images -q`    
# 查看宿主机 3307端口占用情况
    yum install net-tools -y
    netstat -nlp | grep 3307 # 被docker占了
    
#  mysql的容器底层的操作系统是 debian 装软件需要用 
    apt-get update
    apt-get install vim -y

#  文件拷贝(宿主机执行)
	# 容器的文件copy到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  0a9633190cb9:/xx.txt /root/lqz/lqz.txt
    
# 宿主机的文件copy到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp /root/lqz/xx.txt  0a9633190cb9:/xx.txt          
        
# 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
    docker inspect ea5f3c9ee99a --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

4 应用部署

4.1 mysql 部署

# dokcer 中部署mysql，以后不需要在宿主机上装mysql
	
# 没有做目录映射---》配置文件--》表数据都在容器中---》一旦删除--》所有都没了
docker run -di --name=mysql -p 3308:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

# 做目录(配置文件和数据文件)和端口映射

# 做目录映射：data文件，配置文件
mkdir /mysql
mkdir /mysql/conf.d
mkdir /mysql/data/

vi /mysql/my.cnf
# 配置
[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


docker run  -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3306:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7              
    
# 创建库，创建表，插入数据

# 关闭容器，删除容器，myslq的容器没了，但是数据在宿主机上放着
 docker stop mysql2
 docker rm mysql2
##docker rm mysql -f  容器之间删了

# 再运行起一个容器，做好目录映射，数据都回来了
docker run  -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3307:3306 --name mysql2 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7 



# 补充  -e参数--》环境变量
	-不同镜像提供不同参数
    -传入后放入环境变量
    echo $MYSQL_ROOT_PASSWORD
	

4.2 redis部署

docker pull redis  #最新

mkdir /root/data
vim /root/redis.conf

# 配置
bind 0.0.0.0
daemonize NO
protected-mode yes
requirepass 123456


# 运行
#启动容器时，运行的命令是什么 redis-server /etc/redis/redis.conf

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
            
# 远程链接redis操作

4.3 nginx部署

# 拉取nginx镜像
docker pull nginx

# run起容器
# docker run -id --name nginx -p 80:80 nginx
    
# /usr/share/nginx/html
docker run -id --name nginx1 -p 8008:80 -v /root/html:/usr/share/nginx/html nginx
# 以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的

5 迁移与备份

5.1 容器保存为镜像

-运行一个centos容器
    docker run -id --name centos centos:centos7
-在容器中装vim
    docker exec -it centos /bin/bash
    yum install vim -y

-把容器做成镜像（centos+vim）
    docker commit centos centos_vim_image

-把centos_vim 容器删除
    docker rm centos_vim -f
-基于新构建的镜像，运行成容器
    docker run -id --name centos_vim centos_vim_image:latest
-进入到容器中，查看，软件都在
    docker exec -it c3e633bd1 /bin/bash

5.2 镜像备份和恢复

	docker save -o centos_vim_image.tar centos_vim_img
-删除容器，删除镜像
-把备份的镜像恢复
    docker load -i centos_vim_image.tar

6 Dockerfile

6.1 什么是Dockerfile

	Dockerfile是由一系列命令和参数构成的脚本文件，这些命令应用于基础镜像并最终创建一个新的镜像

6.2 Dockerfile的命令

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

# docker logs 容器名字/id号  查看镜像运行成容器时，错误日志
	-如果容器没起来，看日志排查错误
    
# CMD  ENTRYPOINT  --https://zhuanlan.zhihu.com/p/548188679
#相同点：
只能写一条，如果写了多条，那么只有最后一条生效。
容器启动时才运行，运行时机相同。
# 不同点：
ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数


# ARG 和 ENV
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失

6.3 小案例

# 构建一个带vim的centos:7镜像,根路径下有/lqz/ss.py

vim Dockerfile

FROM centos:centos7
MAINTAINER lqz
ENV name lqz
ARG age 19
RUN yum update&&yum install vim -y
RUN mkdir /lqz
RUN touch /lqz/ss.py
RUN echo 'print(1)' > /lqz/ss.py
RUN echo $name
RUN echo $age
WORKDIR /lqz




# 基于dockerfile构建镜像,不要忘了 .   基于当前路径下的Dockerfile 构建镜像
docker build -t='centos_lqz_vim' . 
docker images
# 基于这个镜像运行容器
 docker run -id --name xx centos_lqz_vim
# 进入到容器
docker exec -it xx /bin/bash
# 验证vim，和文件夹，文件是否存在

6.4 dockerfile构建一个djagno项目（books图书管理系统）

# 以图书管理系统为例---》公司使用docker流程
yum install git

# 公司中，使用Docker开发的工作流程
第一步：有一个项目，pycharm开发着，开发完后
第二步：在项目路径下新建Dockerfile，写入
    FROM python
    MAINTAINER qcc
    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/unreal-q/BookSystem.git
第五步：构建镜像
   cd /root/project/BookSystemdock
   docker build -t='django_books' .
第六步：运行容器
   docker run -id --name=books -v /root/project/BookSystem:/soft -p 8080:8080 django_books:latest
第七步：其它人访问宿主机的8080端口就能看到项目了

---------
第八步：开发人员继续提交代码
第九步：运维人员pull代码，重启容器，用户就可以看到最新的了

重启docker容器即可(第三方依赖变了)--》重写构建镜像，运行容器

7 docker 私有仓库

7.1 镜像传到官方仓库

# 在远端创建仓库
# 第一步：给镜像打标签
	docker tag 086e6b3e71c0 xxx/xxx:v1
# 第二步：登录到远程
	docker login
    用户名：不是邮箱
    密码：挺复杂
    
# 第三步：提交
	docker push xxx/xxx:v1
        
# 第四步：别人就可以下载了
	docker pull xxx/xxx:v1

7.2 镜像分层

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

# 只要执行一个命令就会多一层
RUN yum install vim -y
RUN yum install git -y

# 查看镜像分层的命令
docker history  xxx/books:v1
    
# 好处：
构建快，分发方便，如果本地有某一层了，这一层就不需要下载了

# 补充：Dcokerfile写命令，建议多条命令合为一条---》只会生成一层

7.3 私有仓库搭建

# 自己搭建私有仓库
	-harbor：企业级私有仓库---》（有图形化界面--》跟hub.docker 很像）		https://blog.csdn.net/weixin_47085247/article/details/129237979
    
    -registry：用docker搭建私有仓库(没有图形化界面)

搭建步骤

-第一步：拉取镜像 docker pull registry
    -第二步：运行容器：docker run -di --name=registry -p 5000:5000 registry
    	-就是一个web服务端--》从浏览器中访问它
    -第三步：打开浏览器 输入地址http://100.0.0.129:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
    -第四步：修改daemon.json
    vi /etc/docker/daemon.json
    {
       
        "insecure-registries":["100.0.0.129:5000"]
    } 
      
    
    -第五步：重启docker 让配置生效
    systemctl restart docker
    docker start registry
    
    -第六步：把某个镜像tag成私有仓库的镜像
    docker tag 镜像名字/id 100.0.0.129:5000/django_books:v1
    docker tag django_books:latest 100.0.0.129:5000/django_books:v1

    
            
    -第七步：提交到私有仓库
    docker push 100.0.0.129:5000/django_books:v1
            
            
    -第八步：其他人，只要配置了私有仓库就可以直接拉取
    docker pull 100.0.0.129:5000/django_books:v1
    
    
    docker run -id --name=books -v /root/project/books:/soft -p 8080:8080 100.0.0.129:5000/django_books:v1
    # 以后公司用harbor多---》自己搭建个harbor

harbor

# 安装DockerCompose


# 修改权限
chmod +x /usr/local/bin/docker-compose

# Harbor下载
# 如果下载慢，直接从本机拉取
wget https://github.com/goharbor/harbor/releases/download/v2.4.1/harbor-offline-installer-v2.4.1.tgz

# 解压安装包
tar xvf harbor-offline-installer-v2.4.1.tgz

# 进入harbor文件夹
cd harbor

# 编辑配置文件
mv harbor.yml.tmpl harbor.yml

# 打开 harbor.yml文件
vi harbor.yml
    # hostname改为本机ip
    # 端口默认80，可以改为其他指定端口
    # 注释掉https的相关配置
    # harbor_admin_password，改登陆密码
# 准备安装环境
./prepare

# 安装 harbor
./install.sh

#  打开浏览器 输入地址http://100.0.0.129:端口  进行访问

# 修改docker daemon.json文件
vi /etc/docker/daemon.json
cat /etc/docker/daemon.json
{
    "insecure-registries":["#域名或者IP地址"]
}

#重启加载daemon.json配置
systemctl daemon-reload

# 重启docker
systemctl restart docker

# 启动 harbor
docker-compose up -d

# 镜像推送到Harbor

# 首先要登录
docker login  100.0.0.129:8082    #域名或ip地址

# 创建项目  项目名
# 打包
docker tag django_books:latest 100.0.0.129:8082/qcc/django_books:v1
            
# 上传
docker push 100.0.0.129:8082/qcc/django_books:v1

8 docker-compose

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

8.1 安装docker-compose

# 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

# 想在任意路径下执行docker-compose都有相应----》需要把可执行文件放到环境变量所在的目录下
chmod +x /usr/local/bin/docker-compose

8.2 常用命令

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 up -d --build # 启动容器但是重新构建镜像，基于重新构建的镜像启动

9 docker-compose 一键部署路飞

# 一台服务器：
	-python3.8 环境 djagno +uwsgi+代码
    -nginx软件
    -mysql 8.0
    -redis 
    
# 每个都做成一个容器
	-djagno项目容器：python3.8 构建的django，项目依赖模块，uwsgi，代码
    -nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
    -mysql 容器：创建，创用户，密码，luffy库
    -redis 容器，跑起来即可
# 目录结构
    luffy
        luffy_api  # 后台项目
        	Dockerfile
            luffy.ini
		luffycity  # 前台项目
        docker_compose_files # 放数据的文件夹（配置，目录映射）
        	nginx
            	default.conf
            redis
            	redis.conf
            mysql.env
        docker-compose.yml #ymal文件
        
        
# 编译，在\luffy\luffycity\dist文件夹
npm run build

luffy/Dockerfile--->构建uwsgi+django

FROM python:3.8
MAINTAINER qcc
WORKDIR /soft
COPY ./requestment.txt /soft/requestment.txt
RUN python -m pip install --upgrade pip && \ 
pip install -r requestment.txt -i https://pypi.doubanio.com/simple
#CMD ["uwsgi", "-x", "./luffy.xml"]
CMD ["uwsgi", "./luffy.ini"]

luffy/Dockerfile ---->luffy.ini

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

docker_compose_files/nginx----->default.conf

server {
  listen 80;
  server_name  100.0.0.129;
  charset utf-8;
  location / {
    root /var/www/html;
    index index.html;
    try_files $uri $uri/ /index.html; # 解决单页面应用刷新404问题
  }
}
server {
  listen 8000;
  server_name  100.0.0.129;
  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/luffy/static;
  }
}

docker_compose_files/redis----->redis.conf

bind 0.0.0.0
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.env

MYSQL_ROOT_PASSWORD=123456
MYSQL_DATABASE=luffy
MYSQL_USER=qcc
MYSQL_PASSWORD=123456
TZ=Asia/Shanghai

docker-compose.yml

version: "3"

services:
  nginx:
    image: nginx
    container_name: luffy_nginx
    ports:
      - "80:80"
      - "8000:8000"
    restart: always
    volumes:
      - ./luffy_city/dist:/var/www/html
      - ./docker_compose_files/nginx:/etc/nginx/conf.d
    depends_on:
      - django
    networks:
      - web

  django:
    build:
      context: ./luffy
      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:/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:8.0
    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