docker尝试和Swarm集群搭建

置顶波波爱下班

已于 2022-07-24 12:32:07 修改

阅读量1.5k

点赞数 1

文章标签： docker linux centos

于 2022-03-11 08:58:19 首次发布

本文链接：https://blog.csdn.net/weixin_42435798/article/details/123415923

版权

一件自动安装docker脚本：自己创建一个sh文件执行就可以了

#! /bin/bash

echo "正在卸载旧版本docker"
 sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

echo"旧版本卸载完毕"
echo" =======正在删除旧版本文件夹======="
 sudo rm -rf /var/lib/docker
 sudo rm -rf /var/lib/containerd

echo "开始安装docker程序"
echo "=========基本环境安装扫描=========="
yum install -y yum-utils
yum install -y yum-utils device-mapper-persistent-data lvm2

echo "========设置阿里云镜像仓库========="
yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

echo "正在更新索引"
yum makecache
yum makecache fast


echo "======开始安装docker引擎========"
yum install docker-ce docker-ce-cli containerd.io -y

echo "=======启动dokcer查看版本"
systemctl start docker
docker version


echo "=========运行hello-world=======检查docker是否可用"
docker run hello-world

docker images
echo "====hello-world程序出现代表可用======"


echo "配置阿里云镜像加速器"
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "exec-opts": [
    "native.cgroupdriver=systemd"
  ],
  "registry-mirrors": ["https://wy2ktaj3.mirror.aliyuncs.com"]
}
EOF
echo "重启docker"
sudo systemctl daemon-reload

echo "查看docker"
docker version

echo "===========安装结束，恭喜波波！！！！================"
sudo systemctl restart docker

手动安装：

centos8停止维护：更新解决方案

# 将所有 repo 中的文件都替换为 CentOS Steam 的源
sudo sed -i "s|\$releasever|8-stream|g"  /etc/yum.repos.d/CentOS-*.repo

# 更新源
yum makecache

准备1：查看linux环境和系统

[root@tangbo /]# uname -r
5.10.60-9.al8.x86_64

[root@tangbo /]# cat /etc/os-release 
NAME="Alibaba Cloud Linux"
VERSION="3 (Soaring Falcon)"
ID="alinux"
ID_LIKE="rhel fedora centos"
VERSION_ID="3"
PLATFORM_ID="platform:al8"
PRETTY_NAME="Alibaba Cloud Linux 3 (Soaring Falcon)"
ANSI_COLOR="0;31"
HOME_URL="https://www.aliyun.com/"

准备2卸载旧的docker:

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

准备3安装基本环境：

yum install -y yum-utils

2.安装lvm2:

yum install -y yum-utils device-mapper-persistent-data lvm2

3.设置镜像仓库：

Docker CE 镜像源站-阿里云开发者社区

yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

4.更新软件包索引：

yum makecache fast

5.安装docker引擎：

yum install docker-ce docker-ce-cli containerd.io

6.启动docker:

systemctl start docker

7.查看是否安装成功：

docker version

8.写一个hello world:做了很多事情

docker run hello-world

9.查看下载的hello-world镜像在不在：

