Docker从入门到入土

# 官方介绍
- We have a complete container solution for you - no matter who you are and where you are on your containerization journey.
- 翻译: 我们为你提供了一个完整的容器解决方案,不管你是谁,不管你在哪,你都可以开始容器的的旅程。
- 官方定义: docker是一个容器技术。

# 底层
- Docker使用Google公司推出的 Go语言 进行开发实现，基于 Linux 内核的 cgroup、namespace 以及 OverlayFS 类的 Union FS 等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。由于隔离的进程独立于宿主和其它的隔离的进程,因此也称其为容器。
- Docker是一个CS架构，有分客户端和服务器端，详细你可以docker info 可以看出来 client和server

# 设置 仓库地址替换成自己的~

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

[root@localhost ~]# docker info
		..........
    127.0.0.0/8
   Registry Mirrors:
    'https://your.mirror.aliyuncs.com/'
   Live Restore Enabled: false
   Product License: Community Engine

[root@localhost ~]# docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

# 1.安装完成辅助命令
	docker version	 ---- 查看docker的信息
	docker info		 ---- 查看更详细的信息
	docker --help	 ---- 帮助命令

# 1.查看本机中所有镜像
	docker images	 ---- 列出本地所有镜像
		-a			 列出所有镜像（包含中间映像层）
  		-q			 只显示镜像id

# 2.搜索镜像
	docker search [options] 镜像名 ---- 去dockerhub上查询当前镜像
		-s 指定值	  列出收藏数不少于指定值的镜像
  		--no-trunc	显示完整的镜像信息

# 3.从仓库下载镜像
	docker pull 镜像名[:TAG|@DIGEST] ---- 下载镜像

# 4.删除镜像
	docker rmi 镜像名 ---- 删除镜像
		-f			 强制删除

# 1.运行容器
	docker run 镜像名 ---- 镜像名新建并启动容器
	--name 			 别名为容器起一个名字（自定义了dns解析，同一网桥下可以使用名称访问ip）
	-d				 启动守护式容器（在后台启动容器）
	-p 				 映射端口号：原始端口号 指定端口号启动
	--ip 172.18.0.2  指定ip（网桥下）
	--network bridge 指定网络模式
	-it 			 直接以交互模式启动（进容器里了）
	例：
	docker run -it --name myTomcat -p 8888:8080 tomcat
   	docker run -d --name myTomcat -P tomcat

# 2.docker run --privileged=true 参数作用
	使用该参数，container内的root拥有真正的root权限。
	否则，container内的root只是外部的一个普通用户权限。
	privileged启动的容器，可以看到很多host上的设备，并且可以执行mount。
	甚至允许你在docker容器中启动docker容器。

# 3.docker run -d 参数作用
	启动后直接返回容器id，不以终端的形式运行容器（终端 ctrl+c 就直接退出了）

# 4.查看运行的容器
	docker ps 		 ---- 列出所有正在运行的容器
	-a				 正在运行的和历史运行过的容器
	-q				 静默模式，只显示容器编号
	docker ps -qa

# 5.停止|关闭|重启容器
	docker start   容器名字或者容器id	     ---- 开启容器
	docker restart 容器名或者容器id   	      ---- 重启容器
	docker stop  容器名或者容器id		      ---- 正常停止容器运行
	docker kill  容器名或者容器id		      ---- 立即停止容器运行

# 6.删除容器
	docker rm -f 容器id和容器名     
	docker rm -f $(docker ps -aq)          ---- 删除所有容器

# 7.查看容器内进程
	docker top 容器id或者容器名		      ---- 查看容器内的进程

# 8.查看查看容器内部细节
	docker inspect 容器id				     ---- 查看容器内部细节
	docker inspect --format="{{.Id}}" name ---- 获取运行容器id

# 9.查看容器的运行日志
	docker logs [OPTIONS] 容器id或容器名     ---- 查看容器日志
	-t			 加入时间戳
	-f			 跟随最新的日志打印
	--tail 	 数字	显示最后多少条
	docker logs -t -f --tail=100 rabbitmq

# 10.进入容器内部
	docker exec [options] 容器id 容器内命令  ---- 进入容器执行命令
	-i		以交互模式运行容器，通常与-t一起使用
 	-t		分配一个伪终端    shell窗口   bash 
	docker exec -it rabbitmq bash

# 11.容器和宿主机之间复制文件
	docker cp 文件|目录 容器id:容器路径 
	---- 将宿主机复制到容器内部
	docker cp 容器id:容器内资源路径 宿主机目录路径 
	---- 将容器内资源拷贝到主机上

