docker狂神笔记

最新推荐文章于 2024-07-23 12:51:05 发布

sss_jjj_

最新推荐文章于 2024-07-23 12:51:05 发布

阅读量1.4k

点赞数

文章标签： docker

本文链接：https://blog.csdn.net/sss_jjj_/article/details/111870648

版权

一、架构

客户端 - 服务器 - 仓库

镜像（image)

模板，可以通过模板创建容器服务。镜像 =》run =》容器，可以运行多个容器

容器（container）

独立运行一个或一组应用，通过镜像创建

基本命令：启动，停止，删除

理解为一个简易的linux系统

仓库（repository）

存放镜像的地方

分为公有仓库和私有仓库

公有仓库

官方：Docker Hub

阿里云…都有容器服务器（配置镜像加速）

二、作业

部署nginx

Search

Pull

Run -p 3344:80 端口映射
Tomcat

Docker run -it --rm tomcat:9.0

--rm用完即删，用于测试
ES + Kibana

三、可视化

四、docker镜像加载原理

联合文件系统，一层一层加载，底层可以复用。加快docker加载速度

五、镜像分层原理

pull的时候分层下载，已有的层不再下载。加速下载

六、如何提交自己的镜像

Docker commit 提交容器成为一个新的副本

Docker commit -m=“提交的描述信息” -a=“作者” 容器id:[tag]

七、容器数据卷

什么是容器数据卷

需求：数据持久化，数据可以存在本地

不会发生删了docker，数据也没了的情况

方式：目录挂载，数据同步机制

ps：容器间也可以数据共享

方式一：直接使用命令来挂载 -v

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

即使容器停止了，同步也是进行的

好处：修改配置只要再本地就可以，不用进入容器

实战：安装MySQL

https://hub.docker.com/_/mysql

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

方式二：已有容器挂载

法一：修改配置文件（需停止docker服务）
1、停止docker服务
systemctl stop docker.service（关键，修改之前必须停止docker服务）
2、vim /var/lib/docker/containers/container-ID/config.v2.json
修改配置文件中的目录位置，然后保存退出

 "MountPoints":{"/home":{"Source":"/docker","Destination":"/home","RW":true,"Name":"","Driver":"","Type":"bind","Propagation":"rprivate","Spec":{"Type":"bind","Source":"//docker/","Target":"/home"}}}
1

3、启动docker服务
systemctl start docker.service
4、启动docker容器
docker start <container-name/ID>
法二：提交现有容器为新镜像，然后重新运行它

$ docker ps  -a
CONTAINER ID        IMAGE                 COMMAND                  CREATED              STATUS                          PORTS               NAMES
   5a3422adeead        ubuntu:14.04          "/bin/bash"              About a minute ago   Exited (0) About a minute ago                       agitated_newton
$ docker commit 5a3422adeead newimagename
$ docker run -ti -v "$PWD/dir1":/dir1 -v "$PWD/dir2":/dir2 newimagename /bin/bash
12345

然后停止旧容器，并使用这个新容器，如果由于某种原因需要新容器使用旧名称，请在删除旧容器后使用docker rename。
法三：export容器为镜像，然后import为新镜像

$docker container export -o ./myimage.docker 容器ID
$docker import ./myimage.docker newimagename
$docker run -ti -v "$PWD/dir1":/dir1 -v "$PWD/dir2":/dir2 newimagename /bin/bash
123

然后停止旧容器，并使用这个新容器，如果由于某种原因需要新容器使用旧名称，请在删除旧容器后使用docker rename。

方式三：dockerfile挂载

用来构建docker镜像的构建文件：命令脚本

# 创建一个dockerfile文件
# 文件中的内容 指令大写 一层一层
FROM centos

# 生成镜像的方式挂载
# 匿名挂载，挂载到一个随机目录去了，一般在docker的volume中，用docker inspect看
VOLUME ["volume01","volume02"]

CMD echo "----end----"

CMD /bin/bash

方式四：数据卷容器

容器之间数据同步：linux的硬链接，删一个容器其他的还有数据

docker run -it -d --name docker01 kuangshen/centos:1.0

docker run -it -d --name docker02 --volumes-from docker 01 kuangshen/centos:1.0

结论：

容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。

八、DockerFile

dockerfile是用来构建docker镜像的文件，命令参数脚本

构建步骤：

编写一个dockerfile文件
docker build构建成为一个镜像
docker run运行镜像
docker push发布镜像（dockerhub、阿里云镜像仓库）

centos7官方dockerfile

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

