docker

docker的概念

什么是虚拟化

在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。

在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件对资源充分利用。

虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。

虚拟化模块

# kvm：开源的免费的  Kernel-based Virtual Machine的简称，是一个开源的系统虚拟化模块，自Linux 2.6.20之后集成在Linux的各个主要发行版本中
# exsi:vmware商用的，装在裸机上，可以虚拟化出很多机器
# openstack（python开发的，开源的）：电信云，华为云 openstack  管理云平台
# 阿里云（自研，阿里飞天）：云服务器，到一个网站，点点---》付款--》完成
# docker：容器技术
# k8s：多机容器管理，容器编排

docker是什么

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

Docker 自开源后受到广泛的关注和讨论，以至于 dotCloud 公司后来都改名为 Docker Inc。Redhat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 产品中广泛应用。

Docker 项目的目标是实现【轻量级的操作系统虚拟化解决方案】。

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

在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的【容器就像操作一个快速轻量级的虚拟机】一样简单。

为什么要用docker

Docker 容器虚拟化的好处,通过容器来打包应用、解耦应用和运行平台
更快的交付和部署

使用 Docker，开发人员可以使用镜像来快速构建一套标准的开发环境

开发完之后，测试和运维人员可以直接使用完全相同的环境来部署代码

只要是开发测试过的代码，就可以确保在生产环境无缝运行

Docker 可以快速创建和删除容器，实现快速迭代，节约开发、测试及部署的时间
更高效的利用资源

运行 Docker 容器不需要额外的虚拟化管理程序的支持，Docker 是内核级的虚拟化，可以实现更高的性能

同时对资源的额外需求很低，与传统的虚拟机方式相比，Docker 的性能要提高 1 ~ 2 个数量级
更轻松的迁移和扩展

使用 Dockerfile，只需要小小的配置修改，就可以替代以往大量的更新工作

所有的修改都以增量的方式被分发和更新，从而实现自动化并且高效的容器管理

容器与虚拟机比较

作为一种轻量级的虚拟化方式，Docker 在运行应用上跟传统的虚拟机的方式相比具有如下显著优势

Docker 容器启动很快，启动和停止可以实现秒级，相比传统的虚拟机方式（分钟级）要快速很多
Docker 容器对系统资源需求很少，一台主机上可以同时运行数千个 Docker 容器
Docker 通过类似 git 设计理念的操作来方便用户获取、分发和更新应用镜像，存储复用，增量更新
Docker 通过 Dockerfile 支持灵活的自动化创建和部署机制，可以提高工作效率，并标准化流程

docker概念

Docker 中有三个核心概念：镜像、容器和仓库

① 镜像（Image）

Docker 镜像（Image），就相当于是一个 root 文件系统

比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统

② 容器（Container）

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体

容器可以被创建、启动、停止、删除、暂停等

③ 仓库（Repository）

用来保存镜像的仓库

当我们构建好自己的镜像之后，需要存放在仓库中，当我们需要启动一个镜像时，可以在仓库中下载下来

# 1 docker 是cs架构  ，mysql，redis，c和s要通信，使用的http协议，符合resful规范
# 2 Docker镜像：镜像是基于一堆文件，相当于虚拟机装了操作系统，又装了软件的一堆文件
# 3 Docker容器：镜像运行起来，成为了容器，【当成一台虚拟机上面装了一些软件】
	- 类和对象的概念
    - 镜像是类---》生成多个对象
      
# 4 Registry（注册中心）
	-镜像从哪里来？
    	-注册中心中拉取下来

docker安装

# win:下个软件，一路下一步即可（讲课，真正做练习，不要使用它）
	-https://www.docker.com/products/docker-desktop/
    -一路下一步

# centos:建议你直接在虚拟机中安装
	# 先卸载
    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
    
    # 查看版本
    docker -v  # Docker version 23.0.3, build 3e7cbfd

# mac：一路下一步即可

虚拟化工具

-kvm
-exsi
-openstack：python写的云平台，管理虚拟机
-docker：容器技术
-k8s：容器编排

-ansible：批量运维工具，基于ssh  超过500台机器
-salstack：批量运维工具 cs架构
-jenkins：流水线工具
-gitlab：git远程仓库

-普罗米修斯：Prometheus+grafana  ---》go写的
-zabbix：php 运维监控软件

# docker跟虚拟机的区别是docker有自己的网络