# 12.数据卷(volum)实现与宿主机共享目录
	docker run -v 宿主机的路径|任意别名:/容器内的路径 镜像名
	docker run -v 宿主机的路径|任意别名:/容器内的路径:ro 镜像名
	:ro 表示容器内目录只读（容器不能操作这个目录）
	注意（这个非常重要）: 
	1.如果是宿主机路径必须是绝对路径,宿主机目录会覆盖容器内目录内容
	2.如果是别名则会在docker运行容器时自动在宿主机中创建一个目录,并将容器目录文件复制到宿主机中
	理解上面的注意点还是非常有用的。

# 13.打包镜像
	docker save 镜像名 -o 名称.tar

# 14.载入镜像
	docker load -i 名称.tar

# 15.容器打包成新的镜像（容器会暂停）
	docker commit -m "描述信息" -a "作者信息" 容器id或者名称 打包的镜像名称:标签

# 16.打包(dockerfile) 不要忘了后面的 . 这里指定的上下文目录，上下文目录为当前目录
	docker build -t vuenginxcontainer .
	docker build -t myctr:01 .

# docker network ls

# docker network create -d bridge 网桥名称

# docker network rm 网桥名称

# 1.查询当前网络配置
	docker network ls

NETWORK ID          NAME                DRIVER              SCOPE
8e424e5936b7        bridge              bridge              local
17d974db02da        docker_gwbridge     bridge              local
d6c326e433f7        host                host                local

# 2.创建桥接网络
	docker network create -d bridge info

