按部就班学Docker

docker基本用法

卸载

sudo yum remove docker \
                 docker-client \
                 docker-client-latest \
                 docker-common \
                 docker-latest \
                 docker-latest-logrotate \
                 docker-logrotate \
                 docker-engine

安装

sudo yum install -y yum-utils \
 device-mapper-persistent-data \
 lvm2
 
- 设置稳定的仓库
 
  sudo yum-config-manager \
   --add-repo \
   https://download.docker.com/linux/centos/docker-ce.repo
	
	
 #安装docker
 sudo yum install docker-ce docker-ce-cli containerd.io

镜像加速器

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

查看镜像

docker images

拉取

## 默认会拉取最新的,不过能够指定tags的方式拉取对应的镜像
dokcer pull hello-world(镜像名)

运行

docker run --name hellodocker(别名) hello-world

查看运行状态

docker ps -a

删除

docker rmi -f imageId

docker rmi -f $(docker images)

## 删除容器
docker rmi -f $(docker ps -aq)

tomcat

# -d 后台运行
# --name 指定一个名称
# -p 将默认的8080端口映射为一个新的端口
docker run -d --name mytomcat  -p 8888:8080 tomcat

# 进入到镜像中
# 能够是containerId或者是names
docker exec -it 7940b96bcca6 /bin/bash

mysql

docker run -d --name mysql01 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123 --privileged mysql
### 链接不上的问题排查
docker exec -it mysql /bin/bash
mysql -uroot -p
Enter password: 
mysql> select host,user,plugin,authentication_string from mysql.user;
#host为 % 表示不限制ip localhost表示本机使用 plugin非mysql_native_password 则须要修改密码

mysql> use mysql;
mysql> alter user 'root'@'%' identified with mysql_native_password by '123';
mysql> flush privileges;
mysql> select host,user,plugin,authentication_string from mysql.user;

image怎么制做的

Dockerfile > https://github.com/docker-library 每个image都是根据Dockerfile配置生成的

验证html

> 将官网上的mogodb的Dockerfile放入到咱们的物理主机上,
并执行。
#mogodb-my 起个别名

docker build -t mogodb-my .

根据container生成image

docker commit mycentos vim-centos

经过Dockerfile能够追踪image生成的过程便于排查问题,而container的方式看不到生成的细节,因此不推荐使用,能够适当使用。java

查看docker占用的系统资源

docker top mytomcat
docker stats mytomcat
#限制系统资源的使用(否者会无限制消耗系统的资源)
#--memory 100M 限制内存
#--cpu-shares 10 限制CPU资源占比,例如两个container一个配置10,一个配置20那么他们两个的CPU占比应该后者是前者的两倍 即1:2
docker run -d --name mytomcat02 --memory 100M --cpu-shares 10  -p 8000:8080 tomcat

Spring Boot 项目作成image

FROM openjdk:8
MAINTAINER Bellamy.XIAO
LABEL name="demo" version="1.0" author="Bellamy.XIAO"
COPY demo-0.0.1-SNAPSHOT.jar demo-image.jar
CMD ["java","-jar","demo-image.jar"]

## build
docker build -t spring-boot-demo .
## query
docker images
## run
docker run -d --name demo -p 9000:8080 spring-boot-demo
## log
docker logs containerId

推送到远端仓库

# 生成tag:
docker tag spring-boot-demo  7634xxx/spring-boot:v1.0
# 官方仓库: https://hub.docker.com
登陆: docker login
tag: docker tag ImageId  7634xxx/spring-boot :v1.0
push: docker push   7634xxx/spring-boot:v1.0

# 阿里云仓库
登陆: sudo docker login --username=xxxx  registry.cn-hangzhou.aliyuncs.com

tag:  sudo docker tag ImageId registry.cn-hangzhou.aliyuncs.com/docker-namesapce/docker-repository:version

push : sudo docker push registry.cn-hangzhou.aliyuncs.com/docker-namesapce/docker-repository:version

# 私服[harbor]: https://github.com/goharbor/harbor

