docker学习教程
0.导语
如果觉得有用，请点个推荐吧，您的推荐！捐赠！关注！是俺更新下去的动力！
1.docker安装
1.1安装docker（乌班图）-需要su权限
帮助文档：
1.卸载旧的
apt-get remove docker docker-engine docker.io containerd runc
2.设置存储库
sudo apt-get update
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
3.添加 Docker 的官方 GPG 密钥：
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
4.用以下命令设置存储库：
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
1.1安装docker（centos7）-需要su权限
yum install -y yum-utils \
device-mapper-persistent-data \
lvm2
yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4.安装docker相关
ce是社区，ee是企业
apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
5启动docker 验证 Docker 引擎是否已正确安装。
docker run hello-world
6查看版本
docker version
显示
Client: Docker Engine - Community
Version: 20.10.17
API version: 1.41
Go version: go1.17.11
Git commit: 100c701
Built: Mon Jun 6 23:02:57 2022
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
Engine:
Version: 20.10.17
API version: 1.41 (minimum version 1.12)
Go version: go1.17.11
Git commit: a89b842
Built: Mon Jun 6 23:01:03 2022
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.6.6
GitCommit: 10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
runc:
Version: 1.1.2
GitCommit: v1.1.2-0-ga916309
docker-init:
Version: 0.19.0
GitCommit: de40ad0
8.查看image
docker images
9.修改默认的拉取镜像地址
/etc/docker/daemon.json
9.卸载docker的时候用
apt-get purge docker-ce docker-ce-cli containerd.io docker-compose-plugin
主机上的映像、容器、卷或自定义配置文件不会自动删除。要删除所有映像、容器和卷：
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd
如果当你程序出现了这个报错
Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/json": dial unix /var/run/docker.sock: connect: permission denied
一定是当前的登录账号没有root权限导致的。
sudo -i 输入当前账号密码后就有root权限
1.2阿里云镜像加速
1.登录阿里云
2.直接搜索：镜像容器服务，点击进入控制台->镜像工具->镜像加速器
使用加速器可以提升获取Docker官方镜像的速度
| 加速器地址 |
|---|
| https://cgys1rlc.mirror.aliyuncs.com |
针对Docker客户端版本大于 1.10.0 的用户
您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://cgys1rlc.mirror.aliyuncs.com"]
}
sudo systemctl daemon-reload
sudo systemctl restart docker
2.docker常用命令
2.1帮助命令
docker version #显示版本信息
docker info #显示更详细信息
docker --help #帮助信息
帮助文档地址：
2.2镜像命令：
2.2.1docker images #查看所有镜像
docker images --help
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 8 months ago 13.3kB
#解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的id
CREATED 镜像的创建时间
SIZE 镜像的大小
2.2.2docker search #搜索镜像
docker search mysql #搜索mysql
docker search mysql --filter=STARS=3000 #搜索出来的大于等于3000
2.2.3docker pull #下载镜像
docker pull mysql #下载mysql
docker pull 镜像名[:tag]如果不写是默认latest
采用分层下载，联合文件系统，还有签名 ，docker.io是真实地址
docker pull mysql==docker pull docker.io/library/mysql:latest
2.2.4docker images#查看镜像
2.2.5docker rmi #删除镜像
docker rmi-f 删除制定的镜像
docker rmi -f id id 删除多个镜像
docker rmi-f $(docker images -aq) 递归删除全部镜像
2.3容器命令
2.3.1启动并进入容器内部
docker run -it centos /bin/bash
2.3.2 docker run [跟的常用命令]
--name 给容器的别名
-P 随机外部端口映射容器内部端口
-p 指定端口 比如: -p 5000:5000
-d 容器后台运行
2.3.3 退回主机
exit #容器停止退出
ctrl+p+q#不停止退出
2.3.4 列出所有运行中的容器
docker ps
2.3.5 查看运行过的容器
docker -ps -a
2.3.6 docker 容器运行的状态
容器状态有7种：
created（已创建）
restarting（重启中）
running（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）
2.3.7 删除容器
docker rm 容器id #删除制定的容器 ，如果删除正在运行的容器 -f
docker rm -f $(docker ps -aq) #删除所有容器
docker ps -a -q|xargs docker rm #删除所有容器
2.4其他命令
创建容器，但是不会立即运行
docker create --name nginx nginx
2.4.1启动和停止容器
docker start 容器id #启动容器
docker restart 容器id #重启容器
docker stop 容器id #停止当前容器
docker kill 容器id #强制停止容器
2.4.2 后台启动容器
docker run -d -it 镜像名
2.4.3查看日志
docker logs -f -t 容器id
docker logs -t -f --tail 20 容器id查看20条
写一段脚本
while true;do echo kuangshen;sleep 1;done
2.4.4 查看容器进程信息
docker top 容器id
UID PID PPID C STIME TTY TIME CMD
root 18275 18256 0 15:17 ? 00:00:00 /bin/sh -c while true;do echo kuangshen;sleep 1;done
root 20274 18275 0 15:31 ? 00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
2.4.5 查看镜像元数据
docker inspect 容器id
返回的数据
[
{
"Id": "345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d",
"Created": "2022-06-17T07:17:00.304042239Z",
"Path": "/bin/sh",
"Args": [
"-c",
"while true;do echo kuangshen;sleep 1;done"
],
"State": {
"Status": "running",
"Running": true,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
"Pid": 18275,
"ExitCode": 0,
"Error": "",
"StartedAt": "2022-06-17T07:17:00.902769488Z",
"FinishedAt": "0001-01-01T00:00:00Z"
},
"Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
"ResolvConfPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/resolv.conf",
"HostnamePath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/hostname",
"HostsPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/hosts",
"LogPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d-json.log",
"Name": "/vigilant_panini",
"RestartCount": 0,
"Driver": "overlay2",
"Platform": "linux",
"MountLabel": "",
"ProcessLabel": "",
"AppArmorProfile": "docker-default",
"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/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473-init/diff:/var/lib/docker/overlay2/fcb5c270854d34709d71337480437be0e69003ebca9daf39fd1796c293b88d2d/diff",
"MergedDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/merged",
"UpperDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/diff",
"WorkDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/work"
},
"Name": "overlay2"
},
"Mounts": [],
"Config": {
"Hostname": "345af6e6f41f",
"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/sh",
"-c",
"while true;do echo kuangshen;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": "dae4f55d59e869c39417f01d08885567f026c3682c52ef279a2d544fb30e5b63",
"HairpinMode": false,
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"Ports": {},
"SandboxKey": "/var/run/docker/netns/dae4f55d59e8",
"SecondaryIPAddresses": null,
"SecondaryIPv6Addresses": null,
"EndpointID": "90bf5aedb85730b19d7cfd87f940180253850909f80bd464ca857179becad8ef",
"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": "1e8be48fc967fe40643b0e7ab45fd195182b044fc7e654375cb49dba6af35861",
"EndpointID": "90bf5aedb85730b19d7cfd87f940180253850909f80bd464ca857179becad8ef",
"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
}
}
}
}
]
2.4.6进入容器
docker exec -it 容器id/bin/bash ##进入容器打开新终端
docker attach 容器id #进入容器在原来的终端，可以看到之前的代码
2.4.7 从容器内拷贝文件到主机上
docker cp 容器id：容器内路径 目的主机路径
2.5提交一个自己的镜像
docker commit 提交容器成为一个新副本
docker commit -m "内容" -a "作者" 容器id 目标镜像名:[tag]
比如我写好了一个centos7带java7，包括了所有基本命令的。目标镜像名全局小写
docker commit order_3 centos_jdk_development_tools:7
2.5.1 导出镜像
docker save -o <output_file.tar> <image_name>
docker save -o centos_jdk_development_tools.tar centos_jdk_development_tools:7
就会在你所在目录下导出一个tar的文件。
2.5.2镜像导入
docker load -i <input_file.tar>
docker load -i centos_jdk_development_tools.tar
3.数据卷
防止容器删除后数据丢失，有了数据卷可以保存到电脑，将容器目录挂载到linux上面
-v 挂载
docker run -it -v 主机目录:容器内目录
挂载完成之后：
Mounts里就会绑定两者的关系
source 主机内地址
destination docker容器内的地址
容器内添加可以添加到外部，属于双向绑定了是
3.1具名挂载和匿名挂载
不指定主机名 直接是容器内的目录： docker run -d -P --name nginx01 -v /ect/nginx nginx
所有不指定宁docker容器内的卷，在没有指定 /var/lib/docker/volumes/xxx/_data
区分具名匿名
-v 容器内路径 是匿名挂载
-v 卷名：容器内路径 具名挂载
-v /宿主机器路径::容器内路径 指定路径挂载
3.2扩展
通过 -v 容器内路径：ro rw 改变读写权限
ro 只读
rw 可读可写
一旦设置了这个容器权限 只能通过宿主机来操作，容器内部无法操作的 ,ro说明只能通过宿主机来操作，容器内部无法操作
docker run -d -p --name nginx01 -v juming-nginx:/etc/nginx:rw nginx
docker run -d -p --name nginx01 -v juming-nginx:/etc/nginx:ro nginx
3.3docker设置容器内内存
--memory=16g 就是给centos7配置了16g的使用内存
docker run -it --memory=16g --name order_2 centos:7 bash
4.dockerfile
1编写镜像文件dockerfile1
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "--------end------------"
CMD /bin/bash
-
执行docker命令执行文件注意上全路径，结尾有个空格点
docker build -f /home/player3/文档/dockerfile1.Dockerfile -t player3/centos .
3.启动容器
docker run -it player3/centos /bin/bash
4.查看文件
[root@d6bb2b70632d /]# ls
bin etc lib lost+found mnt proc run srv tmp var volume02
dev home lib64 media opt root sbin sys usr volume01
我们生成的目录自动挂载的
5.在容器内创建一个目录，查看容器里是否有，查看匿名挂载路径
docker inspect d6bb2b70632d
"Mounts": [
{
"Type": "volume",
"Name": "d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0",
"Source": "/var/lib/docker/volumes/d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0/_data",
"Destination": "volume01",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
},
{
"Type": "volume",
"Name": "438fcc6181fde2565c4e8c995a3a1aa7973cc91fa345c2b396415f4453e3f8a9",
"Source": "/var/lib/docker/volumes/438fcc6181fde2565c4e8c995a3a1aa7973cc91fa345c2b396415f4453e3f8a9/_data",
"Destination": "volume02",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
6进入本地目录看是否出现,本地电脑添加一个都有
root@player3-TM1613:/var/lib/docker/volumes/d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0/_data# ls
demo01.txt
7.测试删除容器，发现这个本地挂载的数据还在
可以实现什么，比如多个mysql同步数据？
4.1实战：两个mysql进行数据同步
volumes-form 容器名，将容器数据卷挂载到其他的数据卷上，属于继承了上一层的数据卷，多个数据卷的数据相互复制，删除掉源头docker并不会对现有文件造成影响
docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
docker run -d -p 3311:3307 -v /etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7 --volumes-form mysql01
结论：容器之间的生命周期，一直到所有容器都没有使用为止，本地数据卷的数据是不会删除的。
4.2编写docker的具体步骤
1.编写dockerfile文件，文件首字母大写
2.dockerbuild 构件成一个镜像
3.docker run 运行镜像
4.docker push 发布镜像 （ducherhub，阿里云镜像仓库）
4.3dockerfile构建过程
dockerFile:构建文件，定义了一切的步骤，源代码
dockerimages:通过dockerfile构建生成的镜像，最终发布和运行的产品，原来是jar，war。
docker容器：容器就是镜像运行起来提供服务器
基础知识：
1.每个保留关键字（指令）都是必须大写的
2.执行从上到下顺序执行
3。#表示注释
4.每个指令都会创建提交一个新的镜像层
4.4 dockerfile常见命令
FROM 指定基本镜像，一切镜像从这里开始
MAINTAINER 负责人，一般姓名+邮箱
RUN 构建镜像的时候需要运行的命令
ADD 步骤，tomcat镜像的化tomcat的压缩包，添加内容
WORKDIR 镜像的工作目录
VOLUME 挂载的目录
EXPOSE 对外暴露的端口
CMD 命令行操作
ENTRYPOINT 指定容器启动的时候要运行的命令，可以追加命令
ONBUILD 当构建一个被继承dockerfile 这个时候就会运行ONBUILD的指令，触发指令
COPY 类似add，将文件拷贝到镜像中
ENV 设置构建的环境变量
4.5 实战： 构建一个自己的centos镜像
1.构建一个自己的centos镜像
mycentos.Dockerfile
FROM centos
MAINTAINER kuangshen<24736743@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo A$MYPATH
CMD /bin/bash
2.build
docker build -f /home/player3/文档/mycentos.Dockerfile -t player3/mycentos .
3.运行 docker run -it dsoadihaso /bin/bash
查看镜像的构建过程 docker history odsakdlkasjdl
4.6 cnd和entrypoint区别
cmd 指定这个容器启动要运行的命令，之后最后一个会生效，可以被替代
entrypoint 指定这个容器启动要运行的命令，可以追加命令
cmd的file
FROM centos
CMD ['ls',"-a"]
docker build -f xxx -t cmdtest .
docker run aa1111
会自动将最后的cmd命令执行，如果想追加命令不能在后面直接加应该这样写
docker run aa1111 ls-al
entrypoint的file
FROM centos
ENTRYPOINT ['ls',"-a"]
docker build -f xxx -t entrypointtest .
docker run aa1111
会自动将最后的cmd命令执行，如果想追加命令可以直接填上后面
docker run aa1111 l
4.7 实战：tomcat镜像（待补充）
4.8 布自己的镜像
ducokerhub
1.地址：https://hub.docker.com 注册自己的账号
2.确定账号可以正常登录
3.在服务器上提交我们的镜像
dockerlogin --help
-u -p
用户名，密码
4登录之后可以提交镜像，docker push
本地提交到远程尽量带上版本信息和tag
docker tag 5d0da3dc9764 player3/centos:0.0.1
docker push player3/centos:0.0.1
发布到阿里云
1.登录到阿里云
2.找到容器镜像服务
3.找到镜像仓库
4.创建命名空间
5。创建镜像仓库
6其他参考官方文档
5.docker网络
5.1 docker0
ip addr
第一个是回环地址，第二个是内网地址，第三个是docker地址
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: wlp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether a0:c5:89:32:9c:d1 brd ff:ff:ff:ff:ff:ff
inet 192.168.10.109/24 brd 192.168.10.255 scope global dynamic noprefixroute wlp2s0
valid_lft 6054sec preferred_lft 6054sec
inet6 fe80::8d0a:e31a:72d0:f111/64 scope link noprefixroute
valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
link/ether 02:42:83:6a:8a:86 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
valid_lft forever preferred_lft forever
docker是如何处理网络问题
docker 可以ping通容器内部
正常电脑本机192.168.0.1 路由器地址，手机连接WiFi了，192.168.0.2，可以相互ping 可以相互ping通。
原理
1.我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只需要安装docker就会有一个网卡docker0
使用桥接模式，使用的技术是evth-pair 技术（虚拟设备接口）。
启动容器后出现的网卡是成对出现的，一端连着协议，一端彼此相连。
2.不同容器之间可以ping通的
docker exec -it tomcat2 ping xxx
3.结论，tomcat1和tomcat是公用一个路由，docker0，所有容器不指定网络的情况下，都是使用docker0路由的，docker会给我们的容器分配一个默认的可用ip
4.docker中所有的网络接口都是虚拟的，虚拟转发效率高（内网传递文件）
只要容器删除，对应的网桥一对就没了
5.2 –link
场景：编写了一个微服务，database.rul=ip;; 项目不重启，ip换掉了，希望处理这个问题，可以名字来访问容器.
想通过服务去ping tomcat02能ping通吗？
docker exec -it tomcat02 ping tomcat01
ping不通
启动tomcat03
docker run -d -P --name tomcat3 --link tomcat02 tomcat01
通过—link就解决了这个问题，反向是不可以ping通的
当我们配置容器的时候不配置ip会给容器配置默认ip，我们可以通过docker inspect去看
docker exec -it tomcat03 cat /etc/hosts
通过查看tomcat03的docker host ，增加了tomcat02，tomcat01的本地映射
现在玩docker的时候已经不建议使用–link了，自定义网络，不适用docker0，docker0的问题，不支持容器名连接访问
5.3 docker network
docker network ls 查看所有的温昂罗
docker network rm id 删除某个网络
docker network create my-network 创建一个网络为 my-network
网络模式
bridge:桥接，默认
none:不配置网络
host:和宿主机共享网络
container：容器网络连接(用的少，局限很大)
测试
docker run -d -p --name tomcat01 tomcat
docker run -d -p --name tomcat01 tomcat --net bridge tomcat 上面的默认执行了这个
docker0特点；默认，域名不能访问，--link可以打通连接
我们可以自定一个网络
--driver bridge 模式
--subnet 192.168.0.0/16 多少个子网
--gateway 192.168.0.1 +网关路由
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
root@player3-TM1613:/home/player3# docker network ls
NETWORK ID NAME DRIVER SCOPE
430c633bd795 bridge bridge local
a288f78f519b host host local
74783c519ad2 mynet bridge local
7d3b1deefd46 none null local
docker run -d -P --name tomcat01 --net mynet tomcat
当你不适用–link也可以ping通名字 了
好处：不同的集群使用不同的网络，集群是安全和健康的
我们都知道网段不同是无法ping通的，如何打通docker0和自定义网络呢？
docker network connect 可以打通网络
docker network connect mynet tomcat01
联通之后就是将tomcat01放到了mynet网络下，一个容器两个ip
5.3.1 实战 搭建redis集群
1.创建网卡
docker network create redis --subnet 192.168.0.0/16
2.查看服务
docker network ls
docker network inspect redis
3.创建6个redis服务
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF > /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
Cluster-enabled yes
Cluster-config-file nodes.conf
Cluster-node-timeout 5000
Cluster-announce-ip 192.168.0.1${port}
Cluster-announce-port 6379
Cluster-announce-bus-port 16379
appendonly yes
EOF
done
4.启动redis（6个）
node-1
docker run -p 6379:6379 -p 16379:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
node-2
docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
node-3
docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
node-4
docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
node-5
docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
node-6
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
redis中没有bash只有 sh
5.进入其中一个容器
docker exec -it redis-1 /bin/sh
6执行集群命令
redis-cli --cluster create 192.168.0.11:6379 192.168.0.12:6379 192.168.0.13:6379 192.168.0.14:6379 192.168.0.15:6379 192.168.0.16:6379 --cluster-replicas 1
输入yes
7.连接集群
redis-cli -c
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:209
cluster_stats_messages_pong_sent:229
cluster_stats_messages_sent:438
cluster_stats_messages_ping_received:224
cluster_stats_messages_pong_received:209
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:438
8.设置值
set a b
get a
可以正常获取
9.查看主从节点，13的从是14
192.168.0.13:6379> cluster nodes
dda9df6e38727c5ad0667278cb77f96d91973f65 192.168.0.15:6379@16379 slave f6dc83295bb2d7e9a0436fff935dbd6e441ef8cf 0 1655738988807 5 connected
cf8b3f0cc101c2bce9f57d10349676a37ed0538c 192.168.0.14:6379@16379 slave 2c1949dcb59bff7a4cb49b0af04d15978987daaa 0 1655738988507 4 connected
2c1949dcb59bff7a4cb49b0af04d15978987daaa 192.168.0.13:6379@16379 myself,master - 0 1655738986000 3 connected 10923-16383
86ad41983210bdd6fd8c723851820852e57f2c0d 192.168.0.12:6379@16379 master - 0 1655738988306 2 connected 5461-10922
1e1386760e3421384022567658601b9dcae3ef02 192.168.0.16:6379@16379 slave 86ad41983210bdd6fd8c723851820852e57f2c0d 0 1655738988000 6 connected
f6dc83295bb2d7e9a0436fff935dbd6e441ef8cf 192.168.0.11:6379@16379 master - 0 1655738987000 1 connected 0-5460
10.停止docker的node-3节点
docker stop node-3
11.重新获取，发现卡顿，ctrl+c结束后，重新登录，发现从节点已经切换成功
-> Redirected to slot [15495] located at 192.168.0.14:6379
"b"
192.
5.4 将springboot打包成docker镜像
1.构建springboot项目
正常编写web项目并且测试
1.1下载dockerfile插件
2.打包应用
3.编写dockerfile
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
4.构建镜像
将dockerfile+jar包上传到服务器
docker build -t kuangshen666 .
5发布运行
docker run -d -p 8080:8080 --name kunagshen-springboot-web kuangshen666
6.命令小结
attach 当前shell下attach连接制定运行镜像
build 通过dockerfile定制镜像
commit 提交当前容器为新的镜像
cp 从容器拷贝制定文件或者目录到宿主机
create 创建一个新的容器，不启动
diff 查看容器变化
events 从服务获取容器实时时间
exec 在已存在的容器上运行命令
export 导出容器的内容流作为一个tar归档文件对应import
history 展示一个镜像形成历史
images 列出系统当前镜像
import 从tar包中的内容创建一个新的文件系统镜像
info 显示系统的相关信息
inspect 查看容器详细信息
kill kill掉制定容器
load 从一个tar包加载一个镜像[对应一个save]
login 注册或登录一个docker服务器源
logout 从当前原服务器退出
logs 输出当前服务器日志
port 查看映射端口对应的容器源端
pause 暂停容器
ps 列出容器列表
pull 从docker源拉取镜像
push 推送到制定镜像或者docker源
restart 重启运行中的镜像
rm一处一个或多个容器
rmi 移除镜像
run 创建一个容器并运行
save 保存一个镜像为tar包[对应load]
search 在dockerhub搜镜像
start 启动镜像
stop 停止镜像
tag 给源镜像打标签
top 看容器运行进程
unpause 取消暂停容器
version 查看docker版本
wait 截取容器停止时的退出状态值
status 查看docker 状态
7.实战
docker -centos
/usr/sbin/init启动容器之后可以使用systemctl方法
--privileged=true获取宿主机root权限（特殊权限-）
sudo docker run -d --name c7-d1 --privileged=true -p 10022:22 centos:7 /usr/sbin/init
docker-nginx
1.搜索镜像
2.下载镜像
3.启动镜像
4。运行测试:docker run -d --name nginx01 -p 3344:80 nginx
docker -tomcat（待补充）
es+kibana
es需要挂载
es需要内存
es需要暴露多端口
可视化工具
portainer(先用这个)
docker图形化管理工具
Rancher(ci/cd再用)
docker pull portainer/portainer
mkdir -p /usr/local/docker/portainer/data
docker run -p 9000:9000 -p 8000:8000 --name portainer \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /docker/portainer/data:/data \
-d portainer/portainer
第一次登录的时候需要创建管理员账号，访问地址：http://localhost:9000/
之后我们选择连接到本地的Docker环境，连接完成后我们就可以愉快地使用Portainer进行可视化管理了！
登录成功后，可以发现有一个本地的Docker环境；
打开Dashboard菜单可以看到Docker环境的概览信息，比如运行了几个容器，有多少个镜像等；
打开App Templates菜单可以看到很多创建容器的模板，通过模板设置下即可轻松创建容器，支持的应用还是挺多的；
打开Containers菜单，可以看到当前创建的容器，我们可以对容器进行运行、暂停、删除等操作；
选择一个容器，点击Logs按钮，可以直接查看容器运行日志，可以和docker logs命令说再见了；
点击Inspect按钮，可以查看容器信息，比如看看容器运行的IP地址；
点击Stats按钮，可以查看容器的内存、CPU及网络的使用情况，性能分析不愁了；
点击Console按钮，可以进入到容器中去执行命令，比如我们可以进入到MySQL容器中去执行登录命令；
打开Images菜单，我们可以查看所有的本地镜像，对镜像进行管理；
打开Networks菜单，可以查看Docker环境中的网络情况；
打开Users菜单，我们可以创建Portainer的用户，并给他们赋予相应的角色；
打开Registries菜单，我们可以配置自己的镜像仓库，这样在拉取镜像的时候，就可以选择从自己的镜像仓库拉取了。
docker 安装5.7版本的mysql
docker pull mysql:5.7
运行并且挂载配置文件以及和其他通讯问题 ,
mkdir -p /usr/local/docker/mysql/conf
mkdir -p /usr/local/docker/mysql/logs
mkdir -p /usr/local/docker/mysql/data
docker run -p 3306:3306 --name mysql \
-v /usr/local/docker/mysql/conf:/etc/mysql/conf.d \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--restart=always \
-d mysql:5.7
查看安装后的mysql最大连接数
show variables like '%max_connections%';
没找到 my.cnf文件，也就没法添加
# 增加 max_connections=1000 配置
docker -nacos
docker pull nacos/nacos-server:v2.0.3
docker run -d \
--name nacos \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.10.106 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=123456 \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
--restart=always \
nacos/nacos-server:v2.0.3
sql文件 nacos_config
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info */
/******************************************/
CREATE TABLE `config_info` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(255) DEFAULT NULL,
`content` longtext NOT NULL COMMENT 'content',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(20) DEFAULT NULL COMMENT 'source ip',
`app_name` varchar(128) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
`c_desc` varchar(256) DEFAULT NULL,
`c_use` varchar(64) DEFAULT NULL,
`effect` varchar(64) DEFAULT NULL,
`type` varchar(64) DEFAULT NULL,
`c_schema` text,
`encrypted_data_key` text NOT NULL COMMENT '秘钥',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_aggr */
/******************************************/
CREATE TABLE `config_info_aggr` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(255) NOT NULL COMMENT 'group_id',
`datum_id` varchar(255) NOT NULL COMMENT 'datum_id',
`content` longtext NOT NULL COMMENT '内容',
`gmt_modified` datetime NOT NULL COMMENT '修改时间',
`app_name` varchar(128) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='增加租户字段';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_beta */
/******************************************/
CREATE TABLE `config_info_beta` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL COMMENT 'content',
`beta_ips` varchar(1024) DEFAULT NULL COMMENT 'betaIps',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(20) DEFAULT NULL COMMENT 'source ip',
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
`encrypted_data_key` text NOT NULL COMMENT '秘钥',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_tag */
/******************************************/
CREATE TABLE `config_info_tag` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
`tag_id` varchar(128) NOT NULL COMMENT 'tag_id',
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL COMMENT 'content',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(20) DEFAULT NULL COMMENT 'source ip',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_tags_relation */
/******************************************/
CREATE TABLE `config_tags_relation` (
`id` bigint(20) NOT NULL COMMENT 'id',
`tag_name` varchar(128) NOT NULL COMMENT 'tag_name',
`tag_type` varchar(64) DEFAULT NULL COMMENT 'tag_type',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
`nid` bigint(20) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`nid`),
UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),
KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = group_capacity */
/******************************************/
CREATE TABLE `group_capacity` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`group_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Group ID，空字符表示整个集群',
`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数，，0表示使用默认值',
`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_group_id` (`group_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='集群、各Group容量信息表';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = his_config_info */
/******************************************/
CREATE TABLE `his_config_info` (
`id` bigint(64) unsigned NOT NULL,
`nid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`data_id` varchar(255) NOT NULL,
`group_id` varchar(128) NOT NULL,
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL,
`md5` varchar(32) DEFAULT NULL,
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00',
`src_user` text,
`src_ip` varchar(20) DEFAULT NULL,
`op_type` char(10) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
`encrypted_data_key` text NOT NULL COMMENT '秘钥',
PRIMARY KEY (`nid`),
KEY `idx_gmt_create` (`gmt_create`),
KEY `idx_gmt_modified` (`gmt_modified`),
KEY `idx_did` (`data_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='多租户改造';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = tenant_capacity */
/******************************************/
CREATE TABLE `tenant_capacity` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`tenant_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',
`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数',
`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
`gmt_create` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT '2010-05-05 00:00:00' COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='租户容量信息表';
CREATE TABLE `tenant_info` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`kp` varchar(128) NOT NULL COMMENT 'kp',
`tenant_id` varchar(128) default '' COMMENT 'tenant_id',
`tenant_name` varchar(128) default '' COMMENT 'tenant_name',
`tenant_desc` varchar(256) DEFAULT NULL COMMENT 'tenant_desc',
`create_source` varchar(32) DEFAULT NULL COMMENT 'create_source',
`gmt_create` bigint(20) NOT NULL COMMENT '创建时间',
`gmt_modified` bigint(20) NOT NULL COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),
KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';
CREATE TABLE users (
username varchar(50) NOT NULL PRIMARY KEY,
password varchar(500) NOT NULL,
enabled boolean NOT NULL
);
CREATE TABLE roles (
username varchar(50) NOT NULL,
role varchar(50) NOT NULL,
constraint uk_username_role UNIQUE (username,role)
);
CREATE TABLE permissions (
role varchar(50) NOT NULL,
resource varchar(512) NOT NULL,
action varchar(8) NOT NULL,
constraint uk_role_permission UNIQUE (role,resource,action)
);
INSERT INTO users (username, password, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);
INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');
http://192.168.10.106:8848/nacos
自己的ip+8848端口，账号密码：nacos，nacos
docker -redis
## 创建目录
mkdir -p /usr/local/docker/redis/conf
mkdir -p /usr/local/docker/redis/data
## 创建文件
touch /usr/local/docker/redis/conf/redis.conf
docker run -p 6379:6379 --name redis --restart=always -v /usr/local/docker/redis/conf/redis.conf:/etc/redis/redis.conf -v /usr/local/docker/redis/data:/data -d redis:6.2 redis-server /etc/redis/redis.conf --appendonly yes
docker-rocketmq
1.创建namesrv服务
mkdir -p /usr/local/docker/rocketmq/data/namesrv/logs
mkdir -p /usr/local/docker/rocketmq/data/namesrv/store
docker run -d \
-- restart=always \
-- name rmqnamesrv \
-p 9876:9876 \
-v /usr/local/docker/rocketmq/data/namesrv/logs:/root/logs \
- v /usr/local/docker/rocketmq/data/namesrv/store:/root/store \
-e "MAX_POSSIBLE_HEAP=100000000" \
rocketmqinc/rocketmq:4.4.0 \
sh mqnamesrv
2.创建broker节点
mkdir -p /usr/local/docker/rocketmq/data/broker/logs
mkdir -p /usr/local/docker/rocketmq/data/broker/store
mkdir -p /usr/local/docker/rocketmq/conf
vi /usr/local/docker/rocketmq/conf/broker.conf
# 所属集群名称，如果节点较多可以配置多个
brokerClusterName = DefaultCluster
#broker名称，master和slave使用相同的名称，表明他们的主从关系
brokerName = broker-a
#0表示Master，大于0表示不同的slave
brokerId = 0
#表示几点做消息删除动作，默认是凌晨4点
deleteWhen = 04
#在磁盘上保留消息的时长，单位是小时
fileReservedTime = 48
#有三个值：SYNC_MASTER，ASYNC_MASTER，SLAVE；同步和异步表示Master和Slave之间同步数据的机制；
brokerRole = ASYNC_MASTER
#刷盘策略，取值为：ASYNC_FLUSH，SYNC_FLUSH表示同步刷盘和异步刷盘；SYNC_FLUSH消息写入磁盘后才返回成功状态，ASYNC_FLUSH不需要；
flushDiskType = ASYNC_FLUSH
# 设置broker节点所在服务器的ip地址
brokerIP1 = 192.168.52.136
# 磁盘使用达到95%之后,生产者再写入消息会报错 CODE: 14 DESC: service not available now, maybe disk full
diskMaxUsedSpaceRatio=95
docker run -d \
--restart=always \
--name rmqbroker \
--link rmqnamesrv:namesrv \
-p 10911:10911 \
-p 10909:10909 \
-v /usr/local/docker/rocketmq/data/broker/logs:/root/logs \
-v /usr/local/docker/rocketmq/data/broker/store \
-v /usr/local/docker/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf \
-e "NAMESRV_ADDR=namesrv:9876" \
-e "MAX_POSSIBLE_HEAP=200000000" \
rocketmqinc/rocketmq:4.4.0 \
sh mqbroker -c /opt/rocketmq-4.4.0/conf/broker.conf
3.创建rockermq-console服务 (pangliang/rocketmq-console-ng)可视化控制台
docker pull pangliang/rocketmq-console-ng
docker run -d \
--restart=always \
--name rmqadmin \
-e "JAVA_OPTS=-Drocketmq.namesrv.addr=192.168.10.105:9876 \
-Dcom.rocketmq.sendMessageWithVIPChannel=false" \
-p 9999:8080 \
pangliang/rocketmq-console-ng
docker-jenkins
1.拉项目
docker pull jenkins/jenkins:lts
2、启动
mkdir -p /usr/local/docker/jenkins_home
chmod 777 /usr/local/docker/jenkins_home
docker run -d -p 10240:8080 -p 10241:50000 -v /usr/local/docker/jenkins_home:/var/jenkins_home -v /etc/localtime:/etc/localtime --name myjenkins jenkins/jenkins:lts
通过：docker logs myjenkins 查看密码
3.进行登录初始化项目
选择安装插件方式，这里我们直接安装推荐的插件，之后等待安装
4.安装完成后，创建管理员账号
5.进行实例配置，配置Jenkins的URL：
...
10.docker compose
简介
dockerfile 单个容器
微服务，100个微服务，以来关系，docker compose 轻松高效管理容器，定义运行多个容器
1。保证项目可以在任何地方运行
2.services什么是服务，docker-compose.yml这个文件怎么写
3.启动项目
作用：批量容器编排
需要安装，它是docker的开源项目
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: {}
compose：重要的概念
服务services，容器，应用(web，redis,mysql)
项目project，一组关联的容器，博客，web，mysql wp
docker compose安装体验
docker-compose --help
Usage: docker compose [OPTIONS] COMMAND
Docker Compose
Options:
--ansi string Control when to print ANSI control characters ("never"|"always"|"auto") (default "auto")
--compatibility Run compose in backward compatibility mode
--env-file string Specify an alternate environment file.
-f, --file stringArray Compose configuration files
--parallel int Control max parallelism, -1 for unlimited (default -1)
--profile stringArray Specify a profile to enable
--project-directory string Specify an alternate working directory
(default: the path of the, first specified, Compose file)
-p, --project-name string Project name
Commands:
build 构建或重建服务
convert 将撰写文件转换为平台的规范格式
cp 在服务容器和本地文件系统之间复制文件文件夹
create 为服务创建容器。
down 停止并移除容器、网络
events 从容器接收实时事件。
exec 在正在运行的容器中执行命令。
images 列出创建的容器使用的图像
kill 强制停止服务容器
logs 查看容器的输出
ls 列出正在运行的撰写项目
pause 暂停服务
port 打印端口绑定的公共端口。
ps 列出容器
pull 拉取服务图像
push 推送服务图片
restart 重新启动服务容器
rm 删除已停止的服务容器
run 对服务运行一次性命令
start 启动服务
stop 停止服务
top 显示正在运行的进程
unpause 无偿服务
up 创建和启动容器
version 显示Docker Compose版本信息
撰写先决条件
Docker Compose 需要 Docker 引擎。
Docker Compose 插件需要 Docker CLI。
1.首先要安装好docker，和cli之前安装过
2.更新apt包索引，并安装最新版本的 Docker Compose：
apt-get update
apt-get install docker-compose-plugin
docker compose version
apt install docker-compose
docker-compose up -d
docker-compose stop
docker-compose ps
docker-compose rm
compose初体验
在此页面上，您将构建一个在 Docker Compose 上运行的简单 Python Web 应用程序。该应用程序使用 Flask 框架并在 Redis 中维护一个命中计数器。虽然示例使用 Python，但即使您不熟悉此处演示的概念，也应该可以理解。
1.设置目录
mkdir composetest
cd composetest
2.在项目目录中创建一个名为app的文件并编写代码
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.在您的项目目录中创建另一个名为的文件requirements.txt并将其粘贴到：
flask
redis
4.在您的项目目录中，创建一个名为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"]
这告诉 Docker：
从 Python 3.7 映像开始构建映像。
将工作目录设置为/code.
设置命令使用的环境变量flask。
安装 gcc 和其他依赖项
复制requirements.txt并安装 Python 依赖项。
向镜像添加元数据以描述容器正在侦听端口 5000
将项目中的当前目录复制.到镜像中的workdir .。
将容器的默认命令设置为flask run.
5.在您的项目目录中创建一个名为的文件docker-compose.yml并粘贴以下内容：
version: "2.2"
services:
web:
build: .
ports:
- "8000:5000"
redis:
image: "redis:alpine"
6.在您的项目目录中，通过运行`
docker-compose up
7.在浏览器中输入 http://localhost:8000/ 以查看正在运行的应用程序。
8.刷新页面，数字应该增加。
9.切换到另一个终端窗口，然后键入docker image ls以列出本地图像。
10、停止应用程序，方法是docker-compose down
得进入到当前docker-compose.yml目录下执行
root@player3-TM1613:/home/player3/composetest# docker-compose down
Stopping composetest_web_1 ... done
Stopping composetest_redis_1 ... done
Removing composetest_web_1 ... done
Removing composetest_redis_1 ... done
Removing network composetest_default
11.在您的项目目录中编辑docker-compose.yml以添加服务的 绑定[挂载)web：
version: "2.2"
services:
web:
build: .
ports:
- "8000:5000"
volumes:
- .:/code
environment:
FLASK_ENV: development
redis:
image: "redis:alpine"
12.在您的项目目录中，键入docker-compose up以使用更新的 Compose 文件构建应用程序，然后运行它。
13.更改问候语app.py并保存。例如，将Hello World! 消息更改为Hello from Docker!
return 'Hello from Docker! I have been seen {} times.\n'.format(count)
1、应用app.py
2.Dockerfile 应用打包为镜像
3.docker-compose yaml(定义整个服务，需要的环境，web，redis)
4.启动 docker-compose up
5.停止
docker-compose down
刚刚启动的俩服务： composetest_redis_1 , composetest_web_1
默认的服务名： 文件名_服务名_num
如果是多个服务器，集群.a b _num 副本数量
服务redis服务 =》4个副本
docker network ls
出现了一个新的网络
10个服务=》10个项目(项目中的内容都在同个网络下，域名访问)
mysql：3306
10个容器实例：mysql内部不会写死ip的
在同一个网络下可以通过域名访问
yaml的配置规则
3层
version #版本 services #服务 服务1:web docker的一些配置 服务2 ：redis docker 的一些配置 。。。 其他配置,网络，卷，全局规则 volumes: networks: configs:
学习，要掌握规律！
只要多写，多看，compose.yaml配置
搭建开源博客
https://docs.docker.com/samples/wordpress/
1.创建目录my_wordpress/
2.进入目录
3.创建一个docker-compose.yml用于启动您的 WordPress博客的文件和一个带有卷挂载的单独MySQL实例以实现数据持久性：
version: "2.2"
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: {}
4.启动：
docker-compose up -d
5.访问本地8080端口，使用博客
编写redis访问计数器的微服务
1.启动springboot项目包括spirngbootweb+redis
pom配置
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>aliyun-redis-spring-boot-starter</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2.编写基本代码
@RestController
public class HelloController {
@Autowired
StringRedisTemplate redisTemplate;
@GetMapping("/hello")
public String hello(){
Long views = redisTemplate.opsForValue().increment("views");
return "hello docker ! see "+views;
}
}
# 应用名称
spring.application.name=demo1
#ip,目前连接的docker是单机版本，如果是多副本的redis呢？host应该如何连接？
spring.redis.host=demo1_redis_1
3.编写配置文件
dockerfile
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]
docker-compose.yml
version: '2.2'
services:
kuangapp:
build: .
image: kuangapp
depends_on:
- redis
ports:
- "8080:8080"
redis:
image: "redis:5.0.9-alpine3.11"
hostname: redis
ports:
- "6379:6379"
4.打包 package
使用maven自带打包工具然后放在一个目录下，三个文件
5.在linux环境执行
docker-compose up -d
6.会自动下载安装包，会跑两个服务，一个redis的，一个springbot的，然后还会自己创建一个网络，包含这两个环境的
7.访问localhost:8080/hello
购买弹性服务器4台，按量付费
略
1核2
，k8s需要2核4g的
4台，配置安全组，在同一个安全组进行，不需要流量，带宽可以设置的高一些，设置自定义密码…
jenkins+docker持续集成（ci/cd）实战
ci/cd基本概念
jenkins环境搭建
jenkins的基本使用
jenkins自动部署实战案例
swarm
工作模式，适合10台机器以下
管理节点：操作都在manager
工作节点：worker
farft一致性算法
管理节点最少3个
搭建集群
初始化节点
docker swarm init –advertise-addr 本机ip
加入节点
docker swarm join 加入一个节点！
#获取令牌,生成节点命令
docker swarm join-token manager
docker swarm join-token worker
查看节点
docker node ls
farft协议：保证大多数节点存活才可用，
---------------------------------------------------------------------------
国之殇，未敢忘！
南京大屠杀!
731部队!
以及核污染水排海等一系列全无人性的操作，购买他们的食品和为它们提供帮助只会更加变本加厉的害你，呼吁大家不要购买日本相关产品
昭昭前事，惕惕后人
吾辈当自强，方使国不受他人之侮！
---------------------------------------------------------------------------
作者：三号小玩家
出处：https://www.cnblogs.com/q1359720840/
版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。 版权信息
