一、DevOps之Docker详细使用教程_怎么进入devops的容器

Docker

01-主要内容

初识 Docker

Docker 命令

Docker 容器数据卷

Dockerfile

Docker 应用部署

Docker 服务编排

Docker 私有仓库

Docker相关概念

02-初识docker-docker概述

分析：

​ 把环境一起给打包起来

​ 操作系统，运行环境（软件，服务），项目

Docker 概念
• Docker 是一个开源的应用容器引擎
• 诞生于 2013 年初，基于 Go 语言实现， dotCloud 公司出品（后改名为Docker Inc）
• Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux 机器上。
• 容器是完全使用沙箱机制，相互隔离
• 容器性能开销极低。
• Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版）

03-初识docker-安装docker

基于centos7版本进行在线安装

# 1、yum 包更新到最新 
yum update
# 2、安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的 
yum install -y yum-utils device-mapper-persistent-data lvm2
# 3、 设置yum源
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 4、 安装docker，出现输入的界面都按 y 
yum install -y docker-ce
# 5、 查看docker版本，验证是否验证成功
docker -v
1
2
3
4
5
6
7
8
9
10

出现下面这个提示表示安装成功

04-初识docker-docker架构

docker的架构

​ 客户端： Clients,就是我们输入docker命令的命令行，用户用来操作docker.

​ docker主机： Hosts,安装了docker服务的计算机

​ 仓库： Registries,存放镜像的仓库所在的服务器（中央仓库，私服）

•**镜像（Image）：**Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。

•容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

Docker镜像和容器的区别

•仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

05-初识docker-配置镜像加速器

使用阿里云的镜像加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://iaiwnlq8.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8

06-docker命令-服务相关命令（基于CentOS 7）

• 启动docker服务:

  systemctl start docker

• 停止docker服务:

  systemctl stop docker

• 重启docker服务:

  systemctl restart docker

• 查看docker服务状态:

  systemctl status docker

• 设置开机启动docker服务:

  systemctl enable docker

07-docker命令-镜像相关命令

操作docker镜像的命令

docker命令菜鸟教程：

https://www.runoob.com/docker/docker-command-manual.html

分析：

查看镜像: 查看本地所有的镜像

docker images
docker images –q # 查看所有镜像的id
1
2

搜索镜像:从网络中查找需要的镜像

docker search 镜像名称
1

拉取镜像:从Docker仓库下载镜像到本地，镜像名称格式为 名称:版本号，如果版本号不指定则是最新的版本 latest。

如果不知道镜像版本，可以去docker hub 搜索对应镜像查看。

查看镜像的信息：

https://hub.docker.com/

docker pull 镜像名称:镜像版本
1

删除镜像: 删除本地镜像

docker rmi 镜像id # 删除指定本地镜像
docker rmi `docker images -q`  # 删除所有本地镜像
1
2

08-docker命令-容器相关命令

•查看容器

•创建容器

•进入容器

•启动容器

•停止容器

•删除容器

•查看容器信息

8.1 查看容器

# 查看容器
docker ps -a
1
2

8.2 创建容器&进入容器

# 创建并启动交互式容器
docker run -it --name=mycentos7 centos:7 /bin/bash


# 创建并启动守护式容器
docker run -di --name=mycentos2 centos:7

# 启动容器后再进入容器
docker exec -it mycentos2 /bin/bash

#在容器内部退出容器（看命令行前面的主机名）
exit
1
2
3
4
5
6
7
8
9
10
11
12

注意：

​ -it 创建docker交互式容器（启动容器之后会直接进入容器的命令行终端，如果退出则容器停止运行）

​ -di 创建并启动docker容器，可以在后台运行；守护式容器在启动之后会一直在后台运行，即使进入容器之后执行exit命令也不会停止容器；适用于需要长期运行容器的情况.

09-docker命令-容器相关命令2

9.1 启动容器

# c1是容器的name,或者ID
docker start c1     
1
2

9.2 停止容器

# c1是容器的name,或者ID
docker stop c1     
1
2

9.3 删除容器

#只能删除停止状态的容器
docker rm c1     # c1是容器的name,或者ID
#删除所有容器
docker rm `docker ps -a -q`
1
2
3
4