[root@centos ~]# docker network create -d bridge info
6e4aaebff79b1df43a064e0e8fdab08f52d64ce34db78dd5184ce7aaaf550a2f
[root@centos ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
8e424e5936b7        bridge              bridge              local
17d974db02da        docker_gwbridge     bridge              local
d6c326e433f7        host                host                local
6e4aaebff79b        info                bridge              local

# 3.启动容器指定使用网桥
	docker run -d -p 8890:80 --name nginx001 --network info nginx 
	docker run -d -p 8891:80 --name nginx002 --network info nginx 

# 注意:一旦指定网桥后--name指定名字就是主机名,多个容器指定在同一个网桥时,可以在任意一个容器中使用主机名与容器进行互通

[root@centos ~]# docker run -d -p 8890:80 --name nginx001 --network info nginx 
c315bcc94e9ddaa36eb6c6f16ca51592b1ac8bf1ecfe9d8f01d892f3f10825fe
[root@centos ~]# docker run -d -p 8891:80 --name nginx002 --network info nginx
f8682db35dd7fb4395f90edb38df7cad71bbfaba71b6a4c6e2a3a525cb73c2a5
[root@centos ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
f8682db35dd7        nginx               "/docker-entrypoint.…"   3 seconds ago       Up 2 seconds        0.0.0.0:8891->80/tcp   nginx002
c315bcc94e9d        nginx               "/docker-entrypoint.…"   7 minutes ago       Up 7 minutes        0.0.0.0:8890->80/tcp   nginx001
b63169d43792        mysql:5.7.19        "docker-entrypoint.s…"   7 minutes ago       Up 7 minutes        3306/tcp               mysql_mysql.1.s75qe5kkpwwttyf0wrjvd2cda
[root@centos ~]# docker exec -it f8682db35dd7 /bin/bash
root@f8682db35dd7:/# curl http://nginx001
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
.....

# 可以直接查看当前网桥的ip（网关gatwway）和在这个ip下活跃的容器 Containers标签存在容器即活跃
	docker inspect 网桥名称

[root@worker2 ~]# docker network ls
NETWORK ID          NAME                     DRIVER              SCOPE
ef209b3f55ac        bridge                   bridge              local
d5d7fb7c733a        host                     host                local
9617f81ea7ed        metersphere_ms-network   bridge              local
b8fbeb5755fc        none                     null                local
[root@worker2 ~]# docker inspect metersphere_ms-network
[
    {
        "Name": "metersphere_ms-network",
        "Id": "9617f81ea7edc6e38e711dfea23ffaa0c8dc17df458c597213a52b389a3c480e",
        "Created": "2021-05-31T14:27:40.186875973+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.18.0.0/16",
                    "Gateway": "172.18.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": true,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "73cd659e5bd5f772b6481319aba934043121329e0edf9a2e96e9ddc7e64d69b8": {
                "Name": "ms-node-controller",
                "EndpointID": "c787b3b08d33088df519b879a0cb4f96f56e1ac2c0647c4dfd8adaa6450d9bf4",
                "MacAddress": "02:42:ac:12:00:05",
                "IPv4Address": "172.18.0.5/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {
            "com.docker.compose.network": "ms-network",
            "com.docker.compose.project": "metersphere"
        }
    }
]
[root@worker2 ~]# 

[root@centos ~]# docker volume create my-vol
my-vol

[root@centos ~]# docker volume inspect my-vol       
[
    {
        "CreatedAt": "2020-11-25T11:43:56+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
        "Name": "my-vol",
        "Options": {},
        "Scope": "local"
    }
]

[root@centos ~]# docker run -d -P --name web  -v my-vol:/usr/share/nginx/html  nginx
[root@centos ~]# docker inspect web
				"Mounts": [
            {
                "Type": "volume",
                "Name": "my-vol",
                "Source": "/var/lib/docker/volumes/my-vol/_data",
                "Destination": "/usr/share/nginx/html",
                "Driver": "local",
                "Mode": "z",
                "RW": true,
                "Propagation": ""
            }
        ],

docker volume rm my-vol

# 1.拉取mysql镜像到本地
	docker pull mysql:tag (tag不加默认最新版本)
	
# 2.简单运行mysql服务
	docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -d  mysql:tag

# 3.进入mysql容器
	docker exec -it 容器名称|容器id bash

# 4.外部查看mysql日志
	docker logs 容器名称|容器id

# 5.使用自定义配置参数
	docker run -d --name mysql \
	-v /root/mysql/conf.d:/etc/mysql/conf.d \
	-e MYSQL_ROOT_PASSWORD=root \
	mysql:tag

# 6.将容器数据位置与宿主机位置挂载保证数据安全
	docker run -p 3306:3306 -d --name mysql \
	-v /root/mysql/data:/var/lib/mysql \
	-v /root/mysql/conf.d:/etc/mysql/conf.d \
	-e MYSQL_ROOT_PASSWORD=root \
	mysql:tag

# 7.将mysql数据库备份为sql文件
	docker exec mysql|容器id sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql  --导出全部数据
	docker exec mysql sh -c 'exec mysqldump --databases 库表 -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql  --导出指定库数据
	docker exec mysql sh -c 'exec mysqldump --no-data --databases 库表 -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql  --导出指定库数据不要数据

# 8.执行sql文件到mysql中
	docker exec -i mysql sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /root/xxx.sql

# 1.在docker hub搜索redis镜像
	docker search redis
	redis:5.0.10-alpine3.12, 这是最小的redis, 应为alpine是最小的linux操作系统 就几m

# 2.拉取redis镜像到本地
	docker pull redis

# 3.启动redis服务运行容器
	docker run --name redis -d redis:tag (没有暴露外部端口)
	docker run --name redis -p 6379:6379 -d redis:tag (暴露外部宿主机端口为6379进行连接) 

# 4.查看启动日志
	docker logs -t -f 容器id|容器名称

# 5.进入容器内部查看
	docker exec -it 容器id|名称 bash  

# 6.开启aof存储
	默认情况下快照备份也是默认开启的（dump.rdb），但是官方镜像介绍没有明确在哪，持久化可以使用aof
	docker run --name redis -d -v redisdata:/data redis:5.0.10 redis-server --appendonly yes
	开启持久化之后，持久化生成aof文件会被放入容器中的/data目录中（appendonly.aof）

# 6.加载外部自定义配置启动redis容器
	默认情况下redis官方镜像中没有redis.conf配置文件 需要去官网下载指定版本的配置文件 
	这些配置是在执行 redis-server 后再指定配置的位置后 生效
	1. wget http://download.redis.io/releases/redis-5.0.8.tar.gz  下载官方安装包
	2. 将官方安装包中配置文件进行复制到宿主机指定目录中如 /root/redis/redis.conf文件
	3. 修改需要自定义的配置
		 bind 0.0.0.0 开启远程权限 不改redis manager连不上
		 appenonly yes 开启aof持久化
	4. 加载配置启动
	docker run --name redis -v /root/redis:/usr/local/etc/redis -p 6379:6379 -d redis:5.0.10 redis-server /usr/local/etc/redis/redis.conf  

# 7.将数据目录挂在到本地保证数据安全
	docker run -p 6379:6379 -d --name redis \
	-v /root/redis/data:/data \
	-v /root/redis/redis.conf:/usr/local/etc/redis/redis.conf \
	redis:5.0.10 redis-server /usr/local/etc/redis/redis.conf

# 1.在docker hub搜索nginx
	docker search nginx

# 2.拉取nginx镜像到本地
    [root@localhost ~]# docker pull nginx
    Using default tag: latest
    latest: Pulling from library/nginx
    afb6ec6fdc1c: Pull complete 
    b90c53a0b692: Pull complete 
    11fa52a0fdc0: Pull complete 
    Digest: sha256:30dfa439718a17baafefadf16c5e7c9d0a1cde97b4fd84f63b69e13513be7097
    Status: Downloaded newer image for nginx:latest
    docker.io/library/nginx:latest

# 3.启动nginx容器
	docker run -p 80:80 --name nginx01 -d nginx

# 4.进入容器
	docker exec -it nginx01 /bin/bash
	查找目录:  whereis nginx
	配置文件:  /etc/nginx/nginx.conf

# 5.复制配置文件到宿主机
	docker cp nginx01(容器id|容器名称):/etc/nginx/nginx.conf 宿主机名录

# 6.挂在nginx配置以及html到宿主机外部
	docker run -p 80:80 -d --name nginx02 \
	-v /root/nginx/nginx.conf:/etc/nginx/nginx.conf \
	-v /root/nginx/html:/usr/share/nginx/html \
	nginx		

# 1.在docker hub搜索tomcat
	docker search tomcat

# 2.下载tomcat镜像
	docker pull tomcat

# 3.运行tomcat镜像
	docker run -p 8080:8080 -d --name mytomcat tomcat

# 4.进入tomcat容器
	docker exec -it mytomcat /bin/bash

# 5.将webapps目录挂载在外部
	docker run -d --name mytomcat -p 8080:8080 \
	-v /root/webapps:/usr/local/tomcat/webapps \
	tomcat
# 6.数据卷启动	
	docker run -d --name tomcat -p 8080:8080 \
	-v apps:/usr/local/tomcat/webapps \
	-v confs:/usr/local/tomcat/conf \
	tomcat:8.0-jre8

# 1.运行mongDB
	docker run -d -p 27017:27017 --name mymongo mongo  ---无须权限
	docker logs -f mymongo --查看mongo运行日志

# 2.进入mongodb容器
	docker exec -it mymongo /bin/bash
		直接执行mongo命令进行操作

# 3.常见具有权限的容器
	docker run --name  mymongo  -p 27017:27017  -d mongo --auth

# 4.进入容器配置用户名密码
	mongo
	use admin 选择admin库
	db.createUser({user:"root",pwd:"root",roles:[{role:'root',db:'admin'}]})   //创建用户,此用户创建成功,则后续操作都需要用户认证
	exit

# 5.将mongoDB中数据目录映射到宿主机中
	docker run -d -p 27017:27017 -v /root/mongo/data:/data/db --name mymongo mongo 

# 1.dockerhub 拉取镜像
	docker pull elasticsearch:6.4.2
	docker pull elasticsearch:6.8.0
# 2.查看docker镜像
	docker images
# 3.运行docker镜像
	docker run -p 9200:9200 -p 9300:9300 elasticsearch:6.8.0
	参数：-e “discovery.type=single-node” 以单节点启动，在es中单节点就是集群模式，如果不加这个参数以默认的集群模式启动也是可以的
	     --net somenetwork 指定docker网桥，使用中最好是指定网桥
	     -p 9200 http 9300 tcp

# 1.在centos虚拟机中，修改配置sysctl.conf
	vim /etc/sysctl.conf
# 2.加入如下配置
	vm.max_map_count=262144 
# 3.启用配置
	sysctl -p
	注：这一步是为了防止启动容器时，报出如下错误：
	bootstrap checks failed max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]
# 说明 max_map_count
	“This file contains the maximum number of memory map areas a process may have. Memory map areas are used as a side-effect of calling malloc, directly by mmap and mprotect, and also when loading shared libraries.

	While most applications need less than a thousand maps, certain programs, particularly malloc debuggers, may consume lots of them, e.g., up to one or two maps per allocation.

	The default value is 65536.”

	max_map_count文件包含限制一个进程可以拥有的VMA(虚拟内存区域)的数量。
	虚拟内存区域是一个连续的虚拟地址空间区域。在进程的生命周期中，每当程序尝试在内存中映射文件，链接到共享内存段，或者分配堆空间的时候，这些区域将被创建。
	调优这个值将限制进程可拥有VMA的数量。限制一个进程拥有VMA的总数可能导致应用程序出错，因为当进程达到了VMA上线但又只能释放少量的内存给其他的内核进程使用时，操作系统会抛出内存不足的错误。如果你的操作系统在NORMAL区域仅占用少量的内存，那么调低这个值可以帮助释放内存给内核用。

# 0.复制容器中data目录到宿主机中
	docker cp 容器id:/usr/share/share/elasticsearch/data /root/es
# 1.运行ES容器 指定jvm内存大小并指定ik分词器位置
	docker run -d --name es -p 9200:9200 -p 9300:9300 \
	-e ES_JAVA_OPTS="-Xms128m -Xmx128m" \
	-v /root/es/plugins:/usr/share/elasticsearch/plugins \
	-v /root/es/data:/usr/share/elasticsearch/data \
	elasticsearch:6.4.2
	
	docker run -d --name es -p 9200:9200 -p 9300:9300 \
	-v esplugins:/usr/share/elasticsearch/plugins \
	-v esdata:/usr/share/elasticsearch/data \
	-v esconfig:/usr/share/elasticsearch/config \
	elasticsearch:6.8.0

# 1.下载对应版本的IK分词器
	wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.4.2/elasticsearch-analysis-ik-6.4.2.zip

	wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip

# 2.解压到plugins文件夹中
	yum install -y unzip
	cd /var/lib/docker/volumes/esplugins/_data
	mkdir ik
	cd ik
	cp /root/elasticsearch-analysis-ik-6.8.0.zip .
	unzip -d ik elasticsearch-analysis-ik-6.8.0.zip
	rm -rf elasticsearch-analysis-ik-6.8.0.zip

# 3.添加自定义扩展词和停用词（插件挂载目录夹解压ik的zip包下面有个config文件夹
	cd plugins/elasticsearch/config
	vim IKAnalyzer.cfg.xml
	<properties>
		<comment>IK Analyzer 扩展配置</comment>
		<!--用户可以在这里配置自己的扩展字典 -->
		<entry key="ext_dict">ext_dict.dic</entry>
		<!--用户可以在这里配置自己的扩展停止词字典-->
		<entry key="ext_stopwords">ext_stopwords.dic</entry>
	</properties>

# 4.在ik分词器目录下config目录中创建ext_dict.dic文件   编码一定要为UTF-8才能生效
	vim ext_dict.dic 加入扩展词即可
# 5. 在ik分词器目录下config目录中创建ext_stopword.dic文件 
	vim ext_stopwords.dic 加入停用词即可

# 6.重启容器生效
	docker restart 容器id
# 7.将此容器提交成为一个新的镜像
	docker commit -a="xiaochen666" -m="es with IKAnalyzer" 容器id xiaochen/elasticsearch:6.4.2

# 1.下载kibana镜像到本地
	docker pull kibana:6.4.2
	docker pull kibana:6.8.0

# 2.启动kibana容器
	docker run -d --name kibana -e ELASTICSEARCH_URL=http://10.15.0.3:9200 -p 5601:5601 kibana:6.4.2
	docker run -d --name kibana -e ELASTICSEARCH_URL=http://10.15.0.3:9200 -p 5601:5601 kibana:6.8.0
# 3.映射配置
	docker run -d --name kibana -p 5601:5601 -v kibanaconf:/usr/share/kibana/config kibana:6.8.0

# Nexus搭建
# 在线就直接pull吧
docker pull sonatype/nexus3
# 离线
# 将离线镜像加载入docker
sudo docker load --input nexus.tar.gz

# 创建私库目录
mkdir -p /middleware/nexus-data 
chmod -R 777 /middleware/nexus-data

# 启动
sudo docker run --name finnexus \
-d --restart=unless-stopped \
-p 5000-5010:5000-5010 \
-p 8081:8081 \
-v /middleware/nexus-data:/nexus-data \
sonatype/nexus3
# 如果换端口
sudo docker run --restart=unless-stopped -d -p 4000-4010:5000-5010 -p 4081:8081 -v /app/nexus-data:/nexus-data --name nexus sonatype/nexus3

# -p 表示将服务器的端口与容器端口映射
# -v 表示将服务器的目录与容器的目录映射
# 其中neuxs映射的服务器路径要有权限
# 其中8081端口是对应nexus的管理界面的端口
# 5000-5010 表示5000到5010端口，后面创建私有仓库时端口必须在5000到5010之间

# 登录nexus控制台地址 ip:8081
# 如果换了端口 命令参考上面换过端口的命令
# 登录nexus控制台地址 ip:4081

# 查看默认登录密码
cd /app/nexus-data
cat admin.password
# 密码修改为你要的
# 具体设置单独开文章，这里就不多写了

# 0.在线直接pull
docker pull rabbitmq:3.7.8-management-alpine
# 1.上传tar包

    rabbitmq.tar.gz

# 2.load tar包
docker load --input rabbitmq.tar.gz
  出现如下说明：
  2053661fb7d0: Loading layer  12.29kB/12.29kB
  5689db811598: Loading layer  40.96kB/40.96kB
  d2459d554acf: Loading layer  34.29MB/34.29MB
  fc486e98542a: Loading layer  11.13MB/11.13MB
  4bdd294e3b25: Loading layer  5.632kB/5.632kB
  b391c5160f19: Loading layer  2.048kB/2.048kB
  53a95db89e8a: Loading layer  1.536kB/1.536kB
  4db8bc9b75ab: Loading layer  15.36kB/15.36kB
  669bd8e5d693: Loading layer  3.072kB/3.072kB
  86e21faff3ee: Loading layer  37.92MB/37.92MB
  Loaded image: rabbitmq:3.7.8-management-alpine
  
# 3.创建宿主机映射目录
mkdir -p /middleware/rabbitmq/lib
mkdir -p /middleware/rabbitmq/log

# 4.docker run
docker run --name finrabbitmq \
-d --restart=unless-stopped \
-p 5672:5672 \
-p 15672:15672 \
-v /middleware/rabbitmq/lib:/var/lib/rabbitmq \
-v /middleware/rabbitmq/log:/var/log/rabbitmq \
rabbitmq:3.7.8-management-alpine
  
  -it 标准输入给容器并产生一个交互性shell
  -d 在后台运行
  --name 容器名
  -v 目录映射
  -p 端口映射
  
# 5.检查日志是否启动成功
  docker logs -t --tail=100 rabbitmq
 
# 6.登录ip:15672，默认用户名密码 guest/guest

# 在线直接pull
docker pull minio/minio:RELEASE.2020-12-29T23-29-29Z

# 我比较喜欢上面的版本 下面的命令全部是latest的tag有需要自行修改下
# 存储目录：
mkdir -p /middleware/minio/data
mkdir -p /middleware/minio/config
  
# 启动命令：

docker run -p 9000:9000 --name finminio \
-d --restart=unless-stopped \
-e "MINIO_ACCESS_KEY=fin" \
-e "MINIO_SECRET_KEY=eyQ3idRpVkNZ" \
-v /middleware/minio/data:/data \
-v /middleware/minio/config:/root/.minio \
minio/minio server /data

# 控制台访问地址：
http://101.133.150.61:9100/minio/login
fin/eyQ3idRpVkNZ

docker load --input nacos.tar

mkdir -p /middleware/nacos/data
mkdir -p /middleware/nacos/logs

docker run \
--restart=unless-stopped \
--name finnacos \
--privileged=true \
-p 8848:8848 \
-e PREFER_HOST_MODE=ip \
-e MODE=standalone \
-e NACOS_SERVER_PORT=8848 \
-v /middleware/nacos/data:/home/nacos/data \
-v /middleware/nacos/logs:/home/nacos/logs \
-d nacos/nacos-server:1.4.0

# 举例中你可能用到的命令
touch bb.txt

echo "666" >> bb.txt

docker build -t mycentos7:1 .

FROM centos:7
# 我要基于原来的镜像往里安装里没有的指令的并创建新的进镜像 这里装了vim
#RUN yum intall -y vim
RUN ["yum","install","-y","vim"]
# EXPOSE 服务 docker run 的 -p 命令 只有expose之后才能-p生效
EXPOSE 5672
EXPOSE 15672
# WORKDIR 指定的工作目录 目录不存在会给你创建 意思是你docker run之后 进入容器的目录
# 下面的两个WORKDIR设置之后运行了容器 你进入之后pwd 显示的目录就是/data/a
WORKDIR /data
WORKDIR a
# dockerfile目录下还有个aa.txt 把这个东西拷贝到新创建的容器里
COPY aa.txt /data/a
# ADD 和 COPY差不多 只不过他能自动下载（放url）还能解压
ADD bb.txt /data/b
# 这样使用 ADD 会下载gz包 这时候不解压 直接丢进/data/b
# ADD https://download.redis.io/releases/redis-6.2.4.tar.gz /data/b

# 这样使用 ADD 会将本地gz包 解压缩到新建容器的/data/b
# ADD redis-6.2.4.tar.gz /data/b
# 如果这时候你在 run mv 就会把解压文件 丢进去redis文件夹
# RUN mv redis-6.2.4 redis
# 如果你再设置工作目录 这时候进入运行的新容器就会进入 /data/b/redis 
# WORKDIR redis

# VOLUME 服务 -v 只有写了 -v 才能允许挂载（这个概念可能不对 有时间验证验证）
VOLUME /data/b

# ENV 设置环境变量 很好理解 设置之后后面都能用
ENV BASE_DIR /data/b
ADD bb.txt $BASE_DIR
VOLUME $BASE_DIR/test

# 指定容器运行的命令 运行了 ls 会在docker的宿主机输出 ls输出的内容
# ENTRYPOINT 可以写多个 覆盖需要加上 --entrypoint = ls 
# docker run --entrypoint=ls mycentos7:18 /data/a
#ENTRYPOINT ls $BASE_DIR/test
# CMD 可以执行多个 可以被 docker run 之后的命令覆盖掉
# docker rum mycentos7:18 ls /data/b
#CMD ls /data/b/

#一般ENTRYPOINT和CMD连用 CMD后面作为参数 传给ENTRYPOINT
# 如果 docker run mycentos7:19 则只输出 data下目录
# 如果 docker run mycentos7:19 
# 这种shell 格式不生效 需要使用 json数组形式
# ENTRYPOINT ls /data
# CMD /data/b

# 以下build完成之后会输出 ls /data 也会输出 ls /data/b
ENTRYPOINT ["ls","/data"]
CMD ["/data/b"]

# 总结 ENTRYPOINT 写参数 CMD 写参数

FROM openjdk:8
WORKDIR /ems
ADD ems.jar /ems
EXPOSE 8989
ENTRYPOINT ["java","-jar"]
CMD ["ems.jar"]

[root@localhost ems]# docker build -t ems .

[root@localhost ems]# docker run -p 8989:8989 ems

http://10.15.0.8:8989/ems/login.html

$ sudo curl -L https://github.com/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose

$ curl -L https://raw.githubusercontent.com/docker/compose/1.25.5/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

mv docker-compose-Linux-x86_64 docker-compose
mv docker-compose /usr/local/bin
chmod +x /usr/local/bin/docker-compose 

$ sudo rm /usr/local/bin/docker-compose

$ docker-compose --version
 docker-compose version 1.25.5, build 4667896b

version: "3.0"
services:

	demo:
	  build:
	    context: demo
	    dockerfile: Dockerfile
	  container_name: demo
	  ports:
	    - "8081:8081"
	  networks:
	    - hello
	  depends_on:
	    - tomcat01

  mysqldb:
    image: mysql:5.7.19
    container_name: mysql
    ports:
      - "3306:3306"
    volumes:
      - /root/mysql/conf:/etc/mysql/conf.d
      - /root/mysql/logs:/logs
      - /root/mysql/data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
    networks:
      - ems
    depends_on:
      - redis

  redis:
    image: redis:4.0.14
    container_name: redis
    ports:
      - "6379:6379"
    networks:
      - ems
    volumes:
      - /root/redis/data:/data
    command: redis-server
    
networks:
  ems:

- 练习

version: "3.2"

services:
  tomcat01: #服务名称
    container_name: tomcat01 # 相当于run 的 --name
    image: tomcat:8.0-jre8 #使用哪个镜像  相当于run image
    ports:  #用来完成host与容器的端口映射关系  相当于run -p
      - "8080:8080"
    volumes: #完成宿主机与容器中目录数据卷共享  相当于run -v
      #- /root/apps:/usr/local/tomcat/webapps #使用自定义路径映射
      - tomcatwebapps01:/usr/local/tomcat/webapps
    networks: #代表当前服务使用哪个网络桥     相当于run --network
      - hello
    depends_on: #代表这个容器必须依赖哪个容器之后才能启动 这个依赖启动并不是说等
    	- tomcat02 #这里书写的是服务名
    	- redis
    	- mysql
    healthcheck: #心跳检测
      test: ["CMD", "curl", "-f", "http://localhost"] #和docker内核通信
      interval: 1m30s
      timeout: 10s
      retries: 3
		  
  tomcat02: #服务名称
    container_name: tomcat02
    image: tomcat:8.0-jre8 #使用哪个镜像
    ports:  #用来完成host与容器的端口映射关系
      - "8081:8080"
    volumes: #完成宿主机与容器中目录数据卷共享
      #- /root/apps:/usr/local/tomcat/webapps #使用自定义路径映射
      - tomcatwebapps02:/usr/local/tomcat/webapps
    networks: #代表当前服务使用哪个网络桥
      - hello
    #sysctls: #用来修改容器中系统内部参数 并不是必须的有些服务启动受容器内操作系统参数限制可能会无法启动
    # - net.core.somaxconn=1024
    # - net.ipv4.tcp_syncookies=0
    #ulimits: #用来修改容器中系统内部进程数限制 可以根据当前运行服务要求进行更改
    #  nproc: 65535
    #  nofile:
    #    soft: 20000
    #    hard: 40000
        
  mysql:
    image: mysql:5.7.32
    container_name: mysql
    ports:
      - "3307:3306"
    volumes:
      - mysqldata:/var/lib/mysql
      - mysqlconf:/etc/mysql
    #environment:
    #  - MYSQL_ROOT_PASSWORD=root
    env_file: #用来将environment配置放入指定的配置文件中
    	- mysql.env #compose的当前路径
    networks:
      - hello

  redis:
    image: redis:5.0.10
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - redisdata:/data
    networks:
      - hello
    command: "redis-server --appendonly yes" #run 镜像之后用来覆盖容器内容默认命令




volumes:  #声明上面服务所使用的自动创建的卷名
  tomcatwebapps01: #声明指令的卷名  compose自动创建该卷名但是会在之前加入项目名
    external:    #使用自定义卷名
      false       #true确定使用指定卷名  注意:一旦使用外部自定义卷名启动服务之前必须手动创建
  tomcatwebapps02:
  mysqldata:
  mysqlconf:
  redisdata:

networks: #定义服务用到桥
  hello: #定义上面的服务用到的网桥名称 默认创建就是 bridge
    external:
      true   #使用外部指定网桥  注意:网桥必须存在

[root@centos ~]# docker-compose up    							//前台启动一组服务
[root@centos ~]# docker-compose up -d 							//后台启动一组服务

version: "3" #docker-compose的版本

services:
  webapp:
    image: examples/web
    ports:
      - "80:80"
    volumes:
      - "/data"

version: '3'
services:

  webapp:
    build: ./dir

version: '3'
services:

  webapp:
    build:
      context: ./dir #相对路径 相对于docker-compose.yml
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1

command: echo "hello world"

container_name: docker-web-container

version: '3'

services:
  web:
    build: .
    depends_on:
      - db
      - redis

  redis:
    image: redis

  db:
    image: postgres

env_file: .env

env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env

# common.env: Set development environment
PROG_ENV=development

environment:
  RACK_ENV: development
  SESSION_SECRET:

environment:
  - RACK_ENV=development
  - SESSION_SECRET

y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 1m30s
  timeout: 10s
  retries: 3

image: ubuntu
image: orchardup/postgresql
image: a4bc65fd

version: "3"
services:

  some-service:
    networks:
     - some-network
     - other-network

networks:
  some-network:
  other-network:

ports:
 - "3000"
 - "8000:8000"
 - "49100:22"
 - "127.0.0.1:8001:8001"

sysctls:
  net.core.somaxconn: 1024
  net.ipv4.tcp_syncookies: 0

sysctls:
  - net.core.somaxconn=1024
  - net.ipv4.tcp_syncookies=0

  ulimits:
    nproc: 65535
    nofile:
      soft: 20000
      hard: 40000

volumes:
 - /var/lib/mysql:/var/lib/mysql
 - cache/:/tmp/cache
 - ~/configs:/etc/configs/:ro

version: "3"

services:
  my_src:
    image: mysql:8.0
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  mysql_data:

docker-compose [-f=<arg>...] [options] [COMMAND] [ARGS...]

docker-compose -f your-compose.yml -p your-project up

[root@ubuntu1804 ~]#docker pull  portainer/portainer

[root@ubuntu1804 ~]#docker volume create portainer_data
portainer_data
[root@ubuntu1804 ~]#docker run -d -p 8000:8000 -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
20db26b67b791648c2ef6aee444a5226a9c897ebcf0160050e722dbf4a4906e3
[root@ubuntu1804 ~]#docker ps 
CONTAINER ID        IMAGE                 COMMAND             CREATED             STATUS              PORTS                                            NAMES
20db26b67b79        portainer/portainer   "/portainer"        5 seconds ago       Up 4 seconds        0.0.0.0:8000->8000/tcp, 0.0.0.0:9000->9000/tcp   portainer

version: "3.2"

services:
  portainer: 
    container_name: portainer
    image: portainer/portainer
    ports:
      - "8000:8000"
      - "9000:9000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    
volumes:
  portainer_data: 
    external:
      true

[root@localhost ~]# docker search 或者 docker pull 这些命令无法使用
Error response from daemon: Get https://index.docker.io/v1/search?q=mysql&n=25: x509: certificate has expired or is not yet valid

# 1.安装时间同步
	sudo yum -y install ntp ntpdate
# 2.同步时间
	sudo ntpdate cn.pool.ntp.org
# 3.查看本机时间
	date
# 4.重新测试