[root@tangbo ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   5 months ago   13.3kB
[root@tangbo ~]#

10.了解卸载docker：

1）卸载依赖：

yum remove docker-ce docker-ce-cli containerd.io

2）删除目录：

docker默认路径

 sudo rm -rf /var/lib/docker
 sudo rm -rf /var/lib/containerd

11.配置阿里云镜像加速器：

https://cr.console.aliyun.com/cn-beijing/instances/mirrors

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

12：为什么docker更快：

Docker比VM有更少的抽象层：

13.docker的常用命令：

1）帮助命令：

docker version

docker info

docker 命令 --help

Reference documentation | Docker Documentation

镜像命令：`docker images` will show all top level images

docker images

docker images --help

[root@tangbo ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 5 months ago 13.3kB

镜像仓库源标签 ID 创建时间大小

可选项：

docker images -a

Options:
-a, --all Show all images (default hides intermediate images)
-q, --quiet Only show image IDs ##只显示镜像ID

搜索镜像：STARS收藏

docker search

docker search --help

docker search mysql --filter=STARS=3000 #搜索出来的就是STARS大于3000的镜像

Options:
-f, --filter filter Filter output based on conditions provided
--format string Pretty-print search using a Go template
--limit int Max number of search results (default 25)
--no-trunc Don't truncate output

[root@tangbo ~]# docker search mysql
NAME                             DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                            MySQL is a widely used, open-source relation…   12233     [OK]       
mariadb                          MariaDB Server is a high performing open sou…   4696      [OK]

下载镜像：docker pull mysql : 5.7

如果不写tags默认最新的

docker pull mysql

分层下载：docker images 的核心：联合文件系统

[root@tangbo ~]# docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete ### 分层下载：
93619dbc5b36: Pull complete
99da31dd6142: Pull complete
626033c43d70: Pull complete
37d5d7efb64e: Pull complete
ac563158d721: Pull complete
d2ba16033dad: Pull complete
688ba7d5c01a: Pull complete
00e060b6d11d: Pull complete
1c04857f594f: Pull complete
4d7cfa90e6ea: Pull complete
e0431212d27d: Pull complete
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 ###签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址

删除镜像：

docker rmi -f c20987f18b13

删除多个容器+空格+ID

递归删除镜像：

docker rmi -f ${docker images -aq}

镜像命令总结：

l列出镜像：docker images

搜索 docker search mysql

下载镜像 docker pull mysql

删除镜像：docker rmi ID

14>容器命令：有了镜像才能创建容器

1）有了镜像才能创建容器，新建容器并启动：

docker pull centos

2）查看镜像然后进入容器

docker images

启动：进入容器直接进到控制命令好操作 -it 才能进去否则进不去 /bin/bash

[root@tangbo ~]# docker run -it centos /bin/bash
[root@2dcc63853b8e /]#

docker run [可选参数] image

###参数说明

--name="Name" 容器名字tomcat01 tomcat02

-d 后台运行

-it 使用交互方式运行

-p 指定端口

-P 随机指定端口

3）t退出当前容器回到主机：exit

容器不停止退出：ctrl+P+Q

4）查看正在运行的容器：

docker ps

5）查看曾经运行过的容器n是自己查看最近的个数

docker ps -a n=3

docker ps -aq #显示当前所有容器的编号

docker ps -a

6)删除容器，镜像要i，容器不要i

删除指定容器：不能删除运行中的容器，加上 -f 强制删除运行中的容器

docker rm 容器ID

删除所有容器：

docker rm -f $(docker ps -aq)

或者

docker ps -a -q|xargs docker rm

启动和停止容器：

docker start 容器id #启动容器

docker restart 容器id #重启容器

docker stop 容器id #停止正在运行的容器

docker kill 容器id #强制停止当前容器

15》》常用其他命令
1)后台启动：docker run -d centos -----------常见的坑，会立刻自动关掉

2)查看日志命令：-t format时间戳

显示指定行数：docker logs -f -t --tail 10 f3c2dd853e36

全部显示：docker logs -f -t f3c2dd853e36

3)没有日志临时写个Shell脚本：

docker run -d centos /bin/bash -c "while true;do echo bobo;sleep 1;done"

4)docker ps查看当前运行的容器：然后在重新查看logs

docker logs -f -t --tail 10 f3c2dd853e36

5)查看容器中的进程信息：

docker top a2b6fb6853ec -a

6）查看镜像的元数据：很神奇：：会出现容器的所有信息

docker inspect a2b6fb6853ec