9.4 查看容器信息

docker inspect c1
1

最经常查看的容器的IP地址： NetWorkSettings.IPAddress

10-docker容器数据卷-数据卷概念及作用

分析：

什么是数据卷？

•数据卷是宿主机中的一个目录或文件

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

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

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

数据卷的作用

•容器数据持久化

•外部机器和容器间接通信

•容器之间数据交换

11-docker容器数据卷-配置数据卷

创建启动容器时，使用 –v 参数 设置数据卷

# 所有的命令 ： 前面都是宿主机，后面是容器
docker run ... –v 宿主机目录(文件):容器内目录(文件) ... 



#创建容器挂载数据卷
docker run -it --name=c2 -v ~/data:/root/data_con centos:7

#在容器中，进入文件夹
cd ~
#查看挂载的目录,会看到文件夹data_con
ll

#克隆crt窗口，查看主机的/root/data
cd ~

#在主机中创建文件
touch king.txt
#写一个带内容的文件
echo itcast > a.txt


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注意：

1. 目录必须是绝对路径

   2. 如果目录不存在，会自动创建

2. 可以挂载多个数据卷

12-docker容器数据卷-配置数据卷2

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


1
2
3
4

注意： 多个容器挂载相同的数据卷，就可以做到容器之间共享数据。

13-docker容器数据卷-数据卷容器

多容器进行数据交换

1. 多个容器挂载同一个数据卷

2. 数据卷容器

配置数据卷容器

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

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

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

docker run –it --name=c1 --volumes-from c3 centos:7 /bin/bash

docker run –it --name=c2 --volumes-from c3 centos:7 /bin/bash  
1
2
3

14-docker应用部署-部署mysql

分析：

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

•外部机器和宿主机可以直接通信

•宿主机和容器可以直接通信

•当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的该端口，从而间接访问容器的服务。

•这种操作称为：端口映射

在容器中安装MySQL

1.搜索mysql镜像

docker search mysql

2.拉取mysql镜像

docker pull mysql:5.7

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

# 在/root目录下创建mysql目录用于存储mysql数据信息
 mkdir ~/mysql
 
 cd ~/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
1
2
3
4
5
6
7
8
9
10
11
12

总结：

•参数说明：

•-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.进入容器，操作mysql

docker exec -it c_mysql /bin/bash

5.使用外部机器连接容器中的mysql使用主机的ip地址和映射的端口进行连接。

15-docker应用部署-部署tomcat

1. 搜索tomcat镜像

docker search tomcat
1

2. 拉取tomcat镜像

docker pull tomcat
1

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

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

docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat 
1
2
3
4

• 参数说明：

  • **-p 8080:8080：**将容器的8080端口映射到主机的8080端口

    **-v $PWD:/usr/local/tomcat/webapps：**将主机中当前目录挂载到容器的webapps

4. 使用外部机器访问tomcat

16-docker应用部署-部署nginx

1. 搜索nginx镜像

docker search nginx
1

2. 拉取nginx镜像

docker pull nginx
1

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

# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf
1
2
3
4
5
6
7

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;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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
2
3
4
5
6

编写首页

#在当前主机目录下：
cd html
vim index.html

i  # 进入编辑模式
<h1>hello nginx docker <h1>

1
2
3
4
5
6
7

• 参数说明：
  • -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. 使用外部机器访问nginx

17-docker应用部署-部署redis

1. 搜索redis镜像

docker search redis
1

2. 拉取redis镜像

docker pull redis:5.0
1

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

docker run -id --name=c_redis -p 6379:6379 redis:5.0
1

4. 使用外部机器连接redis

./redis-cli.exe -h 192.168.149.135 -p 6379
1

18-dockerfile-镜像原理

dockerfile是用来创建docker镜像的文件。

镜像原理：

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

• bootfs：包含bootloader（引导加载程序）和 kernel（内核）

• rootfs： root文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin，/etc等标准目录和文件

•不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等

docker的rootfs复用了操作系统的rootfs，所以和宿主机的操作系统相关。

1.Docker 镜像本质是什么？

