首页 > 其他分享 >Docker - 容器虚拟化

Docker - 容器虚拟化

时间：2023-05-04 17:46:37浏览次数：48  
标签：容器 compose centos 虚拟化 redis 镜像 Docker docker

目录

Docker

0 虚拟化

0.1 什么是虚拟化

在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。 在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件 对资源充分利用 虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。

0.2 虚拟化技术中常见名词

kvm：开源的免费的 Kernel-based Virtual Machine的简称，是一个开源的系统虚拟化模块，自Linux 2.6.20之后集成在Linux的各个主要发行版本中

exsi:vmware商用的，装在裸机上，可以虚拟化出很多机器

openstack（python开发的，开源的）：电信云，华为云 openstack 管理云平台

阿里云（自研，阿里飞天）：云服务器，到一个网站，点点---》付款--》完成

docker：容器技术

k8s：多机容器管理，容器编排

1 docker简介

docker是c/s架构，在服务端和客户端之间使用的是HTTP协议，符合RESTful规范

MYSQL 、Redis也是c/s架构，但是它们的服务端和客户端之间使用的是自己基于tcp协议封装

1.1 什么是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 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植 的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低

1.2 docker的优势

① Docker 容器化技术

② Docker 在开发和运维中的优势

上手快

职责的逻辑分类

快速高效的开发生命周期

鼓励使用面向服务的架构

1.3 容器与虚拟机比较

可见容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统方式则是在硬件层面实现。

与传统的虚拟机相比，Docker优势体现为启动速度快、占用体积小。

image-20230301164854227

特性 容器 虚拟机
启动速度 秒级 分钟级
性能 接近原生 较好
内存 MB级 GB级别
硬盘适应 MB级 GB级别
运行密度 单台主机支持上千个 单台主机支持几个
隔离性 安全隔离 完全隔离
迁移 优秀 一般

2 Docker镜像、容器、仓库

Docker 中有三个核心概念：镜像、容器和仓库
因此，准确把握这三大概念对于掌握 Docker 技术尤为重要
名称 释义
镜像 启动容器的模板
容器 对外提供服务的实例
仓库 存放镜像的仓库

① 镜像（Image）

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

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

② 容器（Container）

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

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

③ 仓库（Repository）

用来保存镜像的仓库

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

3 Docker安装

3.1 在服务器中安装docker

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

3.2 启动和停止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

4 启动设置镜像

4.1 设置远程仓库

① 查看docker的状态

systemctl status docker

② 启动docker服务

systemctl start docker

③ 配置docker远程仓库 - 设置阿里云镜像站

每个人的镜像加速器地址都是不同的，可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://8fnjvave.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

image-20230412150323665

4.2 镜像相关命令

# 1 查找镜像
	-docker search 镜像名称  
    -建议去hub.docker.com 直接搜，更直观
    
    
# 2 拉取镜像，指定标签 tag
	docker pull centos:7
    如果不指定标签，会下载最新
    docker pull centos
    docker pull centos:latest
        
        
        
# 3 查看本地镜像
	docker images  # 等同于 docker image ls
    
    
# 4 删除镜像
	docker rmi 镜像ID   # 可以同时删多个

    
# 5 删除所有镜像
    # 查出所有镜像的id号
        docker rmi `docker images -q`
  • 使用centos 7 的镜像
# 1 使用tag 拉取镜像
docker pull centos:centos7

# 2 查看本地镜像
docker images

# 3 删除镜像 
docker rmi 镜像ID-1,镜像ID-2,...

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

-- docker images -q 是查看本地所有的镜像id，所以用模版符号引起来后，相当于查出来所有镜像id，并删除
image-20230412152541564

5 容器相关命令

5.1 创建容器

如果容器没有创建，直接执行run，就会创建并运行容器

（1）run 的参数

-i：表示运行容器

-t：表示容器启动后会进入容器命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。

-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）
        
        
--name :为创建的容器命名，如果不写，随机生成一个名字
            
            
-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。

-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

（2） run命令创建容器

docker run -id  # 不会进入到容器内部
docker run -it  # 会进入到容器内部

# 创建mysql的容器，并指定密码和映射的端口
docker run -id --name=mysql -p 80:3306  -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
  • 建立centos 的容器