系统资源监控平台[weaveworks/scope]

#下载
sudo curl -L git.io/scope -o /usr/local/bin/scope  
#受权
sudo chmod a+x /usr/local/bin/scope
#启动(能够有多个ip)
scope launch 192.0.0.1
#中止
scope stop

Docker核心部分->从网络提及网络

Linux中的网络node

namespace 之间的连通性

namespace 是 Linux 2.6.x 内核版本以后支持的特性，主要用于资源的隔离。有了 namespace，一个 Linux 系统就能够抽象出多个网络子系统，各子系统间都有本身的网络设备，协议栈等，彼此之间互不影响。python

namespace 间通讯mysql
- 基础部分

####### 网卡基本操做 #######
	# 查看网卡信息
	ip link show
	#或者
	ip a
	# 网卡配置目录
	cd /etc/sysconfig/network-scripts/
	#给网卡添加临时ip
	ip addr add 192.168.xxx.xxx/24 dev eth0
	#删除ip
	ip addr delete 192.168.xxx.xxx/24 dev eth0
	-------------------------------------------
	####### 将网卡进行隔离 ######
	# 建立 network namespace
	ip netns add ns1
	#查看
	ip netns list
	# 查看当前namespace的网卡信息
	ip netns exec ns1 ip a
	# 启动网卡
	ip netns exec ns1 ifup  lo
	---------------------------------------------

不得不说的veth pair技术(virtual Ethernet Pair)

eth-pair 就是一对的虚拟设备接口，和 tap/tun 设备不一样的是，它都是成对出现的。一端连着协议栈，一端彼此相连着。正由于有这个特性，它经常充当着一个桥梁，链接着各类虚拟网络设备，典型的例子像“两个 namespace 之间的链接”，“Bridge、OVS 之间的链接”，“Docker 容器之间的链接” 等等，以此构建出很是复杂的虚拟网络结构。linux

# 经过如下方式发现隔离的两个namespace间能够通讯了
	ip link add veth-ns1 type veth peer name veth-ns2
	#绑定network namespace
	ip link set veth-ns1 netns ns1
	# 给网卡添加ip
	ip netns exec ns1 ip addr add 192.xxx.xxx.10/24 dev veth-ns1
	# 启动网卡
	ip netns exec ns1 ip link set veth-ns1 up
	# ns2同理可得，略
	# ns1 ping ns2
	ip netns exec ns1 ping 192.168.xxx.xxx
	----------------------------------------------------

经过如上结论来看docker是否相似

启动2个docker容器(验证容器与容器之间为何能够相互通讯)git

docker run -d tomcat01 -p 8001:8080 tomcat
	docker run -d tomcat02 -p 8002:8080 tomcat
	# 经过上述方式查看物理主机信息
	#内容以下
	8: veth131fbae@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default  
	inet6 aaaa::aaaa:aaaa:aaaa:aaaa/64 scope link 
valid_lft forever preferred_lft forever

10: veth61cf0b5@if9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
inet6 aaaa::aaaa:aaaa:aaa:aaa/64 scope link 
valid_lft forever preferred_lft forever

经过上述信息咱们能够发现，（veth131fbae@if7和veth61cf0b5@if9），@if7和@f9，经过数字发现7和9，中间像是跳过了一个8github

进入到容器一探究竟web

# 分别进入到docker 容器中,获得以下内容
	7: eth0@if8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
inet 172.xxx.xxx.2/16 brd 172.xxx.255.255 scope global eth0
  valid_lft forever preferred_lft forever

	  9: eth0@if10: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 172.xxx.xxx.3/16 brd 172.xxx.255.255 scope global eth0
  valid_lft forever preferred_lft forever

eth0@if8 和eth0@if10，由此咱们发现了一些端倪，能够看的出docker中的container和物理主机中确实是成对出现了这样的网卡信息。 veth131fbae@if7 <--> eth0@if8 、veth61cf0b5@if9 <---> eth0@if10，那么也意味着docker中的网络是按照namespace相似的思想作到资源隔离的redis