Dockerfile构建过程

基础知识

每个保留关键字（指令）都是大写字母
执行从上到下顺序执行
#表示注释
每一个指令都会创建提交一个新的镜像层，并提交

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！

docker镜像逐渐成为企业交付的标准，微服务

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

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

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

DockerFile指令

FROM			# 基础镜像
MAINTAINER		# 镜像是谁写的，姓名邮箱
RUN				# 镜像构建的时候需要运行的命令
ADD				# 步骤，tomcat镜像，这个tomcat压缩包，添加内容
WORKDIR			# 镜像的工作目录
VOLUME			# 挂载的目录
EXPOSE			# 暴露端口配置

CMD				# 指定容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT		# 指定容器启动的时候要运行的命令，可以被追加

ONBUILD			# 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 的指令，触发指令
COPY			# 类似add，将文件拷贝到镜像中
ENV				# 构建的时候设置环境变量

CMD和ENTRYPOINT的区别

CMD				# 指定容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT		# 指定容器启动的时候要运行的命令，可以被追加

测试

[root@ceph-node1 dockerfile]# cat testcmd 
FROM centos:7

CMD ["ls","-a"]

[root@ceph-node1 dockerfile]# docker build -f testcmd -t cmdtest .
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM centos:7
 ---> 8652b9f0cb4c
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 586c8704a6cb
Removing intermediate container 586c8704a6cb
 ---> 74aecdefe1f3
Successfully built 74aecdefe1f3
Successfully tagged cmdtest:latest

[root@ceph-node1 dockerfile]# docker run 74aecdefe1f3
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
。。。

# 想追加命令，是替换的关系，要加上完整的命令
[root@ceph-node1 dockerfile]# docker run 74aecdefe1f3 ls -al
total 12
drwxr-xr-x   1 root root     6 Nov 18 02:30 .
...
lrwxrwxrwx   1 root root     7 Nov 13 01:53 bin -> usr/bin
drwxr-xr-x   5 root root   340 Nov 18 02:30 dev
drwxr-xr-x   1 root root    66 Nov 18 02:30 etc
drwxr-xr-x   2 root root     6 Apr 11  2018 home
lrwxrwxrwx   1 root root     7 Nov 13 01:53 lib -> usr/lib

# 而ENTRYPOINT可以直接追加-l
[root@ceph-node1 dockerfile]# docker run 4cff74726897 -l
total 12
drwxr-xr-x   1 root root     6 Nov 18 02:33 .
drwxr-xr-x   1 root root     6 Nov 18 02:33 ..
-rwxr-xr-x   1 root root     0 Nov 18 02:33 .dockerenv
...
drwxr-xr-x  13 root root   155 Nov 13 01:53 usr
drwxr-xr-x  18 root root   238 Nov 13 01:54 var

实战测试：Tomcat镜像

准备镜像文件tomcat压缩包，jdk压缩包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UzB5XWXH-1609146485036)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118111730541.png)]
编写dockerfile文件，官方命名Dockerfile，build会自动寻找这个文件，就不需要-f指定了

FROM centos:7
MAINTAINER swordsj<1173054631@qq.com>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u221-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.39.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_221
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.39
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.39
ENV PATH $PATH:$JAVA_HOME/bin;$CATALINA_HOME/lib;$CATALINA_HOME/bin

EXPOSE 8080

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

构建镜像

docker build -t diytomcat .

创建容器

docker run -d -p 9090:8080 --name sjtomcat -v /home/swordsj/build/tomcat/test:/usr/local/apache-tomcat-9.0.39/webapps/test -v /home/swordsj/build/tomcat/logs/:/usr/local/apache-tomcat-9.0.39/logs diytomcat

访问测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GM3tsCeK-1609146485045)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118112853026.png)]

发布项目（由于做了卷挂载，直接在本地编写项目就可以发布了）

web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" 			xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 	
			xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
			id="WebApp_ID" 
			version="2.5">

</web-app>

index.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>首页</title>
</head>
<body>
    <div class="header">
        <div class="logo">web实践</div>
    </div>
</body>
</html>

发布自己的镜像

地址https://hub.docker.com/ 注册自己的账号
确定这个账号可以应用
在服务器上提交自己的镜像

# 登录docker

[root@ceph-node1 test]# docker login --help

Usage:	docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

登录完毕，push镜像

# push前要用tag命令修改为规范的镜像，名字对应账号名称
docker tag 镜像id swordsj/tomcat:1.0

docker push swordsj/diytomcat:1.0

发布到阿里云镜像服务

