docker技术学习

docker安装

安装docker（乌班图）-需要su权限

官网：https://docs.docker.com/engine/install/ubuntu/

帮助文档：

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

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

10.启动docker

11。停止docker

阿里云镜像加速

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

回顾helloword的整个流程

开始，在本机找镜像，有就用，没有就在dockerhub下载，如果dockerhub找到，下载本地运行，找不到报错。

docker常用命令

帮助命令

docker version #显示版本信息
docker info  #显示更详细信息
docker --help #帮助信息

帮助文档地址：

镜像命令：

docker 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 镜像的大小

docker search #搜索镜像

docker search mysql  #搜索mysql
docker search mysql --filter=STARS=3000 #搜索出来的大于等于3000

docker pull #下载镜像

docker pull mysql #下载mysql

docker pull 镜像名[:tag]如果不写是默认latest 
采用分层下载，联合文件系统，还有签名 ，docker.io是真实地址

docker pull mysql==docker pull docker.io/library/mysql:latest

docker images#查看镜像

docker rmi #删除镜像

docker rmi-f 删除制定的镜像
docker rmi -f id id 删除多个镜像

docker rmi-f $(docker images -aq) 递归删除全部镜像

容器命令

启动并进入容器内部

docker run -it centos /bin/bash

docker run [跟的常用命令]

--name 给容器的别名
-P 随机外部端口映射容器内部端口
-p 指定端口   比如:   -p 5000:5000 
-d 容器后台运行 

退回主机

exit #容器停止退出
ctrl+p+q#不停止退出

列出所有运行中的容器

docker ps

查看运行过的容器

docker -ps -a

docker 容器运行的状态

容器状态有7种：
created（已创建）
restarting（重启中）
running（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）

删除容器

docker rm 容器id			#删除制定的容器 ，如果删除正在运行的容器  -f
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  #强制停止容器

后台启动容器

docker run -d  -it 镜像名

查看日志

docker logs -f -t 容器id
docker logs -t -f --tail 20   容器id查看20条
 

写一段脚本

while true;do echo kuangshen;sleep 1;done

查看容器进程信息

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

查看镜像元数据

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

进入容器

docker exec -it  容器id/bin/bash ##进入容器打开新终端
docker attach  容器id  #进入容器在原来的终端，可以看到之前的代码

从容器内拷贝文件到主机上

docker cp 容器id：容器内路径 目的主机路径

小结

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 状态

作业

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镜像

提交一个自己的镜像

docker commit 提交容器成为一个新副本
docker commit -m "内容" -a "作者" 容器id 目标镜像名:[tag]

数据卷

防止容器删除后数据丢失，有了数据卷可以保存到电脑，将容器目录挂载到linux上面

-v 挂载
docker run -it -v 主机目录:容器内目录 

挂载完成之后：

Mounts里就会绑定两者的关系
source 主机内地址
destination docker容器内的地址

容器内添加可以添加到外部，属于双向绑定了是

作业安装mysql挂载数据

1.查找mysql
2.下载镜像
3.启动，需要数据挂载  

具名挂载和匿名挂载

不指定主机名 直接是容器内的目录： docker run -d -P --name nginx01 -v /ect/nginx nginx
所有不指定宁docker容器内的卷，在没有指定 /var/lib/docker/volumes/xxx/_data

区分具名匿名
-v 容器内路径   是匿名挂载
-v 卷名：容器内路径 具名挂载
-v /宿主机器路径::容器内路径 指定路径挂载

扩展

通过 -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

dockerfile

1编写镜像文件dockerfile1

FROM centos
VOLUME ["volume01","volume02"]
CMD echo "--------end------------"
CMD /bin/bash

2. 执行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同步数据？

小作业两个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

结论：容器之间的生命周期，一直到所有容器都没有使用为止，本地数据卷的数据是不会删除的。

编写docker的具体步骤

1.编写dockerfile文件，文件首字母大写

2.dockerbuild 构件成一个镜像

3.docker run 运行镜像

4.docker push 发布镜像 （ducherhub，阿里云镜像仓库）

dockerfile构建过程

dockerFile:构建文件，定义了一切的步骤，源代码

dockerimages:通过dockerfile构建生成的镜像，最终发布和运行的产品，原来是jar，war。

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

基础知识：

1.每个保留关键字（指令）都是必须大写的

2.执行从上到下顺序执行

3。#表示注释

4.每个指令都会创建提交一个新的镜像层

dockerfile常见命令

FROM   指定基本镜像，一切镜像从这里开始
MAINTAINER 负责人，一般姓名+邮箱
RUN 构建镜像的时候需要运行的命令
ADD 步骤，tomcat镜像的化tomcat的压缩包，添加内容
WORKDIR 镜像的工作目录
VOLUME 挂载的目录
EXPOSE 对外暴露的端口
CMD 命令行操作
ENTRYPOINT 指定容器启动的时候要运行的命令，可以追加命令
ONBUILD 当构建一个被继承dockerfile 这个时候就会运行ONBUILD的指令，触发指令
COPY 类似add，将文件拷贝到镜像中
ENV 设置构建的环境变量

小作业

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

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

小作业tomcat镜像

发布自己的镜像

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其他参考官方文档

docker save

docker load

docker网络

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中所有的网络接口都是虚拟的，虚拟转发效率高（内网传递文件）

只要容器删除，对应的网桥一对就没了

–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的问题，不支持容器名连接访问

docker network

 docker network ls 查看所有的温昂罗
 
  docker network rm id  删除某个网络
  docker create 

网络模式

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

搭建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.

将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

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 需要 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协议：保证大多数节点存活才可用，