使用docker部署项目

一 Dockerfile

1.1 dockerfile介绍和常用命令

# 镜像从哪里来的?
	1 远程仓库拉取的 docker pull   (hub.docker--->搭建私有仓库)
    2 用容器做成的镜像 docker commit 
    3 把备份的恢复 docker load
    4 使用Dockerfile来构建
    
    

# 什么是Dockerfile
	Dockerfile是由一系列命令和参数构成的脚本文件,这些命令应用于基础镜像并最终创建一个新的镜像
    # centos7中,装了vim,在根路径下新建了一个文件 lqz.txt,写了写内容
    
# Dockerfile的命令
	FROM 基础镜像 	     # 基于哪个基础镜像来构建
    MAINTAINER lqz 	     # 声明镜像的创建者,maintainer,维修工,维护员
    ENV key value 	     # 设置环境变量 (可以写多条)
    RUN command 	     # 执行命令,是Dockerfile的核心部分(可以写多条)
    ADD source_dir/file dest_dir/file 	# 将宿主机的文件复制到容器内,如果是一个压缩文件,将会在复制后自动解压
    COPY source_dir/file dest_dir/file 	# 和ADD相似,但是如果有压缩文件并不能解压
    WORKDIR lqz 	# 设置工作目录,运行起这个容器,来到的路径就是这个路径

1.2 小案例

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

# 使用Dockerfile做
cd ~
mkdir lqz
cd lqz  # 把Dockerfile创建到lqz文件夹下
vim aa.txt  # 创建aa.txt文件,输入内容


vim Dockerfile

FROM centos:7
MAINTAINER lqz
ENV name lqz
RUN yum install vim -y
RUN mkdir /lqz
RUN touch /lqz/ss.py
RUN echo 'print(1)' >/lqz/ss.py
COPY ./aa.txt /lqz/aa.txt
WORKDIR /lqz

'''
FROM centos:7  # 基于哪个基础镜像来构建
MAINTAINER lqz
ENV name lqz  # 镜像启动成容器后,直接在环境变量中取name就是lqz
RUN yum install vim -y  # 安装vim,执行命令
RUN mkdir /lqz
RUN touch /lqz/ss.py  # 创建ss.py文件
RUN echo 'print(1)' >/lqz/ss.py  # 输出print(1)到ss.py
COPY ./aa.txt /lqz/aa.txt  将./aa.txt文件复制一份到lqz/aa.txt中
WORKDIR /lqz  # 来到容器内部就是/lqz下,设置工作目录
CMD  # 没有设置cmd命令,那么进入容器后,就会执行centos:7的cmd命令(bin/bash)
'''


# 基于dockerfile构建镜像,不要忘了 .   基于当前路径下的Dockerfile 构建镜像
docker build -t='镜像名' . 
docker build -t='centos_lqz_vim' . 


[+] Building 41.1s (12/12) FINISHED                        docker:default
 => [internal] load build definition from Dockerfile               0.1s  # 基于 Dockerfile 文件加载创建
 => => transferring dockerfile: 212B                                 0.0s
 => [internal] load .dockerignore                                    0.1s
 => => transferring context: 2B                                      0.0s
 => [internal] load metadata for docker.io/library/centos:7          0.0s
 => [1/7] FROM docker.io/library/centos:7                            0.1s
 => [internal] load build context                                    0.1s
 => => transferring context: 56B                                     0.0s
 => [2/7] RUN yum install vim -y                                    36.2s  # 执行RUN后的命令
 => [3/7] RUN mkdir /lqz                                             0.6s
 => [4/7] RUN touch /lqz/ss.py                                       0.4s 
 => [5/7] RUN echo 'print(1)' >/lqz/ss.py                            0.4s 
 => [6/7] COPY ./aa.txt /lqz/aa.txt                                  0.1s 
 => [7/7] WORKDIR /lqz                                               0.2s 
 => exporting to image                                               2.9s 
 => => exporting layers                                              2.9s
 => => writing image sha256:ad1eca551a6fdde4598852325e039371d3a1edc  0.0s
 => => naming to docker.io/library/centos_lqz_vim                    0.0s
[root@iZ2ze3wvcie3ks4ttycl4cZ ~/lqz]