登录阿里云
找到容器镜像服务
创建命名空间，镜像仓库，选公有或私有，本地仓库
创建容器镜像
浏览阿里云官方文档

九、docker全流程总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2R0c2mju-1609146485046)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118154649746.png)]

十、docker网络

理解Docker0

清空所有环境

[root@ceph-node3 ~]# ip addr

## 本机回环地址
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: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:d9:58:ab brd ff:ff:ff:ff:ff:ff
    inet 192.168.174.12/24 brd 192.168.174.255 scope global noprefixroute ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::fbb9:7fc1:3ea6:605b/64 scope link tentative noprefixroute dadfailed 
       valid_lft forever preferred_lft forever
    inet6 fe80::4f59:682b:a7c0:8077/64 scope link tentative noprefixroute dadfailed 
       valid_lft forever preferred_lft forever
    inet6 fe80::452c:7ad9:a88d:11cd/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
       
## docker地址，172.17.0.1是docker网关地址
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:c3:77:d2:b0 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 scope global docker0
       valid_lft forever preferred_lft forever

三个网络

# 问题： docker 是如何处理容器网络访问的？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vFc2QnO7-1609146485048)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118161318162.png)]

docker run -d -P --name tomcat01 tomcat

# 查看容器的内部网络地址  容器的 ip addr

[root@ceph-node3 ~]# docker exec -it d48 ip addr

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
       
# docker分配的ip地址
4: eth0@if5: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:acff:fe11:2/64 scope link 
       valid_lft forever preferred_lft forever

# 思考linux能不能ping通这个eth0，如果能ping通就能交互
[root@ceph-node3 ~]# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.134 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.083 ms

# linux 可以ping通容器内部

原理

我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0

桥接模式，使用的技术是veth-pair技术

再次测试ip addr，发现多了一个网卡

5: veth3b7d3c3@if4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 0e:08:32:0b:19:0f brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::c08:32ff:fe0b:190f/64 scope link 
       valid_lft forever preferred_lft forever

再启动一个容器测试，发现又多了一对网卡

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-krBhV1PG-1609146485049)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118162846503.png)]

# 我们发现这个容器带来的网卡，都是一对一对的
# veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连
# 正因为有这个特性，veth-pair 充当一个桥梁
# OpenStac，Docker容器之间的连接，OVS的连接，都是使用veth-pair技术

我们来测试一下tomcat01和tomcat02能不能互相ping通，可以ping通，是一样的

[root@ceph-node3 ~]# docker exec -it tomcat01 ping 172.17.0.3
PING 172.17.0.3 (172.17.0.3) 56(84) bytes of data.
64 bytes from 172.17.0.3: icmp_seq=1 ttl=64 time=0.100 ms
64 bytes from 172.17.0.3: icmp_seq=2 ttl=64 time=0.058 ms

网络模型原理图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mOjQiiLr-1609146485050)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118163855819.png)]

结论：tomcat01和tomcat02共用一个路由器docker0

所有的容器不指定网路的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP

255.255.0.1/16 大的公司	255.255.0.1/24 域局域网小教室
00000000,00000000,00000000,00000000	00000000,00000000,00000000,00000000
255,255,255,255	255,255,255,255
能放 255*255 - 0.0.0.0 - 255.255 = 65535	能放 255 - 0.0.0.0 - 255.255 = 253

小结

Docker使用的是Linux的桥接，宿主机中是一个Docker容器的网桥 docker0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UxN8MACW-1609146485051)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118164914092.png)]

Docker中所有的网络接口都是虚拟的

虚拟的转发效率高（内网传递文件）

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

–link

思考：编写了一个微服务，database url=ip: ，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以用名字来进行访问容器吗？

docker提供了 --link 来解决这个问题

# 用名字不能ping通
[root@ceph-node3 ~]# docker exec -it tomcat01 ping tomcat01
ping: tomcat01: Name or service not known

