Docker入门

学习链接：黑马程序员Docker容器化技术，从零学会Docker教程

安装Docker

Ubuntu18.04安装Docker

# 1.更新包列表
sudo apt-get update
# 2.安装 Docker 的依赖包
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
# 3.添加 Docker GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
# 4.添加 Docker APT 仓库
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
# 5.再次更新包列表
sudo apt-get update
# 6.安装 Docker-ce
sudo apt-get install -y docker-ce
# 7.sudo docker run hello-world
sudo docker run hello-world

CentOS7安装Docker

# 1.更新包列表
sudo yum update
# 2.安装 Docker 的依赖包
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# 3.添加 Docker 仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 4.安装 Docker-ce
sudo yum install docker-ce
# 5.启动 Docker
sudo systemctl start docker
# 6.开机自启 Docker
sudo systemctl enable docker
# 7.sudo docker run hello-world
sudo docker run hello-world

Docker架构

1. 镜像(Docker image)：相当于一个root文件系统。
2. 容器(Docker container)：运行中的Docker镜像的实例。
3. 仓库(Docker repository)：存储Docker镜像的地方。
4. 守护进程(Docker daemon)：Docker引擎的核心组件，运行在主机上，并负责管理Docker容器和镜像
5. 客户端(Docker client)：与Docker守护进程通信的命令行工具或API，可以用来启动、停止和管理Docker容器和镜像

Docker进程相关命令

1. 启动docker服务

systemctl start docker

2. 停止docker服务

systemctl stop docker

3. 查看docker服务状态

systemctl status docker

4. 重启docker服务

systemctl restart docker

5. 设置开机启动docker服务

systemctl enable docker

Docker镜像相关命令

1. 查看镜像：查看本地所有镜像

docker images
docker images -q  #查看所有镜像id

2. 搜索镜像：从网路中查找需要的镜像

docker search redis

3. 拉取镜像：从Docker仓库下载镜像到本地。镜像名称格式为：镜像:版本号。若版本号不指定则为最新版本。不知道对应版本，可去docker hub搜索对应镜像查看。

docker pull redis

4. 删除镜像

docker rmi image-ID

5. 删除所有镜像

docker rmi `docker images -q`

Docker容器相关命令