# 查看镜像
docker images
# 基于这个镜像运行容器
docker run -id --name xx centos_lqz_vim
# 进入到容器
docker exec -it xx /bin/bash
# 验证vim,和文件夹,文件是否存在



[root@iZ2ze3wvcie3ks4ttycl4cZ ~]# docker exec -it xx /bin/bash
[root@fcf3407de421 lqz]# ---> 进入容器中就直接进入lqz目录下
[root@fcf3407de421 lqz]# ls ---> 该目录下有两个文件aa.txt  ss.py
aa.txt  ss.py
[root@fcf3407de421 lqz]# cat aa.txt  ---> 查看文件内容
nvaugoapejgihabhajbig

[root@fcf3407de421 lqz]# cat ss.py 
print(1)
[root@fcf3407de421 lqz]# echo $name  ---> 获取环境变量,使用$
lqz

'''
拓展:
	1构建镜像时设置的环境变量,进入python程序中,也可以取出os.environ.get()
	2部署Django,密码放在环境中,这样不同的用户就可以设置不同的密码啦,更加安全
'''

1.3常用和不常用命令

# https://zhuanlan.zhihu.com/p/419175543

FROM: 指定基础镜像
RUN: 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD:添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
ENTRYPOINT:同CMD,但这个一定会被执行,不会被覆盖修改。
MLABELAINTAINER:表明镜像的作者。将被遗弃,被LABEL代替。
EXPOSE:设置对外暴露的端口。
ENV:设置执行命令时的环境变量,并且在构建完成后,仍然生效
ARG:设置只在构建过程中使用的环境变量,构建完成后,将消失
ADD:将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件,能将URL作为要拷贝的文件
COPY:将本地文件或目录拷贝到镜像的文件系统中。
VOLUME:添加数据卷
USER:指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
WORKDIR:设置工作目录


# docker logs 容器名字/id号  展示日志

CMD ENTRYPOINT

entrypoint  进入点

# 相同点:
只能写一条,如果写了多条,那么只有最后一条生效。
容器启动时才运行,运行时机相同。
# 不同点:
ENTRYPOINT不会被运行(镜像运行成容器时docker run -id 后面的命令)的command覆盖,而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD,并且CMD指令不是一个完整的可执行命令,那么CMD指定的内容将会作为ENTRYPOINT的参数

FROM ubuntu 
ENTRYPOINT ["rm", "docker2"] 
CMD ["-rf"]
它真正执行的命令将会是:rm docker2 -rf。

如果我们在Dockerfile种同时写了ENTRYPOINT和CMD,并且CMD是一个完整的指令,那么它们两个会互相覆盖,谁在最后谁生效。如下所示:
FROM ubuntu
ENTRYPOINT ["top", "-b"]  
CMD ls -al
那么将执行ls -al,top -b不会执行

ARG的使用

FROM centos:7
ARG age 19

RUN echo 19>aa.txt
CMD ls -al
# 只在构建过程中生效

1.4 dockerfile构建一个djagno项目(books图书管理系统)

# 以图书管理系统为例--->公司使用docker流程


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


curl 0.0.0.0:8080  # 是向ip+port发送get请求

--------
查看端口占用
netstat -lntp
杀掉进程
kill -9 PID
停止正在运行的容器
docker stop 1a27df1911a2
删除容器
docker rm 容器id  
---------
第八步:开发人员继续提交代码
第九步:运维人员pull代码,重启容器,用户就可以看到最新的了
git pull origin master
重启docker容器即可(第三方依赖变了)-->重写构建镜像,运行容器
docker restart books

二 docker私有仓库

# 有个远程仓库 ,docker官方提供的 --->我们可以把我们的镜像传上去
# 公司做的镜像,一般不放在远程仓库,公司会自己搭建私有仓库(把公司制作的镜像传到私有仓库)

2.1 镜像传到官方仓库

# 第0步:在远端创建仓库
hub.docker.com/
# 第一步:给镜像打标签
docker tag 镜像名/镜像id 指定的远程仓库地址:版本
docker tag 086e6b3e71c0 liuqingzheng/lqz_books:v1
# 第二步:登录到远程
docker login
用户名:不是邮箱
密码:挺复杂