Lass/Paas/Saas的简介

Infrastructure-as-a-Service（基础设施即服务）

IaaS公司会提供场外服务器，存储和网络硬件，你可以租用。节省了维护成本和办公场地，公司可以在任何时候利用这些硬件来运行其应用

Paas:平台即服务

paaS公司在网上提供各种开发和分发应用的解决方案，比如虚拟服务器和操作系统。这节省了你在硬件上的费用，也让分散的工作室之间的合作变得更加容易。网页应用管理，应用设计，应用虚拟主机，存储，安全以及应用开发协作工具等

Saas:软件即服务

软件开发、部署、运维后，直接卖给其他公司软件

FAAS

Function as a Service，"功能即服务"（也译作“函数即服务”）

无服务器架构：serverless

docker相关命令

1. docker启动设置镜像

# 查看状态
   systemctl status docker
# 启动
   systemctl start docker
    
# 设置ustc的镜像       下载镜像   国外下载慢--->设置国内镜像站
    国外：https://hub.docker.com #域名改成https://www.docker.com/
    国内：https://cr.console.aliyun.com/cn-shanghai/instances/mirrors # 阿里云服务器自己有一个镜像站
        
# docker安装后会有 /etc/docker文件夹
    1.切到目录/etc/docker  新建一个json文件或者直接创建完整目录
    vim /etc/docker/daemon.json
    2.设置镜像站
        {
            "registry-mirrors": ["https://fdm6xogf.mirror.aliyuncs.com"]
            }
    3.执行下面命令
    	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

2.镜像相关命令

# 查找镜像
   docker search  镜像名称
   建议去hub.docker.com 直接搜

# 拉取镜像，指定标签 tag
    docker pull centos:7   # centos版本号  如果不指定默认下载最新版
    docker pull centos
    docker pull centos:latest
        
# 查看本地镜像
    docker images   # 等同于docker image ls
    
    
# 删除镜像  
     docker rmi 镜像id    # 可以同时删多个
    
# 5 删除所有镜像
    # 查出所有镜像的id号
        docker rmi `docker images -q`

3. 容器相关命令

把镜像运行成容器，并且一个一个镜像，可以运行出多个容器.

# 查看正在运行的容器
	docker ps
# 查看所有容器
	docker ps -a
# 查看最后一次运行的容器
 	docker ps -l
    
# 运行容器--1.创建容器：create,2.运行容器：run
  如果容器没有创建，直接执行run，就会创建并运行
    -run有很多参数
    """
     -i：表示运行容器
     -t：表示容器启动后会进入容器命令行。加入这两个参数后，容器创建就能登录进去。即分			配一个伪终端。
     -d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动			登录容器，如果只加-i -t两个参数，创建后就会自动进去容器） 
        
     --name :为创建的容器命名，如果不写，随机生成一个名字     
     -v： 表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多			个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到			容器上。
     -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个			端口映射
    """
    docker run -id  # 不会进入到容器内部
	docker run -it  # 会进入到容器内部
    
    
 
# 启动一个centos容器,名字叫mycentos，并且进入
    docker run -it --name=myfirstcentos centos:7
    yum install vim -y  # 在容器中装了vim软件
    exit  # 退出，容器停止了


# 启动一个centos容器,名字叫mycentos，不进入
     docker run -id  centos:7

# 启动容器
    docker start myfirstcentos


# 进入到容器内部（本质是让容器执行命令） 
    docker exec 容器id 命令
    docker exec f82e8578b9b1 ls
    docker exec -it  f82e8578b9b1 /bin/bash  # 进入到容器内部

# 退出
    exit

# -v参数：目录映射
     docker run -id --name=secondcento -v /home/kiki:/kiki centos:7 #secondcento容器下面的kiki文件下面编辑文件或者内容都会在home目录下kiki文件展示
     以后无论在宿主机还是容器中修改当前目录下的文件，都会相互影响
:
# -p参数：端口映射  容器中启动一个mysql5.7 --》容器中的3306监听，宿主机3306没人监听，做端口映射后，宿主机的3306就被docker的这个容器监听了
# 启动的mysql的root密码是123456
 
docker run -id --name=mysql1 -p 81:3306  -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