[root@iZ0jl0hf3bpk2xk5tzypy0Z ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
mysql        5.7       3f3447deacaa   11 days ago     455MB
redis        6.2.5     5d89766432d0   18 months ago   105MB
centos       7         eeb6ee3f44bd   19 months ago   204MB
nginx        1.18      c2c45d506085   2 years ago     133MB

1. 查看容器

docker ps    #查看正在运行容器
docker ps -a #查看历史容器

[root@iZ0jl0hf3bpk2xk5tzypy0Z ~]# docker ps -a
CONTAINER ID   IMAGE      COMMAND       CREATED         STATUS                     PORTS     NAMES
0d3d83e07b8d   centos:7   "/bin/bash"   5 minutes ago   Exited (0) 4 minutes ago             cl

2. 创建容器

docker run -it --name=cl centos:7 /bin/bash  #运行后直接进入容器，exit退出后即停止容器
docker run -id --name=c2 centos:7 #后台运行，需要手动进入容器中

• -i：保持容器运行。通常与-t同时使用。加入it这两个参数后，容器创建后自动进入容器，退出后自动关闭容器。
• -t：为容器重新分配一个伪输入终端，通常与-i同时使用。
• -d：以守护模式运行容器。创建一个容器在后台运行，需要使用docker exec进入容器。退出后不会关闭容器。
• -it创建的容器一般称为交互式容器，-id创建的容器一般称为守护式容器。
• --name：为创建的容器命名。

3. 进入容器

docker exec -it c2 /bin/bash

4. 启动容器

docker start 容器名

5. 停止容器

docker stop 容器名

6. 删除容器

docker rm 容器名
docker rm `docker ps -aq`  #删除所有容器

7. 查看容器信息

docker inspect c2

Docker容器数据卷

• Docker容器删除后，容器中得数据会随之销毁
• Docker容器可以与外部机器交换文件吗？ $\to$ 不能
• 容器之间怎么数据交互？

数据卷：宿主机中的一个目录或文件。

当容器目录与数据卷绑定后，对方的修改会立即同步。

一个数据卷可以被多个容器同时挂载。

一个容器可以挂载多个数据卷。

数据卷的作用：容器数据持久化；外部机器与容器间接通信；容器之间数据交换。

• 如何配置数据卷？

# 创建启动容器时，使用-v参数 设置数据卷
docker run ... -v 宿主机目录（文件）:容器内目录（文件）

注意：

1. 目录必须是绝对路径
2. 若目录不存在，会自动创建
3. 可挂载多个数据卷

配置数据卷的例子：

docker run -it --name=c1 -v /root/data:/root/data_container centos:7 /bin/bash

宿主机中的文件：

[root@iZ0jl0hf3bpk2xk5tzypy0Z ~]# ll
total 8
drwxr-xr-x 2 root root 4096 Apr 13 09:24 data
drwxr-xr-x 9 root root 4096 Mar 30 21:47 tomcat-8.5.87

容器中文件：

[root@a14519833eea ~]# ll
total 8
-rw------- 1 root root 3416 Nov 13  2020 anaconda-ks.cfg
drwxr-xr-x 2 root root 4096 Apr 13 01:24 data_container

于是宿主机中的文件与容器中文件保持同步。即便容器删除也不会有影响。

一个容器可以挂载多个数据卷，如：

[root@iZ0jl0hf3bpk2xk5tzypy0Z data]# docker run -it --name=c2 \
> -v /root/data2:/root/data2 \
> -v /root/data3:/root/data3 \
> centos:7

一个数据卷可被多个容器挂载

docker run -it --name=c3 -v /root/data:/root/data centos:7
docker run -it --name=c4 -v /root/data:/root/data centos:7

• 数据卷容器

如何多容器进行数据交互？ $\to$ 1.多个容器挂载同一个数据卷；2.数据卷容器

1. 创建启动c3数据卷容器，使用-v参数 设置数据卷

docker run -it --name=c3 -v /volume centos:7 /bin/bash

2. 创建启动c1 c2容器，使用 --volumes-from 参数 设置数据卷

docker run -it --name=c1 -v /volume-from c3 centos:7 /bin/bash
docker run -it --name=c2 -v /volume-from c3 centos:7 /bin/bash

Docker应用部署

MySQL部署

• 容器内的网络服务和外部机器不能直接通信
• 外部机器和宿主机可以直接通信
• 宿主机和容器可以直接通信

解决办法：将容器中提供服务的端口映射到宿主机的端口上，外部机器访问宿主机的端口，间接访问容器中的服务。这种操作称为：端口映射。

在Docker容器中部署MySQL，并通过外部MySQL客户端操作MySQL Server。

1. 搜索mysql镜像

docker search mysql

2. 拉取mysql镜像

docker pull mysql:5.7

3. 创建容器，设置端口映射、目录映射

# 在/root目录下创建mysql目录用于存储mysql数据信息
mkdir /root/mysql
cd /root/mysql

docker run -id \
-p 3307:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.7

参数说明：

• -p 3307:3306：将容器的3306端口映射到宿主机的3307端口。
• -v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
• -v $PWD/logs:/logs：将主机当前目录下的logs目录挂载到容器的 /logs。日志目录
• -v $PWD/data:/var/lib/mysql：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql。数据目录
• -e MYSQL_ROOT_PASSWORD=123456：初始化root用户的密码。

4. 进入容器

docker exec -it c_mysql /bin/bash

5. 操作容器中的mysql

mysql -uroot -p123456 #登录
create database db1; #创建一个数据库db1
show databases; #显示所有库

6. SQLyog连接
   

注意：云服务器上要配置端口3307的安全组

tomact部署

需求：在Docker容器中部署Tomcat，并通过外部机器访问Tomcat部署的项目。

1. 搜索tomcat镜像

docker search tomcat

2. 拉取tomcat镜像

docker pull tomcat:8.5

3. 创建容器，设置端口映射、目录映射

# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir /root/tomcat
cd /root/tomcat

docker run -id --name=c_tomcat \
-p 8081:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat:8.5

参数说明：

• -p 8081:8080：将容器的8080端口映射到主机的8081端口
• -v $PWD:/usr/local/tomcat/webapps：将主机中当前目录挂载到容器的webapps

4. 部署项目

[root@iZ0jl0hf3bpk2xk5tzypy0Z tomcat]# mkdir test
[root@iZ0jl0hf3bpk2xk5tzypy0Z tomcat]# cd test
[root@iZ0jl0hf3bpk2xk5tzypy0Z test]# vim index.html
[root@iZ0jl0hf3bpk2xk5tzypy0Z test]# cat index.html


<h1> hello tomcat docker </h1>

5. 测试访问

注意：云服务器中开启8081端口的安全组

在网址中输入：

http://x.x.x.x:8081/test/index.html

nginx部署

需求：在Docker容器中部署Nginx，并通过外部机器访问Nginx。

1. 搜索Nginx镜像

docker search nginx

2. 拉取Nginx镜像

docker pull nginx:1.18

3. 创建容器

# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf 
cd conf
# 在~/nginx/conf/下创建nginx.conf文件，粘贴下面内容
vim nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

退到nginx目录下

cd ..

docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx:1.18

参数说明：

• -p 80:80：将容器的 80 端口映射到宿主机的 80 端口。
• -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
• -v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录

4. 部署访问

[root@sjn ~]# cd nginx
[root@sjn nginx]# cd html
[root@sjn html]# cat index.html



<h1> hello nginx docker </h1>

注意：云服务器中开启80端口的安全组

在网址栏中输入ip地址：

x.x.x.x

redis部署

1. 搜索Redis镜像

docker search redis

2. 拉取Redis镜像

docker pull redis:6.2.5

3. 创建容器

docker run -id --name=c_redis -p 6379:6379 redis:6.2.5

4. 测试访问

redis-cli.exe -h x.x.x.x -p 6379

alist部署

1. 拉取alist镜像

docker pull xhofe/alist

2. 创建容器

# 在/root目录下创建alist目录用于存储alist数据信息
mkdir /root/alist
cd /root/alist

docker run -d --restart=always -v $PWD/data:/opt/alist/data -p 5244:5244 -e PUID=0 -e PGID=0 -e UMASK=022 --name="alist" xhofe/alist:latest

3. 进入容器并查看登录密码

[root@sjn ~]# docker exec -it alist /bin/bash
5891862e4956:/opt/alist# ./alist admin
INFO[2023-04-24 05:58:31] reading config file: data/config.json        
INFO[2023-04-24 05:58:31] load config from env with prefix: ALIST_     
INFO[2023-04-24 05:58:31] init logrus...                               
INFO[2023-04-24 05:58:31] admin user's info: 
username: admin
password: xxxxxxxx

4. 网址登录

yourIP:5244

5. 域名解析与代理

参考教程：

• 域名解析【cloudflare+namesilo】
• Cloudflare域名解析接入，免费使用DNS和CDN

namesilo域名购买：https://www.namesilo.com/

cloudflare域名托管与解析：https://dash.cloudflare.com/login

6. 用nginx反向代理

在nginx.conf文件中加入如下代码，nginx监听80端口，并将80端口转发至5244端口。如此一来，浏览器中只需要输入域名便可直接访问

server {
     listen 80;
     charset utf-8;
     server_name example.com;

     location / {
          proxy_pass http://yourIP:5244;
          proxy_redirect default;
     }
}

6. 用https访问

在这里插入代码片

Dockerfile

思考：

1. Docker镜像本质是什么 $\to$ 一个分层文件系统
2. Docker中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个G $\to$ 答：centos的iso镜像文件包含bootfs和rootfs，而docker中的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层
3. Docker中一个tomcat镜像为什么只有500MB，而一个tomcat安装包只有70多MB $\to$ 答：Docker中镜像是分层的，tomcat虽然只有70多MB，但它依赖于父镜像和基础镜像，所以整个对外暴露的tomcat镜像为500多MB。

Linux文件系统由bootfs和rootfs两部分组成

• bootfs：包含bootloader（引导加载程序）和kernel（内核）
• rootfs：root文件系统，包含典型的Linux系统中的/dev，/proc，/bin，/etc等标准目录和文件
• 不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos

Docker镜像原理

• Docker镜像是由特殊的文件系统叠加而成
• 最底端是bootfs，并使用宿主机的bootfs
• 第二层是rootfs，称为base image
• 然后再往上叠加其他的镜像文件
• 统一文件系统技术将不同的层整合成一个文件系统，为这些层提供一个统一视角，隐藏多层的存在。在用户看来，只存在一个文件系统
• 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像。
• 当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器。

镜像制作

1. 容器转为镜像

将容器转成新的镜像

docker commit 容器id 镜像名称:版本号

将镜像转成压缩文件

docker save -o 压缩文件名称 镜像名称:版本号

将压缩文件转成新的镜像

docker load -i 压缩文件名称

注意：新镜像中包含容器中非目录挂载的文件，之前挂载的文件则消失不见。

2. Dockerfile

• Dockerfile是一个文本文件
• 包含了一条条的指令
• 每条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• 对于开发人员：可以为开发团队提供一个完全一致的开发环境
• 对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作
• 对于运维人员：在部署时，可实现应用的无缝移植

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于哪个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,”param2”]
CMD	容器启动命令	提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,”param2”]