# 第三步:提交,上传镜像
docker push liuqingzheng/lqz_books:v1

# 第四步:别人就可以下载了
下载之前必须登录dockerhub
docker pull liuqingzheng/lqz_books:v1

2.2 镜像分层

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


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


# 查看镜像分层的命令
docker history  liuqingzheng/lqz_books:v1

# 好处:
构建快,分发方便,如果本地有某一层了,这一层就不需要下载了


# 补充:Dcokerfile 写命令,建议多条命令合为一条--->这样只会生成一层
RUN python -m pip install --upgrade pip &&\
    python -m pip install --upgrade setuptools &&\
    pip install -r requirements.txt


2.3 私有仓库搭建

# 自己搭建私有仓库
	-harbor:企业级私有仓库--->https://blog.csdn.net/Gf19991225/article/details/121982824
    -registry:我们用docker搭建私有仓库

# 搭建步骤:
-第一步:拉取镜像 docker pull registry
-第二步:运行容器:docker run -di --name=registry -p 5000:5000 registry
    -registey没有图形化界面
	-就是一个web服务端-->从浏览器中访问它
    
-第三步:打开浏览器 输入地址http://47.94.149.117:5000/v2/_catalog 看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空

-第四步:修改daemon.json
# 不要删除之前的配置,只添加
vi /etc/docker/daemon.json
{
    "insecure-registries":["47.94.149.117:5000"]
} 
    
-第五步:重启docker 让配置生效
systemctl restart docker
docker start registry

-第六步:把某个镜像tag成私有仓库的镜像,并打标签
docker tag 镜像名字/id 远程仓库的地址:监听的端口/起个名字
docker tag centos_lqz_vim 47.94.149.117:5000/centos_lqz_vim

-第七步:提交到私有仓库
docker push 47.94.149.117:5000/centos_lqz_vim
    -这个比较慢,因为私有仓库现在什么也没有,需要一层一层下载
    -之前的地址http://47.94.149.117:5000/v2/_catalog刷新就能看到{"repositories":["centos_lqz_vim"]}

 -第八步:其他人,只要配置了私有仓库就可以直接拉取
 docker pull 8.130.125.9:5000/django_books:v1
            
            
# 其他人只要是配置了"insecure-registries":["47.94.149.117:5000"]之后,就可以在docker这个私有仓库中拉取之上的镜像了。

三 docker-compose

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

# 批量管理,操作docker容器的--->只在单机

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

# 多机容器编排
	-docker swarm:官方提供的,公司里用的不多
	-k8s是多机容器编排工具,go语言写了k8s,后面(到了公司后)可以学习学习

# Docker Compose概念
    Compose中定义和启动的每一个容器都相当于一个服务(service)
    Compose中能定义和启动多个服务,且它们之间通常具有协同关系
    -管理方式:
    使用YAML文件来配置我们应用程序的服务。
    使用单个命令(docker-compose up),就可以创建并启动配置文件中配置的所有服务。
    
    

# 安装docker-compose (可执行文件,放在了github上,下载下来即可,速度很慢)
# https://github.com/docker/compose/releases
下载docker-compose-linux-x86.64位

# 可以wget下载
wget https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64
    
# 可以直接下载到桌面上,上传到lqz下
rz


cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose
# cp:复制文件,+x是增加执行权限
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 up # 前台执行
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

# flask 项目,使用redis服务---> 2个容器
	flask 项目容器
    redis容器
    # 使用docker-compose管理多个容器

4.1 新建flask项目 app.py

from flask import Flask
from redis import Redis
import os

app = Flask(__name__)
# 会取到redis字符串,不需要写ip,直接写容器名,就可以连接通
# redis = Redis(host='redis', port=6379)
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)

4.2 编写Dockerfile-->用于构建flask项目的镜像

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

##########################文件解析###################
# redis镜像是可以从远端拉取的,但是falsk镜像只能是自己建立的
FROM python:3.8  # 基于哪个基础镜像来构建
WORKDIR /app  # 设置工作目录,运行容器后来到当前路径下的app文件下
COPY . /app  # 当前资源下的所有都拷到app文件下
RUN pip install flask redis -i   https://pypi.tuna.tsinghua.edu.cn/simple  # 执行命令安装flask、redis两个模块
EXPOSE 5000  # 暴露在外的5000端口
CMD [ "python", "app.py" ]  # 运行项目命令,进入容器后执行的命令
#####################################################

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