#  netstat -nlp |grep 80  查看本机80端口占用情况
# 以后访问宿主机80端口就等于访问容器的3306端口 
"""  通过公网ip连接,以后操作本地库或者容器mysql数据都是同步，但把容器删除了，本地库和表都会删除了
    解决方法：
    1.做目录映射，防止删除了也能新建服务后再连接使用
"""

容器操作

# 启动容器
	docker start 容器id
# 停止容器
	docker stop 容器id
 
# 文件拷贝
	# 容器的文件copy到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  57547e2e0397:/home/kimi.txt /home/kimi.txt  # 宿主机不需要提前创建kimi.txt
        
    # 宿主机的文件copy到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp ./kiki.txt 57547e2e0397:/home/kiki.txt
 
# 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
    docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
    eg:docker inspect --format='{{.NetworkSettings.IPAddress}}' 57547e2e0397
    
    
# 在多个容器之间是可以ping通的   # ping 172.17.0.2是证明是该ip是可以联网
    # centos:172.17.0.3
    # mysql:172.17.0.2
    
    
# 删除容器（删除已停止的容器---先停止(determined_jones)后删除）
	docker rm 容器id  
    docker rm `docker ps -a -q`
# 无状态的服务
	-myslq reids
    -uwsgi+django
    # 有状态的服务一般不建议部署在容器

镜像从哪里来?

远程仓库拉取的 docker pull
用容器做成的镜像 docker commit
把备份的恢复 docker load
使用Dockerfile来构建

应用部署

1. mysql部署

# 1.端口映射
docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
        
# 2.做目录映射：data文件，配置文件----前提不能有容器mysql5.7在运行
	# 创建文件夹
    mkdir /home/mysql  # 创建文件夹
    mkdir /home/mysql/conf.d   # 创建配置文件
    mkdir /home/mysql/data/   # 创建数据存放的文件
    vim /home/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 /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 3305:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7     
                        
                        
# 3 创建库  创建表  插入数据
# 4  关闭容器 删除容器 mysqld的容器没了 ,但是数据在宿主机上放着
# 5  再运行一个容器 做好目录映射,数据都回来了
 
 注意点:之前部署过django项目 本地3306端口监听着项目mysql3306  本地6739监听项目redis6379  80监听80  所以下面本地端口要改

2. redis部署

# 不能提前先创一模一样的容器
1. 拉取redis镜像
     docker pull redis  # 拉取镜像
     mkdir /root/data    # 根目录创建data文件夹
	vim /root/redis.conf  # 创建并编辑redis配置文件
            bind 0.0.0.0
            daemonize NO
            protected-mode no
            requirepass 123456
            
            
2.运行  映射目录并运行
    docker run -id  -p 6378:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf  
     # 目录  端口  配置文件 映射
    
3.远程链接redis操作

3.nginx部署

1. 拉取nginx镜像
  docker pull nginx
    
2.run起容器
  docker run -id --name nginx -p 81:80 nginx   # 默认是最新nginx
  
3.修改展示给前端的html文件    /usr/share/nginx/html
    docker run -id --name nginx -p 81:80 -v /root/html:/usr/share/nginx/html nginx
            
  # 以后只需要修改宿主机的/root/html 路径，访问47.102.20.8:81/看到页面就是修改后的

4 python38部署

下载wget和make

# 1 没下载wget，先下载wget
yum -y install wget

# 2 下载make
yum -y install gcc automake autoconf libtool make

安装python3.8

# 1前往用户根目录
>: cd ~
 
#2 下载 或 上传 Python3.8.6  服务器终端
wget https://registry.npmmirror.com/-/binary/python/3.8.6/Python-3.8.6.tgz
 
#3  解压安装包
tar -xf Python-3.8.6.tgz
 
#4 进入目标文件
cd Python-3.8.6
 
#5  配置安装路径：/usr/local/python3
# 把python3.8.6 编译安装到/usr/local/python38路径下
>: ./configure --prefix=/usr/local/python38
 
#6  编译并安装,如果报错，说明缺依赖
yum install openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel sqlite-devel psmisc libffi-devel zlib* libffi-devel  -y
make & make install
  # 编译成功会提示建立软件/usr/local/python38/bin
 
#7  建立软连接：/usr/local/python38路径不在环境变量，终端命令 python3，pip3
#没有把/usr/local/python38/bin加入到环境变量
ln -s /usr/local/python38/bin/python3.8 /usr/bin/python3.8
ln -s /usr/local/python38/bin/pip3.8 /usr/bin/pip3.8  
   #可以到/usr/local/python38/bin目录下看是否下载成功，，/usr/bin目录查看是否建立成功软连接
 