[root@tangbo /]# docker inspect a2b6fb6853ec
[
{
"Id": "a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e",
"Created": "2022-03-11T11:53:19.609846518Z",
"Path": "/bin/bash",
"Args": [
"-c",
"while true;do echo bobo;sleep 1;done"
],
"State": {
"Status": "running",
"Running": true,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
"Pid": 14463,
"ExitCode": 0,
"Error": "",
"StartedAt": "2022-03-11T11:53:19.907854058Z",
"FinishedAt": "0001-01-01T00:00:00Z"
},
"Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
"ResolvConfPath": "/var/lib/docker/containers/a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e/resolv.conf",
"HostnamePath": "/var/lib/docker/containers/a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e/hostname",
"HostsPath": "/var/lib/docker/containers/a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e/hosts",
"LogPath": "/var/lib/docker/containers/a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e/a2b6fb6853eca5d67185d7c1f92775ff98c29a46257a87688b0f83a104e31b3e-json.log",
"Name": "/modest_darwin",
"RestartCount": 0,
"Driver": "overlay2",
"Platform": "linux",
"MountLabel": "",
"ProcessLabel": "",
"AppArmorProfile": "",
"ExecIDs": null,
"HostConfig": {
"Binds": null,
"ContainerIDFile": "",
"LogConfig": {
"Type": "json-file",
"Config": {}
},
"NetworkMode": "default",
"PortBindings": {},
"RestartPolicy": {
"Name": "no",
"MaximumRetryCount": 0
},
"AutoRemove": false,
"VolumeDriver": "",
"VolumesFrom": null,
"CapAdd": null,
"CapDrop": null,
"CgroupnsMode": "host",
"Dns": [],
"DnsOptions": [],
"DnsSearch": [],
"ExtraHosts": null,
"GroupAdd": null,
"IpcMode": "private",
"Cgroup": "",
"Links": null,
"OomScoreAdj": 0,
"PidMode": "",
"Privileged": false,
"PublishAllPorts": false,
"ReadonlyRootfs": false,
"SecurityOpt": null,
"UTSMode": "",
"UsernsMode": "",
"ShmSize": 67108864,
"Runtime": "runc",
"ConsoleSize": [
0,
0
],
"Isolation": "",
"CpuShares": 0,
"Memory": 0,
"NanoCpus": 0,
"CgroupParent": "",
"BlkioWeight": 0,
"BlkioWeightDevice": [],
"BlkioDeviceReadBps": null,
"BlkioDeviceWriteBps": null,
"BlkioDeviceReadIOps": null,
"BlkioDeviceWriteIOps": null,
"CpuPeriod": 0,
"CpuQuota": 0,
"CpuRealtimePeriod": 0,
"CpuRealtimeRuntime": 0,
"CpusetCpus": "",
"CpusetMems": "",
"Devices": [],
"DeviceCgroupRules": null,
"DeviceRequests": null,
"KernelMemory": 0,
"KernelMemoryTCP": 0,
"MemoryReservation": 0,
"MemorySwap": 0,
"MemorySwappiness": null,
"OomKillDisable": false,
"PidsLimit": null,
"Ulimits": null,
"CpuCount": 0,
"CpuPercent": 0,
"IOMaximumIOps": 0,
"IOMaximumBandwidth": 0,
"MaskedPaths": [
"/proc/asound",
"/proc/acpi",
"/proc/kcore",
"/proc/keys",
"/proc/latency_stats",
"/proc/timer_list",
"/proc/timer_stats",
"/proc/sched_debug",
"/proc/scsi",
"/sys/firmware"
],
"ReadonlyPaths": [
"/proc/bus",
"/proc/fs",
"/proc/irq",
"/proc/sys",
"/proc/sysrq-trigger"
]
},
"GraphDriver": {
"Data": {
"LowerDir": "/var/lib/docker/overlay2/7d36375fa235ade7d70ae6b33b17f0de2aaff9c39e0a34e98f0740941fe860f7-init/diff:/var/lib/docker/overlay2/cbaaf8c3251850451f3263adc456fe9d228edbdf3b4f5b2a9ad7124004ab6e0b/diff",
"MergedDir": "/var/lib/docker/overlay2/7d36375fa235ade7d70ae6b33b17f0de2aaff9c39e0a34e98f0740941fe860f7/merged",
"UpperDir": "/var/lib/docker/overlay2/7d36375fa235ade7d70ae6b33b17f0de2aaff9c39e0a34e98f0740941fe860f7/diff",
"WorkDir": "/var/lib/docker/overlay2/7d36375fa235ade7d70ae6b33b17f0de2aaff9c39e0a34e98f0740941fe860f7/work"
},
"Name": "overlay2"
},
"Mounts": [],
"Config": {
"Hostname": "a2b6fb6853ec",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/bash",
"-c",
"while true;do echo bobo;sleep 1;done"
],
"Image": "centos",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": {
"org.label-schema.build-date": "20210915",
"org.label-schema.license": "GPLv2",
"org.label-schema.name": "CentOS Base Image",
"org.label-schema.schema-version": "1.0",
"org.label-schema.vendor": "CentOS"
}
},
"NetworkSettings": {
"Bridge": "",
"SandboxID": "fdf271b0c08adc09dcf7357aa12a28783d94ae7aa0c7d6f365d8b29f66aff6ff",
"HairpinMode": false,
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"Ports": {},
"SandboxKey": "/var/run/docker/netns/fdf271b0c08a",
"SecondaryIPAddresses": null,
"SecondaryIPv6Addresses": null,
"EndpointID": "005dc9a767dbe2f927c8267c853d2880d55931a30a4d7310296aa2a007ab3949",
"Gateway": "172.17.0.1",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"IPAddress": "172.17.0.2",
"IPPrefixLen": 16,
"IPv6Gateway": "",
"MacAddress": "02:42:ac:11:00:02",
"Networks": {
"bridge": {
"IPAMConfig": null,
"Links": null,
"Aliases": null,
"NetworkID": "221862c07b1057e61e140dd82618e41317c9ea1b1790b2c40d91b6b4c0881cdf",
"EndpointID": "005dc9a767dbe2f927c8267c853d2880d55931a30a4d7310296aa2a007ab3949",
"Gateway": "172.17.0.1",
"IPAddress": "172.17.0.2",
"IPPrefixLen": 16,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:11:00:02",
"DriverOpts": null
}
}
}
}
]

7）j进入后台运行的容器：打开新端口

docker exec -it 容器ID /bin/bash

方式二：进入正在运行的命令行而不是打开新端口

docker attach a2b6fb6853ec

8)从容器中拷贝文件到主机：

~~1进入容器内部，创建一个文件，并找到文件位置

~~2回到主机用docker cp拷贝文件格式如下

格式容器名：容器文件路径本地存放路径

docker cp c97ed819b202:/home/bobo.java /home

拷贝是一个手动过程，后期可以用数据卷自动连同