Docker 中的网络模式

#经过以下命令查看
docker network ls
NETWORK ID          NAME                DRIVER               SCOPE
15ea9d89d616        bridge              bridge               local
1c62b0fd4212        host                host                 local
375f1ab17a8b        none                null                 local

bridge

默认使用的方式 2.host
访问容器不须要进行映射直接能够访问

none

只有一个本地网卡信息

#建立,默认为bridge
docker network create  net01

#经过以下命令能够获得具体信息
docker network inspect net01

信息以下：
[
   {
       "Name": "net01",
       "Id": "b9fee626fdee",
       "Created": "2019-12-19T10:50:59.641869093Z",
       "Scope": "local",
       "Driver": "bridge",
       "EnableIPv6": false,
       "IPAM": {
           "Driver": "default",
           "Options": {},
           "Config": [
               {
                   "Subnet": "x.0.0.0/16",
                   "Gateway": "x.x.x.x" #网关信息
               }
           ]
       },
       "Internal": false,
       "Attachable": false,
       "Ingress": false,
       "ConfigFrom": {
           "Network": ""
       },
       "ConfigOnly": false,
       "Containers": { # 容器信息
           "c0f8db51792b9b394b": {
               "Name": "tomcat03",
               "EndpointID": "9a966183a87",
               "MacAddress": "",
               "IPv4Address": "x.x.x.x/16",
               "IPv6Address": ""
           }
       },
       "Options": {},
       "Labels": {}
   }
]

这是否意味着咱们能够经过上述三种方式自定义网络

# 从新启动一个容器，命令以下
docker run -d --name tomcat03 --network net01 -p 8082:8080 tomcat
#能够对比容器使用network参数与未使用的ip变化

神奇的是在tomcat03中此刻却没法ping通使用了docker默认的network建立的tomcat01容器。缘由在于自定义的网络跟docker0不在同一个网段因此没法ping通(tomcat03使用的是自定义网络,而tomcat01使用的则是默认的网络)，那么tomcat03和tomcat01固然没法ping通。

# 查看当前docker默认的bridge
docker inspect bridge
[
   {
       "Name": "bridge",
       "Id": "15ea9d89d6165304b561b",
       "Created": "2019-12-19T10:43:46.750789678Z",
       "Scope": "local",
       "Driver": "bridge",
       "EnableIPv6": false,
       "IPAM": {
           "Driver": "default",
           "Options": null,
           "Config": [
               {
                   "Subnet": "x.x.0.0/16",
                   "Gateway": "x.x.x.x"
               }
           ]
       },
       "Internal": false,
       "Attachable": false,
       "Ingress": false,
       "ConfigFrom": {
           "Network": ""
       },
       "ConfigOnly": false,
       "Containers": { #能够看到默认网络的容器信息
           "44371744ca1a": {
               "Name": "tomcat01",
               "EndpointID": "7005e8d9f9aab442",
               "MacAddress": "",
               "IPv4Address": "x.x.x.x/16",
               "IPv6Address": ""
           }
       },
       "Options": {
           "com.docker.network.bridge.default_bridge": "true",
           "com.docker.network.bridge.enable_icc": "true",
           "com.docker.network.bridge.enable_ip_masquerade": "true",
           "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
           "com.docker.network.bridge.name": "docker0",
           "com.docker.network.driver.mtu": "1500"
       },
       "Labels": {}
   }
]

# 将tomcat01也加入到自定义网络中
docker network connect net01 tomcat01
#再次查看net01发现tomcat01也在当中了

# 经过以下命令查看tomcat01的网络信息发现tomcat01中的网络此时多了一个ip地址
docker inspect tomcat01
#此时tomcat01和tomcat03由于有同网段的ip地址，因此又能够互通

结论: 为何容器之间可以相互连通,是由于docker会建立这种桥接模式,而桥接模式其实是使用了veth-pair技术,因此容器之间能够进行通讯。

container之间是否能够经过名称互通