version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis
         
##########################文件解析###################        
version: "3"  # 固定,版本就是3
services:  # 几个服务就是几个容器
  redis:  # redis服务
    image: redis  # image镜像,如果没有redis服务,就会直接去官方拉取最新的
  web:  # web服务
    build:  # 自己构建需要写build
      context: .  # 基于什么路径构建
      dockerfile: Dockerfile  # 就是基于当前路径下的Dockerfile文件构建
    ports:  # -p参数,8080映射成5000端口
      - 8080:5000
    environment:  # -e参数,这里设置环境变量中取REDIS_HOST,取到的是'redis'字符串
      REDIS_HOST: redis
#####################################################

4.4 docker-compose启动

# 1 把项目文件上传到远端
	方式一:上传git,拉取
    方式二:直接把项目文件压缩,rz上传,解压

 
# 2 一键部署:redis,和flask ,每个都在一个容器中
docker-compose up


# 进入到redis中,查看访问次数
docker-compose ps
docker-compose exec redis /bin/bash # 进入redis服务中
redis-cli  # 客户端连接
git hits  # 查看数据
# 进入项目中
docker-compose exec web /bin/bash # 进入web(项目)服务中

# 如果redis服务的名字叫redis,我在web服务中(容器中),根据redis名字就能拿到容器
	ping redis
    
# 进入到了web,ping redis
# 安装ping命令
apt-get update
apt-get install inetutils-ping
ping redis

五 docker-compose一键部署路飞

# 一台服务器:
	-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 


# pycharm文件:
-修改前端链接后台的地址:luffycity/src/access/xx.js
-编译:npm run build
-提交到git
git add 文件夹名字
git commid -m '名'
git push orgter master

# 远程服务器中
git clone https://gitee.com/liuqingzheng/luffy.git  # 拉取项目

docker-compose up  # 一键部署
-访问宿主机的 80 端口,就可以看到luffy项目啦

5.1 项目目录结构

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

5.2 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"]

5.3 docker-compose.yml

参数介绍:https://blog.csdn.net/shixiaodongmain/article/details/127850973

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再启动nginx
      - django
    networks:
      - web

  django:
    build:  # 构建镜像的 dockerfile 的路径
      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:  # network,设置网络连接,把web加入网络
      - 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

5.4 一键部署

docker-compose up  

作业

# dockerfile用过吗?用了哪些常用命令?
FROM: 指定基础镜像
RUN: 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD:添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
ENTRYPOINT:同CMD,但这个一定会被执行,不会被覆盖修改。
EXPOSE:设置对外暴露的端口。
ENV:设置执行命令时的环境变量,并且在构建完成后,仍然生效
ARG:设置只在构建过程中使用的环境变量,构建完成后,将消失
ADD:将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件,能将URL作为要拷贝的文件
COPY:将本地文件或目录拷贝到镜像的文件系统中。
VOLUME:添加数据卷
USER:指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
WORKDIR:设置工作目录

# CMD  ENTRYPOINT entrypoint  进入点
#相同点:
只能写一条,如果写了多条,那么只有最后一条生效。
容器启动时才运行,运行时机相同。
# 不同点:
ENTRYPOINT不会被运行的command覆盖,而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD,并且CMD指令不是一个完整的可执行命令,那么CMD指定的内容将会作为ENTRYPOINT的参数

FROM ubuntu 
ENTRYPOINT ["rm", "docker2"] 
CMD ["-rf"]
它真正执行的命令将会是:rm docker2 -rf。

如果我们在Dockerfile种同时写了ENTRYPOINT和CMD,并且CMD是一个完整的指令,那么它们两个会互相覆盖,谁在最后谁生效。如下所示:
FROM ubuntu
ENTRYPOINT ["top", "-b"]  
CMD ls -al
那么将执行ls -al,top -b不会执行
posted @ 2023-08-27 21:03  星空看海  阅读(60)  评论(0编辑  收藏  举报