16练习》》配置nginx:

后台运行别名 |||宿主机端口，容器内端口镜像名

docker run -d --name nginx01 -p 3344:80 nginx

1)本机自测：

docker ps

curl localhost:3344

2）进入nginx:

docker exec -it nginx01 /bin/bash

17》》配置tomcat---------------------阿里云tomcat404问题解决

1）自动下载

docker run -d -p 3355:8080 --name tomcat01 tomcat

2）进入容器修改webapps

docker exec -it tomcat01 /bin/bash

发现linux命令少了，webapps没东西，阿里云默认是最小镜像

3）把webapps.dist里面的文件夹拷贝到webapps里面：

cp -r webapps.dist/* webapps

root@21d6cd94c26a:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

4）退出容器，再次访问：

exit

curl localhost:3355

17>>配置ES+Kibana-------------elastic

启动ES

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch

查看负荷状态：

docker stats

负载过大会自动关闭：

ES十分耗内存，1核2G肯定不够：

增加内存的限制----------修改配置文件----------限制占用内存大小

-e ES_JAVA_OPTS="Xms64m -Xmx512m"

docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="Xms64m -Xmx512m" elasticsearch

如果还是自动停止运行，是因为虚拟机内存太小了，需要加大内存或者重新分配：

curl localhost:9200

18>>部署可视化管理工具：portainer---------暂时先用这个:

新版是8000:8000

老版是8000:9000

docker run -d -p 8000:9000 -p 9443:9443 --name portainer \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:2.9.3

19》》Commit镜像：

实战测试：

1）启动1个默认的tomcat发现tomcat里面webapps没东西----------因为阿里云最小化镜像

2）自己拷贝基本文件webapps

3）提交自己的镜像---commit

作者描述mes 容器ID 自定义版本名称

docker commit -a="bobobobo" -m="bobo first add webapps" 01fa69209281 tomcat02:1.0

docker commit -a="bobobobo" -m="bobo first add webapps" 01fa69209281 tomcat02:1.0

后面可以发布给别人用：

到这里才算是入门DOCKER

后面还有：容器数据卷 -------DockerFile----------Docker网络

20》》容器数据卷：数据可以持久化---数据可以存储在本地

-----容器之间的数据共享技术：Docker容器中产生的数据可以同步到本地，容器删了数据在本地，不会丢失

-----------目录挂载-----同步机制

----------容器间也支持数据共享

1）方式1：本地直接使用命令-v来挂载：

-v路径映射本地路径：容器路径镜像名

docker run -it -v /home/ceshi:/home centos /bin/bash

docker run -it -v /home/ceshi:/home centos /bin/bash

本机会多一个文件夹出来：

新文件产生：挂载成功：

docker ps查看正在运行的容器：

docker ps

docker inspect 容器ID

显示挂载成功

1）退出容器，在本地修改文件内容

2）重启容器查看文件是否改变：

[root@tangbo ~]# docker start 173606da6668
173606da6668
[root@tangbo ~]# docker attch 173606da6668

没问题：

[root@tangbo ~]# docker start 173606da6668
173606da6668
[root@tangbo ~]# docker attch 173606da6668
docker: 'attch' is not a docker command.
See 'docker --help'
[root@tangbo ~]# docker attach 173606da6668
[root@173606da6668 /]# cd /home
[root@173606da6668 home]# ls
bobo.txt
[root@173606da6668 home]# cat bobo.txt 
woshi bobo
[root@173606da6668 home]#

21》》实战，安装Mysql,数据同步

mysql的数据持久化问题：

官方测试：

docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

1）完整启动mysql:可以多个文件挂载-----指定路径挂载常用

docker run -d  -p 3310:3306 -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

[root@tangbo ~]# docker run -d -p 3310:3306 -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

具名挂载指定路径挂载常用(具名挂载)

docker run -d -P --nginx01 -v /etc/nginx:/etc/nginx nginx

匿名挂载：也可以省略主机挂载路径：自动生成，我们一般不用

随机端口容器路径

docker run -d -P --nginx01 -v /etc/nginx nginx

查看所有的卷的情况：匿名卷挂载

docker volume ls

查看具名或者匿名路径：

docker volume inspect  卷名称

匿名卷的默认存储路径：

/var/lib/docker/volumes/juming-nginx/_data

查看是否连接成功：

2）用sqlyoung 连接尝试可以成功：

用工具创建文件；

进入mysql挂载文件夹可以看见：在docker容器也能看见

删除容器，本地数据不会丢失：实现数据持久化功能：

22》》初识DockerFile

1）创建一个dockerfile文件
2）文件的内容：

每个命令就是文件的一层

[root@tangbo home]# mkdir docker-tets-volume
[root@tangbo home]# ls
bobo.java  ceshi  docker-tets-volume  ecs-assist-user  mysql
[root@tangbo home]# cd docker-tets-volume/
[root@tangbo docker-tets-volume]# ls
[root@tangbo docker-tets-volume]# vim dockerfile01

FROM centos

#挂载券
VOLUME ["volume01","volume02"]

CMD echo "------end-------"
CMD /bin/bash

自己build一个镜像;

全路径自定义镜像名字

docker build -f /home/docker-tets-volume/dockerfile01 -t bobo/centos .

docker build -f /home/docker-tets-volume/dockerfile01 -t bobo/centos .

3）进入自己的做的镜像：

docker run -it 5d44b76d9a38 /bin/bash

自己写的数据卷目录自动挂载：

这个卷一定和外部有一个同步的目录，----------这是匿名挂载

查看卷挂载路径：

 docker inspect 0c380f2cea60

23》》数据卷容器----------多个容器间数据共享\

启动容器时挂载：

docker run -it -v /home/boboguazzai:/home/bobo/guazai --name bobocentos12 --volumes-from  bobocentos10  bobocentos

1）启动自己写的镜像，进入容器：

docker run -it --name docker01 bobo/centos

2）启动第二个镜像继承第一个镜像-----------挂载到父节点 docker02 --volumes-from docker01

数据共享只要还有一个容器在，数据就还在================备份机制==双向拷贝

容器名挂载继承docker01 镜像名字或ID

docker run -it --name docker02 --volumes-from docker01 bobo/centos

docker01就叫数据卷容器

docker run -it --name docker02 --volumes-from docker01 bobo/centos

后面可以无限挂载

 docker run -it --name docker03 --volumes-from docker01 bobo/centos

3）分别进入两个挂载文件夹查容器内文件是否挂载成功-----同时更新

显示挂载成功！！---------------同步更新

还可以多次挂载

4))尝试mysql数据同步：

docker run -d  -p 3311:3306 -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql

23>>dockerFile

构建步骤1）编写一个dockerfile文档

2）docker build构建成为镜像

3）docker run运行镜像

4）docker push发布镜像（Docker Hub 阿里云）

5）

基础知识：1）每个保留指令都必须是大写字母

2）顺序执行

3）#注释u 4)每个指令都会创建提交一个新的镜像层

dockerfile是面向开发的，这个文件十分简单

步骤：---开发-->>部署--->>运维

DockerFile:构建文件，定义操作步骤----源码

DockerImages:通过DockerFile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供的服务器

24)DockerFile指令

FROM #基础镜像，一切从这里构建 centos

MAINTAINER #主要维护者信息----姓名+email

RUN #docker镜像构建的时候需要运行的命令

ADD #步骤tomcat压缩包：添加内容

WORKDIR #镜像的工作目录

VOLUME #设置挂载容器卷------挂载目录

EXPOSE #暴露端口配置

CMD #指定这个容器运行的时候要运行的命令

ENERYPOINT #可以追加命令

ONBUILD #触发指令---了解即可

COPY #

ENV #设置环境变量

25》》用dockerfile构建自己的centos

官方文档：


FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]

自己写一个简单的centos： vim dockerfile

1）编写dockerfile文件

FROM centos

MAINTAINER bobo<15927561940@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "----------构建完毕----------"
CMD /bin/bash

2）构建文件镜像------docker build -f mydockerfile -t mycentos .点别忘了

docker build -f mydockerfile -t mycentos .

创建成功：看最后一行

查看自己的镜像文件：mycentos出现

[root@tangbo dockerfile]# docker images
REPOSITORY                               TAG       IMAGE ID       CREATED         SIZE
mycentos                                 latest    4099e14cf20c   2 minutes ago   231MB
bobo/centos                              latest    5d44b76d9a38   3 hours ago     231MB
tomcat02                                 1.0       9ae6ee0adbed   5 hours ago     684MB
nginx                                    latest    605c77e624dd   2 months ago    141MB
tomcat                                   latest    fb5657adc892   2 months ago    680MB
mysql                                    latest    3218b38490ce   2 months ago    516MB
portainer/portainer-ce                   latest    0df02179156a   3 months ago    273MB
cr.portainer.io/portainer/portainer-ce   2.9.3     ad0ecf974589   3 months ago    252MB
portainer/portainer-ce                   2.9.3     ad0ecf974589   3 months ago    252MB
hello-world                              latest    feb5d9fea6a5   5 months ago    13.3kB
centos                                   latest    5d0da3dc9764   5 months ago    231MB
elasticsearch                            latest    5acf0e8da90b   3 years ago     486MB

运行自己的centos：

docker run -it mycentos

查看镜像构建过程：可以查看官方镜像的构建过程

docker history 4099e14cf20c

26--》》构建自己的tomcat

1）文件准备：jdk压缩包和tomcat压缩包

2）创建Dockerfile文件：

vim Dockerfile


FROM centos

MAINTAINER tangbo<15927561940@.163com>


#                               解压路径
ADD jre-8u321-linux-i586.tar.gz /usr/local/
ADD apache-tomcat-10.0.17.tar.gz /usr/local/

RUN yum -y install vi

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jre1.8.0_21
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-10.0.17
ENV CATALINA_BASE /usr/local/apache-tomcat-10.0.17
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_BASE

EXPOSE 8080

CMD /usr/local/apache-tomcat-10.0.17/startup.sh && tail -F /url/local/apache-tomcat-10.0.17/bin/logs/catalina.out

3)构建镜像：别忘了点.号

docker build -t diytomcat .

2)创建自己的Dockeerfile02:

FROM centos

MAINTAINER BOBO<EMAIL>

ADD XXXXXXXXX.TAR.GZ
ADD XXXXXXXXXX.TAR.GZ

RUN YUM INSTALL VIM

RUM YUM INSTALL WGET

ENV MYPATH /USR/LOCAL
WORKDIR $MYPATH


ENVY JAVA_HOME /USR/LOCAL/JDK.XXX.21
ENV CLASS_PATH $JAVA_HOME/LIB/DT.JAR:$JAVA_HOME/LIB/TOOLS.JAR
ENV CATALINA_HOME USR/LOCAL/APACHE-TOMCAT-10.0.17
ENV CATALINA_BASE USR/LOCAL/APACHE-TOMCAT-10.0.17

EXPOSE 8080

CMD /USR/LOCAL/APPACHE-TOMCAT-10.0.17/STARTUP.SH && TAIL -F USR/LOCAL/APPAACHE-TOMCAT-10.0.17/
BIN/LOGS/CATALINA.OUT

docker build -t diytomcat .

27--》》发布镜像到GitHub

1)注册账号并登陆docker.com

2）在linux登陆docker：

----------也可以先输入用户名，点回车密码变成密文

docker login -u 159xxxxxxxx-p xxxxxxxxxxxx
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

3）你的密码会保存在本地！！！

WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.

4）push镜像到github

使用docker images查看images：上传的是这个，别传成容器了！！！

docker images

1`先要打标签 docker tag 镜像ID username/镜像名称

2`docker push username/mycentos

[root@tangbo ~]# docker tag 4099e14cf20c 15927561940/mycentos
[root@tangbo ~]# docker push 15927561940/mycentos
Using default tag: latest
The push refers to repository [docker.io/15927561940/mycentos]
74ddd0ec08fa: Pushing  11.51MB/231.3MB

28->>发布到阿里云：

1）登录到阿里云

2）找到容器镜像服务---个人实例---------》镜像仓库

3）阿里云登录 - 欢迎登录阿里云，安全稳定的云计算服务平台

4）创建命名空间

5）创建容器镜像

6）查看是上传步骤：阿里云登录 - 欢迎登录阿里云，安全稳定的云计算服务平台

29-->>移除所有镜像和容器

docker rm -f $(docker ps -aq)

docker rmi -f $(docker images -aq)

30--》》Docker0网络讲解：

1）清空所有环境

2)ip addr

3)启动tomcat开始测试测试网络

docker run -d -P --name tomcat01 tomcat

docker exec -it tomcat01 ifconfig

4）docker可以ping通容器内部

5）容器和容器间是可以ping通的evth-pair协议-----走路由器桥接

31--》》 --link通过服务名ping通----------老办法----单向---------不推荐使用

docker run -d -P --name tomcat03 --link tomcat02 tomcat

现在就能ping通了

doccker exec -it tomcat03 ping tomcat02

32--》》自定义网络-----------容器互联---------玩docker常用

1)查看所有网络

docker network ls

[root@tangbo ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
ec1b716a0374   bridge    bridge    local
711f0036a1ed   host      host      local
e997ff310b20   none      null      local

2）自己定义也使用桥接模式：创建自己的网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

创建成功，查看网络：

查看自己配置的网络详情：

docker network inspect mynet

[root@tangbo ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "5036bd94e81b02b04e591519e87f2dabea097a383c90387d688079fb08906afd",
        "Created": "2022-03-13T09:51:07.974701868+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]
[root@tangbo ~]#

尝试启用自己的网络：

[root@tangbo ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
442a79a469b5cf89556a625eaca55249b06396c3b653661c2109fc0f6f37d31c
[root@tangbo ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
9648d1b58b9ce2fabc906eca672f6234cc59bf88799713f10d4af307790c1877
[root@tangbo ~]#

再次查看网络配置详细信息：

docker inspect mynet

尝试ping命令：

docker exec -it tomcat-net-01 ping 192.168.0.3

通过ip和名字都可以ping通：

docker exec -it tomcat-net-01 ping tomcat-net-02

32--》》网络连通

docker network --help

docker network connect --help

测试打通tomcat01 -mynet

两个容器相互打通

docker network connect mynet tomcat01

打通了

一个容器两个ip地址

33-->>关于centos8停止维护

# 将所有 repo 中的文件都替换为 CentOS Steam 的源
sudo sed -i "s|\$releasever|8-stream|g"  /etc/yum.repos.d/CentOS-*.repo

# 更新源
yum makecache

自己写的Dockerfile解决容器centos没有vim等命令问题，解决centos8停止维护问题

FROM centos


MAINTAINER bobo<15927561940@163.com>

ENV MYPATH /usr/local

WORKDIR $MYPATH

RUN  sed -i "s|\$releasever|8-stream|g"  /etc/yum.repos.d/CentOS-*.repo

RUN yum makecache

RUN yum -y install vim
RUN yum -y install net-tools


EXPOSE 80
CMD echo$MYPATH
CMD echo"----okkkkkkkkk-------"

CMD /bin/bash

CentOS8 停止维护解决方案，手动升级为 CentOS Stream_JupiterXue的博客-CSDN博客_centos8停止维护

百度安全验证

Errors during downloading metadata for repository 'AppStream':
- Status code: 404 for https://repo.huaweicloud.com/centos/8/AppStream/x86_64/os/repodata/repomd.xml (IP: 61.172.237.151)
Error: Failed to download metadata for repo 'AppStream': Cannot download repomd.xml: Cannot download repodata/repomd.xml: All mirrors were tried

33-->>DockerCompose定义：

1）运行多个容器

2）yaml file配置文件

3）三个步骤：

Dockerfile保证项目在任何地地方可以运行

把服务卸载dockerfile.yaml中，方便运行-----------文件怎么写

docker-compose up命令的使用

作用：批量容器编排：根据配置文件自动启动依赖关系

1）Compose是官方的开源项目--------------需要安装！！！

2)在任何地方运行

依赖关系下载--------重要：

依赖启动顺序：重点

yaml类似格式：

version: "3.9"  # optional since v1.27.0
services:
  web:
    build: .
    ports:
      - "8000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

replicaes:副本数量

Compose的重要概念：

services:容器，应用

project：一组关联的容器

34-》》安装Compose：

Install Docker Compose | Docker Documentation

1)下载：

国内地址：

curl -L https://get.daocloud.io/docker/compose/releases/download/1.24.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

官网地址：

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

2）进入路径查看是否下载成功：

cd /usr/local/bin/
[root@tangbo bin]# ls
docker-compose
[root@tangbo bin]#

3）加运行权限：

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

查看是否安装成功：

4）版本出现就是安装成功：

[root@tangbo bin]# docker-compose version
docker-compose version 1.24.0, build 0aa59064
docker-py version: 3.7.2
CPython version: 3.6.8
OpenSSL version: OpenSSL 1.1.0j  20 Nov 2018
[root@tangbo bin]#

35--》》Compose体验

Get started with Docker Compose | Docker Documentation

1）创建文件夹：

 cd /home
 mkdir composetest
 cd composetest

2)创建一个app.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)

3）创建一个Dockerfile文件：

vim Dockerfile

# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.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
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

4)创建docker-compose.yml文件

vim docker-compose.yml

内容：

version: "3.9"
services:
  web:
    build: .
    ports:
      - "8000:5000"
  redis:
    image: "redis:alpine"

This Compose file defines two services: web and redis.

5）Step 5: Build and run your app with Compose

当前文件下启动 docker-compose up

docker-compose up

下载会比较慢

流程：

1·创建网络

2·打包执行 Docker-compose.yaml

3·启动了服务各种build---------根据文件自动生成服务_1的意思是副本数量，集群不可能只有一个实例运行，弹性，负载均衡

Starting composetest_web_1   ... done
Starting composetest_redis_1 ... done

Starting composetest_web_1 ... done
Starting composetest_redis_1 ... done

· 4· 大概成功的样子：

docker ps

5· 本地访问应用端口：

[root@bobo ~]# curl localhost:8000
Hello World! I have been seen 1 times.

查看镜像：自动构建了：

6·网络规则：项目中的内容都在同一个网络下面----可以通过域名访问

mysql:3306----------可以一下连接十个mysql

7`你也inspect查看网络：

docker network inspect composetest_default

证明都在一个容器里面：

36-》》YAML的编写规则

Compose file version 3 reference | Docker Documentation

理解为3层：

version: "3.9"
services:
  webapp:
    build: ./dir

version: "3.9" #版本
services: #服务

服务1：web

服务配置：

images

build

network

服务2：redis

服务配置：

.......

服务3：redis
webapp: #
build: ./dir

37-->>部署word_press博客

Quickstart: Compose and WordPress | Docker Documentation

1)创建一个工作目录并进入

 cd my_wordpress/

2）创建yaml文件：

vim docker-compose.yml

内容为：

version: "3.9"
    
services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    
  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}

3）

运行成功：

docker-compose up

4）公网访问：WordPress › Installation

WordPress › Installationhttp://39.105.26.24:8000/访问成功：

5)后台启动

docker-compose up  -d

38->>阿里云购买四台服务器，然后安装docker：

1）安装gcc

 yum -y install gcc

2)回到开头傻瓜式安装

39--》》Swarm集群搭建：

Swarm mode overview | Docker Documentation

How nodes work | Docker Documentation

1）搭建集群：

docker swarm --help

2）

 docker swarm init --help

3）私网不要钱，走私网

！！！如果使用yum install docker 安装的docker 这里可能会报错！！！

解决方法：卸载docker重新装，别用yum install docker，用文章开头的用法

docker swarm init --advertise-addr 172.23.6.46

ip addr

4）把2，3，4服务器加入到swarm 1做管理者

自己使用上图第二条命令：

docker swarm join --token SWMTKN-1-6bdq65cec8zrkwmad469hh9tmsitpd7f3ysmc7hwwlgkvwu3w3-0hmjcybpcv2tkj4rkrxa538ks 172.23.6.46:2377

也可以运行 docker swarm join-token manager 生成主节点的token令牌，复制到别的节点中，

如果2,3,4，要设置成主节点的话，用leader生成token令牌，放到4里面

leader做的：

 docker swarm join-token manager

docker swarm join-token manager

复制到docker4的：

docker swarm join --token SWMTKN-1-6bdq65cec8zrkwmad469hh9tmsitpd7f3ysmc7hwwlgkvwu3w3-8bbwxq0hwxbrf3tkytczxswje 172.23.6.46:2377

docker swarm join --token SWMTKN-1-6bdq65cec8zrkwmad469hh9tmsitpd7f3ysmc7hwwlgkvwu3w3-0hmjcybpcv2tkj4rkrxa538ks 172.23.6.46:2377

5)在主节点运行：MANAGER空白代表worker节点

只有管理员才能运行：docker node ls命令

docker node ls

40--》》Raft协议，一致性算法：

保证大多数节点存活才可用：>1，，，集群>3，设置成高可用，停了一个也还能用

如果是两主两从，挂了一个就不能用了

设置三个管理节点，尝试断掉一个

1）设置三个管理节点

docker swarm init --advertise-addr 172.23.6.46

2）尝试断掉一个主节点：

systemctl stop docker

3）关于关掉服务器Warning:这是顶层设计，在socket保留，你尝试参看，自动恢复，体会舍弃的妙处：

Warning: Stopping docker.service, but it can still be activated by: docker.socket_qq_42533216的博客-CSDN博客

Warning: Stopping docker.service, but it can still be activated by: docker.socket

4）如果强制停掉了，也是高可用，除非在停一个，只有一个主节点存活，变成主节点和worker一样，就死了，无法使用 >1台管理节点存活过半主节点存活

41--》》动态扩缩容：滚动更新

服务docker service，以前是docker run

docker service create -p 8888:80 --name my-nginx nginx

1）docker run -------------容器启动，不具备扩缩容

2）docker service ---------服务启动，具有扩缩容功能---------滚动更新

3）查看启动的服务：

docker service ps my-nginx

4）查看所有服务

docker service ls

REPLICAS 1/1 代表只存在一个节点上

5）参看服务所有信息：

docker service inspect my-nginx

6）去所有节点输入 docker ps

奇妙的事情发生了，我在docker1启动的service，出现在了docker3！！！！！！！！！是随机的

7）动态扩缩容来了：

在docker1上启动多个service：

动态扩大或者缩小，改变数值就行。

docker service update --replicas 4 my-nginx

或者scale命令，效果一样：

docker service scale my-nginx=10

所有的服务器上 docker ps 查看

docker ps

会发现随机分布到处都有，随机分布

8）尝试公网访问：Welcome to nginx!

无论哪个ip都能访问

这就是集群！！！！！！！！！！！！！！！！！！！！！！！！！

Welcome to nginx!http://47.104.10.18:8888/

9)移除服务：

docker service rm my-nginx

10)查看：

docker service ls

DockerSwarm搭建集群到此OKKKKKKK

只要会搭建集群，启动服务，动态管理容器

42--》》动态扩缩容流程总结：

1）创建swarm环境，设置主从节点---------------部署服务器集群

2）通过docker service 启动容器

3）动态扩缩容

4）docker ps查看容器是否启动成功

5）外网尝试访问

波波爱下班

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
docker尝试和Swarm集群搭建

查看linux环境和系统[root@tangbo /]# uname -r5.10.60-9.al8.x86_64[root@tangbo /]# cat /etc/os-release NAME="Alibaba Cloud Linux"VERSION="3 (Soaring Falcon)"ID="alinux"ID_LIKE="rhel fedora centos"VERSION_ID="3"PLATFORM_ID="platform:al8"PRETTY_NAME="
复制链接

扫一扫