# 机器上有多个python和pip命令，对应关系如下
python3.8    3.8      pip3.8
 
#8  删除安装包与文件：
>: rm -rf Python-3.8.6
>: rm -rf Python-3.8.6.tar.xz

③ 打包成镜像

docker commit -a "作者名" -m "提交生成镜像的说明信息" 容器id  新镜像的名字:新镜像的tag
docker commit -a "kimi" -m "create new img" 57547e2e0397  py3.8:v3.8

将镜像运行成容器，就可以直接使用了

5. Dockerfile部署

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

常用命令

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

不常用命令

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

构建一个带vim的centos镜像

vim Dockerfile  # 在宿主机上创建一个文件 文件里面书写下面的

FROM centos:7
MAINTAINER kimi
ENV name kimi
RUN yum install vim -y   # 只是下载了vim工具
RUN mkdir /kimi
RUN touch /kimi/aa.py
RUN echo 'print("每天都很努力")' >/kimi/aa.py
COPY redis.conf /kimi/   # 网上答案
WORKDIR /kimi

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

dockerfile构建django文件

在公司中，使用Docker开发的工作流程：

pycharm开发项目，项目开发完

在项目路径下新建Dockerfile，编辑下面内容

FROM python:3.8
MAINTAINER kimi
WORKDIR /soft  # mkdir soft  and cd 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 init
git add .
git commit -m ''
git push origin master

上线人员在上线机器上，把代码拉下来

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

构建镜像

cd books  # 不然找到dockerfile下的目录soft
docker build -t='django-books' .

运行容器

docker run -id --name=books -v /root/books:/soft -p 8081:8080 django-books:latest  # 端口和目录做映射
    
docker exec -it id  /bin/bash

"""
如果镜像不是books目录下构建的，它是找不到dockerfile文件的
解决方法：停止容器  删除容器  删除镜像  切到books下新构建新镜像
"""

其他直接访问宿主机的8081端口就能看到前端页面

公网+8081

开发人员继续提交代码到docker
运维人员pull代码，重启容器，用户就可以看到最新版的

重启docker容器即可（第三方依赖变了）---要重写构建镜像，再运行容器

docker私有仓库

docker官方提供的远程仓库，可以把自己定义的镜像传上去，就是自己的私有镜像（可公开）。公司做的镜像一般不放在远程仓库，会放在公司自己搭建私有仓库（把公司制作的镜像传到私有仓库）

1. 镜像传到官方仓库

1.在远端创建仓库
2.给镜像打标签
	docker tag ab5c0e652fd4 liuqingzheng/centos_vim:v1  # docker的名字加上镜像名字和标签
3. 登录到远程
    虚拟机  docker login  # 用户名是docker名字  密码是docker密码
4.将镜像提交docker远程仓库
    docker push liuqingzheng/centos_vim:v1
5.任意人就可以下载使用镜像了
	docker pull liuqingzheng/centos_vim:v1

2.镜像分层

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

RUN yum install vim -y
RUN yum install git -y


# 查看镜像分层的命令
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

3.私有仓库搭建

企业级的私有仓库Harbor ，harbor部署与使用：https://blog.csdn.net/Gf19991225/article/details/121982824

docker搭建私有仓库---registry

1.拉取镜像
	docker pull registry 
2.运行容器
    docker run -di --name=registry -p 5000:5000 registry
3.打开浏览器 
	输入地址http://47.102.20.8:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
4.修改daemon.json
    vim /etc/docker/daemon.json
    {
       
        "insecure-registries":["47.102.20.8:5000"]
    } 
5. 重启docker 让配置生效
	systemctl restart docker
    
    docker start registry
6.把某个镜像tag成私有仓库的镜像
    docker tag 镜像名字/id 47.102.20.8:5000/django_books:v1
       eg:docker tag registry 47.102.20.8:5000/django_books:v1
7.提交到私有仓库
	docker push 47.102.20.8:5000/django_books:v1
8.其他人，只要配置了私有仓库就可以直接拉取
     docker pull 47.102.20.8:5000/django_books:v1

docker-compose介绍

使用docker部署项目时，会存在一个问题，把mysql、redis都放在一个容器中，之后不好使用服务，如果每个服务放在一个容器，批量管理多个容器，比较难操作，于是出现了docker-compose.