# 如何解决  通过 --link
[root@ceph-node3 ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
166999b991036e5bda28d201d6ff933da43a3cedd134a205ce9aad26f2793c7d

[root@ceph-node3 ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.144 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.090 ms

# 反向ping呢？ tomcat02 ping tomcat03  ping不通
[root@ceph-node3 ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

探究

[root@ceph-node3 ~]# docker inspect tomcat03

...
"Links": [
                "/tomcat02:/tomcat03/tomcat02"
            ],
...


# 而tomcat02 ping 不到 tomcat03 原因：单向绑定
[root@ceph-node3 ~]# docker inspect tomcat02

...
"Links": null,
...

# 原理：link直接再tomcat03的/etc/hosts文件里绑定了tomcat02的内网地址
root@166999b99103:/etc# cat /etc/hosts

127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.3	tomcat02 f98b8581b4e9
172.17.0.4	166999b99103

# 所以要双向绑定的话只要改tomcat02的hosts文件，添加tomcat03的映射就可以了

我们现在玩Docker已经不建议使用–link了

自定义网络，不适用docker0

docker0问题：不支持容器名连接访问

自定义网络

查看所有的docker网络

[root@ceph-node3 ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
cb13300e74b0        bridge              bridge              local
eeafa2335fe6        host                host                local
32c302a596c0        none                null                local

网络模式

bridge：桥接 docker（默认 自己创建的也是用bridge模式）

none：不配置网络

host：和宿主机共享网络

container：容器网络联通！（用得少，局限很大）

测试

# 自定义网络
# --driver bridge 			桥接
# --subnet 192.168.0.0/24 	子网   最大支持 192.168.0.2 - 192.168.0.255
# --gateway 192.168.0.1 	网关
[root@ceph-node3 ~]# docker network create --driver bridge --subnet 192.168.0.0/24 --gateway 192.168.0.1 mynet
4d0de2d1b9ee851d7c951793e0392f75a4d59e5eb03ac36159762760cb455d6d

[root@ceph-node3 ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
cb13300e74b0        bridge              bridge              local
eeafa2335fe6        host                host                local
4d0de2d1b9ee        mynet               bridge              local
32c302a596c0        none                null                local

我们自己的网络就创建好了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ePSs6pwK-1609146485051)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118194832403.png)]

[root@ceph-node3 ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "4d0de2d1b9ee851d7c951793e0392f75a4d59e5eb03ac36159762760cb455d6d",
        "Created": "2020-10-22T22:37:42.976495365+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/24",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Containers": {
            "a1b0900ed55d6343ec8a03b00bc3bb342154e04f95fd135690066cfb3e433307": {
                "Name": "tomcat-net-01",
                "EndpointID": "1771fd8a151cd4142bb5afa4ad3f797982ee729830c22a3d0c05488e11123634",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/24",
                "IPv6Address": ""
            },
            "c915c5e53e472142b92d93d9cca8840e887609f158c3143b78ccf00458a32232": {
                "Name": "tomcat-net-02",
                "EndpointID": "89e045c5167ee40c8512b6ec36e2ac17522f828512f250894aab11b486e3b086",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/24",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 这时候就支持container互相ping了，docker0没有这个功能

[root@ceph-node3 ~]# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.047 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.054 ms

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐平时这样使用网络

好处：不同的集群使用不同的网络，保证集群是安全和健康的

网络联通

# 把在docker0网络下的tomcat01 连接到mynet
[root@ceph-node3 ~]# docker network connect mynet tomcat01

[root@ceph-node3 ~]# docker network  inspect mynet
[
    {
        "Name": "mynet",
        "Id": "4d0de2d1b9ee851d7c951793e0392f75a4d59e5eb03ac36159762760cb455d6d",
        "Created": "2020-10-22T22:37:42.976495365+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/24",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Containers": {
            "291533f225f79e1a714cc2de7e5590795b876eea7eadc3078024d9ac8ff9c61f": {
                "Name": "tomcat01",
                "EndpointID": "0400e3cef0fb9b62a81330ae8b5c503accdab37f11b74095575e598feb4499c3",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/24",
                "IPv6Address": ""
            },
            "a1b0900ed55d6343ec8a03b00bc3bb342154e04f95fd135690066cfb3e433307": {
                "Name": "tomcat-net-01",
                "EndpointID": "1771fd8a151cd4142bb5afa4ad3f797982ee729830c22a3d0c05488e11123634",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/24",
                "IPv6Address": ""
            },
            "c915c5e53e472142b92d93d9cca8840e887609f158c3143b78ccf00458a32232": {
                "Name": "tomcat-net-02",
                "EndpointID": "89e045c5167ee40c8512b6ec36e2ac17522f828512f250894aab11b486e3b086",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/24",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 结果：tomcat01可以ping通 tomcat-net-01
[root@ceph-node3 ~]# docker exec -it tomcat01 ping tomcat-net-01

PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.134 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.077 ms

一个容器两个ip

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dhlnthXS-1609146485052)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118202144108.png)]

结论：假设要跨网络操作别人，就需要使用docker network connect 联通

实战：部署Redis集群

分片 + 高可用 + 负载均衡

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pYSlkG2J-1609146485053)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201118202500653.png)]

shell脚本启动

# 网卡
docker network create redis --subnet 172.38.0.0/16

# shell脚本创建redis集群
[root@ceph-node3 ~]# 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-enabledro yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 启动容器
docker run -p 6371:6379 -p 16371: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 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

十一、SpringBoot微服务打包Docker镜像

构建springboot项目
打包应用

编写dockerfile（在idea加载docker插件，可以又dockerfile高亮和提示）

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]