[root@duo ~]# docker run -it --name=py_centos7 centos:7
Unable to find image 'centos:7' locally
7: Pulling from library/centos
Digest: sha256:9d4bcbbb213dfd745b58be38b13b996ebb5ac315fe75711bd618426a630e0987
Status: Downloaded newer image for centos:7
[root@ae9a0b5d7921 /]# mkdir zakduo
[root@ae9a0b5d7921 /]# ls
anaconda-post.log  dev  home  lib64  mnt  proc  run   srv  tmp  var
bin                etc  lib   media  opt  root  sbin  sys  usr  zakduo

（3）进入到容器内部（本质是让容器执行命令）

docker exec 容器id 命令
docker exec f82e8578b9b1 ls

docker exec -it  f82e8578b9b1 /bin/bash  # 进入到容器内部

# 退出
exit

image-20230412153646031

5.2 容器相关命令

（1） 查看容器

# 查看正在运行的容器
	docker ps
# 查看所有容器
	docker ps -a
# 查看最后一次运行的容器
 	docker ps -l

（2）运行容器

① 不进入容器

docker exec 容器id 命令

# docker exec f82e8578b9b1 ls

② 进入容器

docker exec -it  f82e8578b9b1 /bin/bash  # 进入到容器内部

（3）在centos的容器上安装python3.8并打包成镜像

① 拉取centos7 的镜像，制作容器

docker pull centos:7

# 启动一个centos容器,名字叫mycentos，并且进入
docker run -it --name=mycentos centos:7

② 在容器上安装python3.8

  • 下载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
 
#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
 
# 机器上有多个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 "zakduo" -m "create new img" ae9a0b5d7921  py3.6:v3.6

docker commit -a "作者名" -m "提交生成镜像的说明信息" 容器id  新镜像的名字:新镜像的tag

image-20230412184746438

image-20230412184733057

image-20230412184648819

https://blog.csdn.net/weixin_45505313/article/details/125020076

（4）容器操作

# 启动容器
	docker start 容器id
# 停止容器
	docker stop 容器id

# 文件拷贝
		# 容器内的文件copy --> 到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  20fd8:/home/lqz.txt /home/lqz.txt
    
    # 宿主机的文件copy --> 到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp ./test1.py newpy3.6:/home/test1.py


# 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
  docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
    Gateway
     "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
 c9bcb894a8ac

          
   docker inspect --format='{{.State.Status}}'  c9bcb894a8ac      # running
	docker inspect --format='{{.NetworkSettings.IPAddress}}' c9bcb894a8ac   # 172.17.0.4

          
    # 在多个容器之间是可以ping通的
    # centos:172.17.0.3
    # mysql:172.17.0.2

    
# 删除容器（删除已停止的容器）
	docker rm 容器id  
    docker rm `docker ps -a -q`
    
    
    
 # 无状态的服务
	-myslq reids
    -uwsgi+django

6 应用部署

6.1 mysql部署

# 先创建好目录和文件
# 1 创建相关目录
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 -id -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 3333:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

# 插入数据后，停止并删除该容器
docker stop f81eeed0632

docker rm f81eeed0632


# 再启动一个容器，并做同样的映射，这样原来的数据，就可以在新的容器上的mysql服务中显示了

docker run -id -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 3332:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7


# 这样数据依然在

# 关闭容器，删除容器，myslq的容器没了，但是数据在宿主机上放着

# 再运行起一个容器，做好目录映射，数据都回来了
image-20230413154240288

6.2 redis

# 拉取redis镜像
docker pull redis

# 创建宿主机中存放redis 数据的文件
mkdir /root/data

vim /root/redis.conf

bind 0.0.0.0
daemonize NO
protected-mode no
requirepass 123456


# 运行
docker run -id -p 6380:6379 --name docker_redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis redis-server /etc/redis/redis.conf
image-20230413162710732

6.3 nginx

# 拉取nginx镜像
docker pull nginx

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

修改 宿主机中的 index.html页面，就可以在 81端口访问到这个页面

image-20230413164157531

7 迁移与备份

# 容器保存为镜像
	-运行一个centos容器
    docker run -id --name centos_vim centos:7
    -在容器中装vim
    docker exec -it a6e240 /bin/bash
	yum install vim -y
    
    -把容器做成镜像（centos+vim）
    docker commit centos_vim centos_vim_image

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

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

8 Dockerfile

8.1 什么是Dockerfile

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

镜像从哪里来的？

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

8.2 Dockerfile的命令

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