docker-compose是一个能一次性定义和管理多个Docker容器的工具，单机容器编排【定义和管理】。Compose中定义和启动的每一个容器都相当一个服务（service)，Compose中能定义和启动多个服务，且它们之间通常具有协同关系。管理方式：

使用YAML文件来配置我们应用程序的服务。
使用单个命令（docker-compose up），就可以创建并启动配置文件中配置的所有服务。

多容器编排的工具：

-docker swarm：公司里用的不多
-k8s是多机容器编排工具，go语言写了k8s

docker-compos常用命令

# 常用命令
# 启动管理容器
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-compos下载

# 安装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  # 官方下载很慢，可以直接rm 安装有压缩包
    
 # 复制目录
cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose 

# 给执行的权限
chmod +x /usr/local/bin/docker-compose  


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

docker-compose部署flask-redis项目

flask项目，使用redis服务---->2个容器

新建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)  # 拿到主机的id和端口号   也可以设置密码--》项目是公司内网的也不设置密码

@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
COPY . /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:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis

docker-compose启动

1.ping redis  连接
    
 # 进入到了web，ping redis
    # 安装ping命令，
    apt-get update
    apt-get install inetutils-ping
    ping redis
    
    
2.# 一键部署：redis，和flask ，每个都在一个容器中
docker-compose up

docker-compose一键部署项目

# 一台服务器：
	   -python3.8 环境 djagno +uwsgi+代码
    -nginx软件
    -mysql 5.7
    -redis 
    
# 每个都做成一个容器
	   -djagno项目容器：python3.8 构建的django，模块，uwsgi，代码
    -nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
    -mysql 容器：创建，创用户，密码，luffy库
    -redis 容器，跑起来即可
    

# 项目部署过程
1.前端项目
  # 把luffycity/dist 文件夹删除
  # 把\luffy\luffycity\src\assets\js\settings.js后端地址改成上线地址(服务器地址)
  # 来到前端路径下：luffy\luffycity
       cnpm install  安装依赖
  # 编译，在\luffy\luffycity\dist文件夹
       npm run build--》dict文件  # 切到前端luffycity路径下

  # 提交到git上

2.线上操作
# 在部署的机器上，git clone 下来
# 进入到项目目录luffy
  docker-compose up  # docker提前把docker-compose装好
# 直接访问公网+后端8000可以访问后台，公网+80就可以访问前台了
# 如果数据没有，可能数据库没起






# 部署路飞项目
-后端写一个Dockerfile,构建镜像
- mysql,redis,nginx 基于官方
-nginx：代理前端，请求转发---》自己的配置文件
-redis：目录映射，数据放到宿主机，配置文件宿主机的
-mysql：创建用户，创建库
 
 -docker-compose up -d
 -数据库导入，部署完成

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的配置文件

2. luffy_api/Dockerfile--->构建uwsgi+django

#依赖镜像名称和ID
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"]

3.docker-compose.yml

version: "3"

services:
  nginx:
    image: nginx
    container_name: luffy_nginx
    ports:
      - "80:80" # nginx监听80
      - "8000:8000"  # nginx监听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"  # 前6379是本地的端口 后6379是容器里redis
    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:

4. 一键部署

docker-compose up

posted @ 2023-04-11 19:44 魔女宅急便阅读(28) 评论(0) 收藏举报

刷新页面返回顶部

kimi

docker

docker

docker的概念

什么是虚拟化

docker是什么

为什么要用docker

容器与虚拟机比较

docker概念

① 镜像（Image）

② 容器（Container）

③ 仓库（Repository）

docker安装

虚拟化工具

Lass/Paas/Saas的简介

docker相关命令

1. docker启动设置镜像

2.镜像相关命令

3. 容器相关命令

容器操作

镜像从哪里来?

应用部署

1. mysql部署

2. redis部署

3.nginx部署

4 python38部署

5. Dockerfile部署

常用命令

不常用命令

构建一个带vim的centos镜像

dockerfile构建django文件

docker私有仓库

1. 镜像传到官方仓库

2.镜像分层

3.私有仓库搭建

docker-compose介绍

docker-compose部署flask-redis项目

docker-compose一键部署项目

1. 项目目录结构

2. luffy_api/Dockerfile--->构建uwsgi+django

3.docker-compose.yml

4. 一键部署

公告