构建镜像
```
docker build -t swordsj .
```

发布运行

docker docker run -d -P --name sword-springboot-web swordsj

发给别人的时候上传到镜像仓库即可

十二、企业实战

如果有很多镜像 100个，分别启动，维护很麻烦

Docker Compose

简介

100个微服务，依赖关系

不能手动运行，通过Docker Compose来高效管理，定义运行多个容器

官方介绍

定义、运行多个容器

YAML file配置文件

single command。命令有哪些？

Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services. Then, with a single command, you create and start all the services from your configuration. To learn more about all the features of Compose, see the list of features.

Compose works in all environments: production, staging, development, testing, as well as CI workflows. You can learn more about each case in Common Use Cases.

Using Compose is basically a three-step process:

Define your app’s environment with a Dockerfile so it can be reproduced anywhere.
- Dockerfile 保证项目在任何地方可以运行
Define the services that make up your app in docker-compose.yml so they can be run together in an isolated environment.
- services是什么服务？
- docker-compose.yml这个文件怎么写？
Run docker-compose up and Compose starts and runs your entire app.
- 启动项目

作用：批量容器编排

自己的理解

Compose是Docker官方的开源项目，需要安装！

Dockerfile让程序在任何地方运行

compose

version: "3.8"
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

docker-compose up

Compose：重要的概念

服务services，容器。应用。（web、redis、mysql…）
项目project。一组关联的容器。博客：web、mysql、wp

安装

1、下载

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

# 国内镜像
curl -L https://get.daocloud.io/docker/compose/releases/download/1.24.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/dock

路径：/usr/local/bin

2、授权

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

3、查看版本

docker-compose version

出现

安装成功

ldblk

Docker Swarm

简单版的k8s

集群方式的部署、4台阿里云服务器、2核4g

实战

1、编写项目微服务 jar包

2、dockerfile构建镜像

3、docker-compose.yml 编排项目

4、放到服务器 docker-compose up

假设项目要重新打包部署

# 重新构建
docker-compose up --build

总结

工程、服务、容器

项目 compose：三层

工程 Project
服务
容器运行实例 docker k8s 容器

Docker Stack

4台服务器搭建集群：阿里云、mobaxterm（免费）、虚拟机

docker-compose 单机部署项目

docker stack部署，集群部署

# 单机
docker-compose up -d wordpress.yaml
# 集群
docker-stack up -d wordpress.yaml

yaml例子

version: "3"
services:

  redis:
    image: redis:alpine
    ports:
      - "6379"
    networks:
      - frontend
    
    # 集群
    deploy:
    
      # 副本数
      replicas: 2
      
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure

  db:
    image: postgres:9.4
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend
    deploy:
      placement:
        constraints: [node.role == manager]

networks:
  frontend:
  backend:

volumes:
  db-data:

Docker Secret

安全！配置密码、证书

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ulW92F6v-1609146485054)(D:\CourseAndLearn\md学习笔记\SwordSJ\typora-user-images\image-20201207203300747.png)]

Docker Config

配置

网上找案例，跑起来试试 // 查看命令，帮助文档

CI/CD之Jenkins

拓展到K8S

趋势：云原生

云应用 => 下载 => 配置 => 你的网站

Go语言

Docker、K8S是Go开发的

并发语言，语法与C相近，但功能上有：内存安全，GC，结构形态及CSP-style并发计算

效率接近于C

入门

基础语法

高级对象

如何操作数据库

框架

sss_jjj_

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
docker狂神笔记

一、架构客户端 - 服务器 - 仓库镜像（image)模板，可以通过模板创建容器服务。镜像 =》run =》容器，可以运行多个容器容器（container）独立运行一个或一组应用，通过镜像创建基本命令：启动，停止，删除理解为一个简易的linux系统仓库（repository）存放镜像的地方分为公有仓库和私有仓库公有仓库官方：Docker Hub阿里云…都有容器服务器（配置镜像加速）二、作业部署nginx Search Pull Run -p 3344:80
复制链接

扫一扫