若是真的能够那么就不须要担忧ip地址的变化了,就像微服务同样,服务与服务之间的调用经过注册咋注册中心上的服务名字便可调用。遗憾的是咱们在使用默认的docker网络是没法用名字的方式ping通

#增长link的方式进行指定
docker run -d --name tomcat05 --link tomcat01 -p 8085:8080 tomcat
	 
# 自定义网络的方式是能够互通的

多机通讯overlay网络

Swarm中实现

# 建立一个overlay网络
docker network create -d overlay o-net

#建立mysql
docker service create --name mysql -v v1:/var/lib/mysql  -e MYSQL_ROOT_PASSWORD=123 -e MYSQL_DATABASE=db_wordpress --network o-net mysql:5.6

#建立wordpress
docker service create --name wordpress -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=123 -e WORDPRESS_DB_HOST=mysql:3306 -e WORDPRESS_DB_NAME=db_wordpress -p 8080:80 --network o-net wordpress

#查看网络信息
docker network inspect o-net
[
    {
        "Name": "o-net",
        "Id": "45x28fm6",
        "Scope": "swarm",
        "Driver": "overlay",
        "IPAM": {
            "Driver": "default",
            "Config": [
                {
                    "Subnet": 
                    "Gateway": 
                }
            ]
        },
        "Containers": {
            "64cf17fd1f0": {
                "Name": "mysql.1.s1hfbsju",
                "EndpointID": 
                "MacAddress": 
                "IPv4Address":
            },
            "lb-overlay-net": {
                "Name": "overlay-net-endpoint",
                "EndpointID": ,
                "MacAddress":,
                "IPv4Address": ,
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.driver.overlay.vxlanid_list": "4097"
        },
        "Labels": {},
        "Peers": [
            {
                "Name": 
                "IP": 
            },
            {
                "Name":
                "IP": 
            }
        ]
    }
]

docker持久化

volume

# 查看，建立容器的时候会自动生成一个默认的volume
 docker volume ls
 
 DRIVER              VOLUME NAME
local               1deb0814c8723496c03aacecbe0535e47f39e1131286f3c0d1090eb8717617e8
local               3a7e9642878f96afe5b307b39dc184aad6f0ea379e53592b989e2d513a44c6b9
local               6f4e05e55601c866a614dd60b05386763e8081b93465472adbdceef5a1a2c60a

如上所示 VOLUME NAME太长不容易记忆
在建立容器的时候能够指定 -v
docker run -d --name mysql -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123  mysql

DRIVER             VOLUME NAME
local               mysql

# 查看详情
docker volume inspect mysql
[
   {
       "CreatedAt": "2019-12-23T06:40:53Z",
       "Driver": "local",
       "Labels": null,
       "Mountpoint": "/var/lib/docker/volumes/mysql/_data",
       "Name": "mysql",
       "Options": null,
       "Scope": "local"
   }
]

# 测试是否可以持久化
1.建立一个数据库tester
2. 退出容器并删除容器
3.查看volume发现，volume并不会随着容器的删除而删除
4.执行命令：docker run -d --name mysql -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123  mysql（volume属性指向以前建立的volume->mysql）
docker run -d --name mysql -p 3306:3306 -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123 --net net-cluster  mysql:latest --log-bin=mysql-bin --binlog-format=ROW --server_id=101(甚至能够直接修改my.cnf)
5.进入mysql并show databases；发现以前建立的数据库还在。

Bind Mounts

# 1. 建立一个文件 /usr/local/web/1.html
内容： <h1>hello</h1>

#2. 挂载并运行：docker run -d --name tomcat -p 8888:8080 -v 
/usr/local/web/:/usr/local/tomcat/webapps/web/ tomcat
或者
docker run -d --name tomcat02 -p 9000:8080 --mount type=bind,source=/usr/local/web/,target=/usr/local/tomcat/webapps/web/  tomcat

#3.访问http://ip:8888/web/1.html查看内容

#4.进入到Tomcat中查看,会发现有个同样的目录和文件。

#5.再次修改物理机中的1.html
加入内容<h2>Docker</h2>
#6.从新访问浏览器会发现内容的变化

Docker容器管理

若是使用命令行的方式，须要每次先建立自定义网路、挂载等再一个个的启动运行容器相对来讲比较麻烦，下面来看看Docker容器管理。

单机版多容器管理

docker-compose

安装

sudo curl -L "https://github.com/docker/compose/releases/download/1.25.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

	sudo chmod +x /usr/local/bin/docker-compose 

	docker-compose --version

版本

https://github.com/docker/compose/releases

命令

https://docs.docker.com/compose/reference/envvars/

示例

#打印访问次数
	# application.py
	import time
	import redis
	from flask import Flask
	app = Flask(__name__)
	cache = redis.Redis(host='redis', port=6379)

	def get_hit_count():
	retries = 5
	while True:
	 try:
    return cache.incr('hits')
	 except redis.exceptions.ConnectionError as exc:	
	    if retries == 0:
		  raise exc
	    retries -= 1
    time.sleep(0.5)

	@app.route('/')
	def hello():
	   count = get_hit_count()
	   return 'Hello World! I have been seen {} times.\n'.format(count)
	  ----------------------
	  requirements.txt:
	  flask
	  redis
	  -------------------------------
	  Dockerfile:
	  FROM python:3.7-alpine
	  WORKDIR /code
	  ENV FLASK_APP application.py
	  ENV FLASK_RUN_HOST 0.0.0.0
	  RUN apk add --no-cache gcc musl-dev linux-headers
	  COPY requirements.txt requirements.txt
	  RUN pip install -r requirements.txt
	  COPY . .
	  CMD ["flask", "run"]
	  ---------------------------------------------
	  docker-compose.yml:
	  version: '3'
	  services:
	     web:
		build: .
		ports:
		  - "5000:5000"
        volumes: 
          - /web
         networks:
          - compose-net
      redis:
          image: "redis:alpine"
          volumes: 
            - /redis
	           networks:
             - compose-net  
	   volumes:
     web:
     redis:
   networks:
     compose-net

注意：若是不指定网络，docker-compose会生成一个默认的网络

集群版多容器管理

docker swarm

示例（1个manager，2个work）

manager:

docker swarm init --advertise-addr= ip
	# 日志输出:
	Swarm initialized: current node (k2bfj4ipf63u) is now a manager.

work(2个):

$ docker swarm join --token SWMTKN-1-k2bfj4ipf63u192.0.0.1:2377
	日志输出：
	This node joined a swarm as a worker.

查看集群信息

docker node ls

ID                        HOSTNAME     STATUS    AVAILABILITY  MANAGER STATUS      ENGINE VERSION
k2bfj4ipf63u *   node1      Ready      Active    Leader         19.03.4
lf9i7sj17u5b     node2      Ready      Active                   19.03.4
69tfr9cq6j61     node3      Ready      Active                   19.03.4

节点升/降级

#示例命令：
docker node promote node2

docker node demote  node2

建立一个Tomcat

docker service create --name tomcat -p 8080:8080  tomcat

查看swarm的services

#命令：
docker service ls

ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
qy870rkl            tomcat              replicated          1/1                 tomcat:latest       *:8080->8080/tcp

查看service的启动日志

docker service logs tomcat

查看在哪一个node中运行

docker service ps tomcat

扩展service

docker service scale tomcat=3

自动恢复

# 删除其中一个容器
docker rm -f bfaxc6smw
#查看
$ docker service ps tomcat
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE            ERROR                         PORTS
50000saiypxh        tomcat.1            tomcat:latest       node2               Running             Running 30 minutes ago                                 
3x4bfaxc6smw        tomcat.2            tomcat:latest       node3               Running             Running 19 minutes ago                                 
vicrsu2aebud         \_ tomcat.2        tomcat:latest       node3               Shutdown            Failed 19 minutes ago    "task: non-zero exit (137)"   
ot50dhj0b1at        tomcat.3            tomcat:latest       node1               Running             Running 23 minutes ago

删除service

docker service rm tomcat
# 再次查看
docker service ls