•是一个分层文件系统

2.Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个个G？

•Centos的iso镜像文件包含bootfs和rootfs，而docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层

3.Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？

•由于docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小500多MB

19-dockerfile-容器转为镜像

1.容器转为镜像

docker commit 容器id 镜像名称:版本号
docker save -o 压缩文件名称 镜像名称:版本号
docker load –i 压缩文件名称

1
2
3
4

注意：容器中通过挂载数据卷中的数据，不会打包到镜像中。

2.dockerfile

20-dockerfile-dockerfile概述及关键字

Dockerfile 是一个文本文件

•包含了一条条的指令

•每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像

•对于开发人员：可以为开发团队提供一个完全一致的开发环境

•对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了

•对于运维人员：在部署时，可以实现应用的无缝移植

Dochub网址：https://hub.docker.com

关键字介绍：查看文档目录中的《dockerfile.md》

21-dockerfile-案例-自定义centos

需求：

自定义centos7镜像。要求：

1. 默认登录路径为 /usr

2. 可以使用vim

实现步骤：

①定义父镜像：FROM centos:7

②定义作者信息：MAINTAINER kingking@163.com

③执行安装vim命令： RUN yum install -y vim

④定义默认的工作目录：WORKDIR /usr

⑤定义容器启动执行的命令：CMD /bin/bash

⑥通过dockerfile构建镜像：docker bulid –f dockerfile文件路径 –t 镜像名称:版本

centos_dockerfile

FROM centos:7
MAINTAINER king<king@163.com>

RUN yum install -y vim
WORKDIR /usr

cmd /bin/bash
1
2
3
4
5
6
7

运行：

docker build -f ./centos_dockerfile -t king_centos:1 .
1

22-dockerfile-案例-部署springboot项目

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

实现步骤：

①定义父镜像：FROM java:8

②定义作者信息：MAINTAINER kingking@163.com

③将jar包添加到容器： ADD springboot.jar app.jar

④定义容器启动执行的命令：CMD java–jar app.jar

⑤通过dockerfile构建镜像：docker bulid –f dockerfile文件路径 –t 镜像名称:版本

springboot_dockerfile

FROM java:8
MAINTAINER king<king@163.com>

ADD springboot-hello-0.0.1-SNAPSHOT.jar app.jar
CMD java -jar app.jar

1
2
3
4
5
6

运行：

docker build -f ./springboot_dockerfile -t king_app:1 .
1

23-docker compose-概述

服务编排

按照一定的业务规则批量管理容器

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

•要从Dockerfile build image 或者去dockerhub拉取image

•要创建多个container

•要管理这些container（启动停止删除）

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

1.利用 Dockerfile 定义运行环境镜像

2.使用 docker-compose.yml 定义组成应用的各服务

3.运行 docker-compose up 启动应用

24-docker compose-安装使用

1.安装Docker Compose

# Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version
1
2
3
4
5
6

2.卸载Docker Compose

# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose
1
2

3.使用docker compose编排nginx+springboot项目

1. 创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose
1
2

2. 编写 docker-compose.yml 文件

version: '3'
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 创建./nginx/conf.d目录

mkdir -p ./nginx/conf.d
1

4. 在./nginx/conf.d目录下 编写king.conf文件

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}
1
2
3
4
5
6
7
8
9

5. 在~/docker-compose 目录下 使用docker-compose 启动容器

docker-compose up
1

6. 测试访问

http://192.168.149.135/hello
1

25-docker私有仓库-搭建

一、私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

1
2
3
4
5
6
7
8
9
10
11
12
13

26-docker私有仓库-上传镜像

二、将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像     
docker push 私有仓库服务器IP:5000/centos:7

1
2
3
4
5
6

27-docker私有仓库-拉取镜像

三、 从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7
1
2

28-docker和虚拟机比较

docker容器虚拟化 与 传统虚拟机比较

相同：

•容器和虚拟机具有相似的资源隔离和分配优势
不同：

•容器虚拟化的是操作系统，虚拟机虚拟化的是硬件。

•传统虚拟机可以运行不同的操作系统，容器只能运行同一类型操作系统