8.3 构建一个带vim的centos镜像

vim Dockerfile

FROM py3.6:v3.6
MAINTAINER duo
ENV SONG_NAME ALL_MINE
RUN mkdir /duoduo
RUN touch /duoduo/test.py
RUN echo 'print("duoduo")' > /duoduo/test.py
WORKDIR /duoduo


# 基于dockerfile构建镜像
docker build -t='py3.8_test' .

# 基于这个镜像运行容器
docker run -id --name xxx py3.8_test
# 进入到容器
docker exec -it xxx /bin/bash
# 验证vim，和文件夹，文件是否存在

image-20230413171807199

8.4 常用和不常用命令

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”]。

9 案例：Dockerfile 构建Django项目

模拟公司中使用Docker开发的工作流程

① 第一步：有一个项目，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"]

③ 第三步：把代码提交到git

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

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

⑤ 第五步：进入拉下来的项目路径，构建镜像 名为books

docker build -t='books' .

⑥ 第六步：运行容器

docker run -id --name=books -v /root/books:/soft -p 9990:9990 books:latest

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

image-20230414184923904

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

开发人员，在git上提交了新的代码

⑨ 第九步：运维人员pull代码，重启容器，用户就可以看到最新的了

在上线项目上直接 从pull中拉取最新的代码，在重新启动容器，由于做好了目录的映射，所以直接就可以更新

10 Docker私有仓库

docker官方又提供的远程仓库，我们可以把自己的镜像传上去，之后需要使用直接拉去即可，但是需要收费

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

10.1 镜像传到官方仓库

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

10.2 镜像分层

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

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

# 补充：Dcokerfile写命令，建议多条命令合为一条
 RUN python -m pip install --upgrade pip &&\
    python -m pip install --upgrade setuptools &&\
    pip install -r requirements.txt
image-20230414190349009

10.3 私有仓库搭建

（1）harbor

Harbor Registry（又称 Harbor 云原生制品仓库或 Harbor 镜像仓库）由 VMware 公司中国研发中心云原生实验室原创，并于 2016 年 3 月开源。Harbor 在 Docker Distribution的基础上增加了企业用户必需的权限控制、镜像签名、安全漏洞扫描和远程复制等重要功能，还提供了图形管理界面及面向国内用户的中文支持，开源后迅速在中国开发者和用户社区流行，成为中国云原生用户的主流容器镜像仓库。

更多参考：

https://blog.csdn.net/Gf19991225/article/details/121982824

（2） registry：用docker搭建私有仓库

搭建步骤：

	  -第一步：拉取镜像 docker pull registry
    -第二步：运行容器：docker run -di --name=registry -p 5000:5000 registry
    -第三步：打开浏览器 输入地址http://101.132.188.28: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

image-20230414191205311

① 第一步：拉取镜像

 docker pull registry

② 第二步：根据镜像registry，运行容器

ocker run -di --name=registry -p 5000:5000 registry

③ 第三步：打开浏览器

输入地址http://本地ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空

image-20230414191532612

④ 第四步：修改docker的配置文件 daemon.json，添加如下配置

{     
    "insecure-registries":["ip地址:端口"]
}

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

systemctl restart docker
docker start registry

⑥ 第六步：把某个镜像tag成私有仓库的镜像

docker tag 镜像id/镜像名字 公网ip:5000/redis:v1

docker tag 7614ae9453d1 101.132.188.28:5000/redis:v1

⑦ 第七步：提交到私有仓库

docker push 101.132.188.28:5000/redis:v1

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

docker pull 101.132.188.28:5000/redis:v1

查看端口号：

netstat -nltp|grep 端口号

11 docker-compose

11.1 简介

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

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

Compose中定义和启动的每一个容器都相当于一个服务(service)

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

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

多容器编排：

  • docker swarm：docker官方自己的，公司里用的不多

  • k8s：多机容器编排工具，谷歌公司写的go语言写了k8s

11.2 使用步骤

① 安装docker-compose

# 安装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  # 进入到容器内

12 dockercompose部署flask+redis项目

12.1 新建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)

12.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" ]

12.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

12.4 docker-compose启动

# 如果redis服务的名字叫redis，我在web服务中(容器中)，根据redis名字就能拿到容器
	ping redis
    
    # 进入到了web，ping redis
    # 安装ping命令，
    apt-get update
    apt-get install inetutils-ping
    ping redis
  • 一键部署