Docker案例 —— 自定义CentOS

需求：自定义CentOS7镜像，要求：

1. 默认登录路径为/usr
2. 可以使用vim

实现步骤：

1. 定义父镜像：FROM centos:7
2. 定义作者信息：MAINTAINER itheima itheima@itcast.cn
3. 执行安装vim命令：RUN yum install -y vim
4. 定义默认的工作目录：WORKDIR /usr
5. 定义容器启动执行的命令：CMD /bin/bash

[root@sjn ~]# mkdir docker-files
[root@sjn ~]# cd docker-files/
[root@sjn docker-files]# vim centos_dockerfile

dockerfile文件

FROM centos:7
MAINTAINER itheima <itheima@itcast.cn>

RUN yum install -y vim
WORKDIR /usr

cmd /bin/bash

构建镜像

[root@sjn docker-files]# docker build -f ./centos_dockerfile -t itheima_centos:1 .
[+] Building 26.8s (7/7) FINISHED                                                                             
 => [internal] load .dockerignore                                                                        0.1s
 => => transferring context: 2B                                                                          0.0s
 => [internal] load build definition from centos_dockerfile                                              0.1s
 => => transferring dockerfile: 152B                                                                     0.0s
 => [internal] load metadata for docker.io/library/centos:7                                              0.0s
 => [1/3] FROM docker.io/library/centos:7                                                                0.0s
 => [2/3] RUN yum install -y vim                                                                        22.0s
 => [3/3] WORKDIR /usr                                                                                   0.0s
 => exporting to image                                                                                   4.6s 
 => => exporting layers                                                                                  4.6s 
 => => writing image sha256:72b61db1540f024062c2b1ea7ece0fa343868083cb10f0156a7e7e779d211ac2             0.0s 
 => => naming to docker.io/library/itheima_centos:1 

运行容器

[root@sjn docker-files]# docker run -it --name=c2 itheima_centos:1
[root@5713f727a66d usr]# vim -v

Dockerfile案例——部署springboot项目

需求：定义dockerfile，发布springboot项目

Docker服务编排

服务编排

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般会部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。

• 要从Dockerfile build image或者去dockerhub拉取image
• 要创建多个container
• 要管理这些container

Docker Compose

Docker Compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：

1. 利用Dockerfile定义运行环境镜像
2. 使用docker-compose.yml定义组成应用的各服务
3. 运行docker-compose up启动应用

Docker Compose安装使用

Docker私有仓库

Docker相关概念