# 一键部署：redis，和flask ，每个都在一个容器中
docker-compose up

13 dockercompose一键部署路飞项目

# 一台服务器：
	-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 -d
    -访问宿主机的 80 端口

标签：容器,compose,centos,虚拟化,redis,镜像,Docker,docker
From： https://www.cnblogs.com/DuoDuosg/p/17372003.html

相关文章

  • docker mysql 容器自动停止 -- docker update
    原因：mysql容器占用资源过高被系统杀死解决方法dockerupdate-m500M--memory-reservation500M--memory-swap1000M容器id/容器名说明-m限制内存最大值--memory-reservation是弹性控制内存大小，防止损失性能，建议要开。当宿主机资源充足时，允许容器尽量多地使......
  • k8s 编写pod yaml 文件 启动pod 查看pod详细信息 查看pod日志 连接pod容器 删除po
    #1创建podyaml文件#使用帮助命令 [root@master01pod]#kubectlexplainpod.spec[root@master01pod]#catpod-self.yamlapiVersion:v1kind:Podmetadata:name:pod-selfnamespace:defaultlabels:app:my-selfdev:prospec:restartPolic......
  • [Docker] Add a SQLite Console Shortcut with the Dockerfile
    Withalong-runningnodeserverandadatabase,sometimesit'susefultosshintothevirtualmachinetoexplorethefilesystem,andlookatthedatabase.InDockerfile,add:RUNecho'#!/bin/sh\nset-xe\nsqlite3\$DATABASE_URL'>/u......
  • Docker可视化管理工具对比(DockerUI、Shipyard、Rancher、Portainer)
    1、前言   谈及docker，避免不了需要熟练的记住好多命令及其用法，对于熟悉shell、技术开发人员而言，还是可以接受的，熟练之后，命令行毕竟是很方便的，便于操作及脚本化。但对于命令行过敏、非技术人员，进行docker部署、管理是比较头疼的，学习成本是很高的。    而市面上的可视化......
  • Docker可视化管理工具Portainer
    1、portainer介绍    Portainer是Docker的图形化管理工具，提供状态显示面板、应用模板快速部署、容器镜像网络数据卷的基本操作（包括上传下载镜像，创建容器等操作）、事件日志显示、容器控制台操作、Swarm集群和服务等集中管理和操作、登录用户管理和控制等功能。 Portainer展示......
  • docker 部署 canal
    1、docker部署canal/canal-server:v1.1.61.1、下载镜像dockerpullcanal/canal-server:v1.1.61.2、挂载properties配置文件1.2.1、先进行第一次运行，拷贝properties配置文件dockerrun-p11111:11111--namecanal-dcanal/canal-server:v1.1.61.2.2、拷贝运行后的容器......
  • 01. k8s1.15.1高可用版本(docker引擎，Centos7.9)
    1.软件版本首先要把centos7系统的内核升级最好4.4以上(默认3.10的内核,运行大规模docker的时候会有bug)软件/系统版本备注Centos7.9最小安装版k8s1.15.1flannel0.11etcd3.3.102.角色分配k8s角色主机名节点IP备注master1+etcd1mas......
  • Centos7中安装Docker
    在CentOS7上安装Docker的步骤如下：更新系统使用以下命令更新系统软件包：sudoyumupdate安装Docker依赖使用以下命令安装Docker依赖包：sudoyuminstall-yyum-utilsdevice-mapper-persistent-datalvm2添加Docker软件仓库使用以下命令添加Docker软件仓库：sudoyu......
  • docker的nginx的nginx.conf文件复制到主机
    要将Docker容器中的Nginx配置文件复制到主机上，可以使用dockercp命令完成。以下是具体的步骤：执行以下命令，在运行中的Nginx容器中复制/etc/nginx/nginx.conf文件到主机的某个目录中（例如，当前目录中的nginx.conf文件）：dockercp<nginx-container-name>:/etc/nginx/ng......
  • 查看Nginx容器中的配置文件
    要查看Nginx容器中的配置文件，可以按照以下步骤进行：进入正在运行的Nginx容器：dockerexec-it<nginx-container-name>bash其中，<nginx-container-name>是Nginx容器的名称。在容器内部，浏览到/etc/nginx/目录，这是Nginx配置文件所在的目录。使用以下命令可以查看该目录中的所......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99