Docker入门实战教程-动力哥

已于 2024-10-21 14:26:03 修改
阅读量1.2k 收藏 13
点赞数 22
分类专栏： K8s+docker 文章标签： docker 容器 运维
于 2024-04-11 16:35:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flytalei/article/details/137552746
版权

文章目录

Docker引擎的安装

安装Docker需要的依赖gcc gcc-c++

yum -y install gcc
yum -y install gcc-c++

因为我之前已经安装了，所以现在提示"Nothing to do"

[root@localhost ~]# yum -y install gcc
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Package gcc-4.8.5-44.el7.x86_64 already installed and latest version
Nothing to do

[root@localhost ~]# yum -y install gcc-c++
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Package gcc-c++-4.8.5-44.el7.x86_64 already installed and latest version
Nothing to do

非root用户需要使用sudo提权

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装Docker

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

查看docker版本

docker version

[root@localhost ~]# docker version
Client: Docker Engine - Community
 Version:           26.0.0
 API version:       1.45
 Go version:        go1.21.8
 Git commit:        2ae903e
 Built:             Wed Mar 20 15:21:09 2024
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          26.0.0
  API version:      1.45 (minimum version 1.24)
  Go version:       go1.21.8
  Git commit:       8b79278
  Built:            Wed Mar 20 15:20:06 2024
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.28
  GitCommit:        ae07eda36dd25f8a1b98dfbf587313b99c0190bb
 runc:
  Version:          1.1.12
  GitCommit:        v1.1.12-0-g51d5e94
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

运行hello-world

docker run hello-world

[root@localhost ~]# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
c1ec31eb5944: Pull complete 
Digest: sha256:53641cd209a4fecfc68e21a99871ce8c6920b2e7502df0a20671c6fccc73a7c6
Status: Downloaded newer image for hello-world:latest

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

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

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

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

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

Docker比vm虚拟机快

为什么Docker会比vm虚拟机快

1.docker有着比虚拟机更少的抽象层
  由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化，
  运行在docker容器上的程序直接使用的都是实际物理机的硬件资源，因此在cpu、内存利用率上docker将会在效率上有明显优势。
  
2.docker利用的是宿主机的内核，而不是需要加载操作系统os内核
  当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统内核。

Docker常用命令

官方文档：https://docs.docker.com/
在这里插入图片描述

Docker启动管理命令

systemctl start docker
systemctl stop docker
systemctl status docker
systemctl restart docker
systemctl enable docker
docker info
docker --help
docker command(具体命令) --help

镜像命令

docker images

docker images  #列出本地主机上的镜像

[root@localhost ~]# docker images
REPOSITORY(表示镜像的仓库源)    TAG(镜像的标签版本号)       IMAGE ID(镜像ID)       CREATED(镜像创建时间)         SIZE(镜像大小)
hello-world                  latest                    d2c94e258dcb           11 months ago               13.3kB

docker search

docker search 镜像名称

docker search redis

[root@localhost ~]# docker search redis
NAME                                DESCRIPTION                                     STARS     OFFICIAL
redis                               Redis is an open source key-value store that…   12764     [OK]
redislabs/redisearch                Redis With the RedisSearch module pre-loaded…   63        
redislabs/redisinsight              RedisInsight - The GUI for Redis                101       
redis/redis-stack-server            redis-stack-server installs a Redis server w…   72        
redis/redis-stack                   redis-stack installs a Redis server with add…   103       
redislabs/rebloom                   A probablistic datatypes module for Redis       27        
redislabs/redis                     Clustered in-memory database engine compatib…   40 
......

name        镜像名称
DESCRIPTION 镜像说明
STATRS      点赞数量
OFFICIAL    是否官方认证

docker search --limit 5 redis #搜索前五名

docker pull

下载镜像

docker pull 镜像名字[:TAG]  #没有TAG就是最新版

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

docker system df

查看镜像/容器/数据卷所占的空间
在这里插入图片描述

docker rmi

删除镜像

docker rmi -f 镜像ID                  #删除单个
docker rmi -f 镜像名1:TAG 镜像名2:TAG  #删除多个
docker rmi -f$(docker images -qa)    #删除全部

在这里插入图片描述

docker rm

删除下图中NAMES为redis的容器
在这里插入图片描述

 docker rm redis

在这里插入图片描述

容器命令

[root@localhost ~]# docker run --help

Usage:  docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
Create and run a new container from an image
Aliases:
  docker container run, docker run

Options:
  -i, --interactive                      Keep STDIN open even if not attached
  -t, --tty                              Allocate a pseudo-TTY
  -d, --detach                           Run container in background and print container ID

redis前台交互式启动

前台启动很容易被意外终止，窗口一关就没了

docker run -it redis:6.0.8

在这里插入图片描述
在这里插入图片描述

redis后台守护进程启动

docker run -d redis:6.0.8

在这里插入图片描述
查看容器内运行的进程
在这里插入图片描述

Nginx容器运行

在这里插入图片描述
保存拉取好的nginx镜像
在这里插入图片描述
删除nginx镜像，通过上一步保存好的nginx.tar包再将nginx加载回来
在这里插入图片描述
在这里插入图片描述
创建nginx容器

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

[root@localhost ~]# docker run -d --name nginx -p 80:80 nginx
c37c23e22fcb0001e16f0da7e4d23f7787673f1e222e788826ea843c55d26437

在这里插入图片描述

[root@localhost ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED              STATUS              PORTS                               NAMES
c37c23e22fcb   nginx     "/docker-entrypoint.…"   About a minute ago   Up About a minute   0.0.0.0:80->80/tcp, :::80->80/tcp   nginx

停掉nginx容器

docker stop nginx

在这里插入图片描述
在这里插入图片描述
启动nginx容器

docker start nginx

在这里插入图片描述
在这里插入图片描述
查看nginx日志

docker logs nginx

docker logs -f nginx    #持续刷新日志

进入nginx容器内部

docker exec -it nginx bash

在这里插入图片描述

ubuntu交互式运行

当我们直接使用docker run(不加任何参数)运行某个容器，使用ps命令查看容器状态时，STATUS显示的是‘Exited’，表示已经退出了。当我们希望有交互式的命令输入时，需要使用到‘-it’参数
在这里插入图片描述

docker run -it --name myubuntu2 ubuntu /bin/bash

交互式时，容器的状态是’Up’
在这里插入图片描述

tomcat交互式运行

docker run --name mytomcat2 -it tomcat:8.5.49

当运行完以上命令后，以下为截取的部分tomcat启动运行日志，可以看到tomcat启动成功了。

[root@localhost ~]# docker run --name mytomcat2 -it tomcat:8.5.49
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/openjdk-8
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
.......
ProtocolHandler ["http-nio-8080"]
11-Apr-2024 07:33:02.042 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"]
11-Apr-2024 07:33:02.058 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 571 ms

查看容器状态时，可以看到COMMAND为“catalina.sh run”, 此命令可以参考tomcat的Dockerfile
在这里插入图片描述
在这里插入图片描述

既然tomcat都启动成功了，那tomcat就可以访问了吗，此时我们访问下这个主机的8080端口试一下，
在这里插入图片描述
哦NO,汤姆小猫并没有出来，此时你需要对外暴露访问端口。

对外暴露访问端口

专用术语称之为端口映射，将宿主机的8080端口映射为8081，也就是对外我们访问8081端口就等于访问宿主机的8080端口。

docker run --name mytomcat3 -it -p 8081:8080 tomcat:8.5.49

  -p, --publish list    Publish a container's port(s) to the host
  # -p参数用于指定发布端口

[root@localhost ~]# docker run --name mytomcat3 -it -p 8081:8080 tomcat:8.5.49
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/openjdk-8
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
11-Apr-2024 07:45:24.267 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version name:   Apache Tomcat/8.5.49
11-Apr-2024 07:45:24.269 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server built:          Nov 17 2019 18:45:30 UTC
11-Apr-2024 07:45:24.269 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version number: 8.5.49.0
11-Apr-2024 07:45:24.269 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Name:               Linux
11-Apr-2024 07:45:24.269 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Version:            3.10.0-1160.el7.x86_64
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Architecture:          amd64
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Java Home:             /usr/local/openjdk-8/jre
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Version:           1.8.0_232-b09
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Vendor:            Oracle Corporation
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_BASE:         /usr/local/tomcat
11-Apr-2024 07:45:24.270 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_HOME:         /usr/local/tomcat
......

11-Apr-2024 07:45:24.990 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/usr/local/tomcat/webapps/manager] has finished in [16] ms
11-Apr-2024 07:45:24.998 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
11-Apr-2024 07:45:25.009 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"]
11-Apr-2024 07:45:25.013 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 594 ms

在这里插入图片描述

此时我们访问8081端口：
在这里插入图片描述
噢耶，Tomcat小猫咪出来了。

Dockerfile

Dockerfile 是用于构建 Docker 镜像的脚本文件，由一系列指令构成。通过 docker build命令构建镜像时，Dockerfile 中的指令会由上而下依次执行，每条指令都将会构建出一个镜像，这就是镜像的分层。因此指令越多，层次就越多，创建的镜像就越多，效率就越低。所以在定义 Dockerfile 时，能用一个指令完成的动作就不要分为两条。

对于 Dockerfile 的指令，需要注意以下几点：
 指令是大小写不敏感的，但惯例是写为全大写。
 指令后至少会携带一个参数。
 "#"号开头的为注释行

FROM：指定基础镜像
 【语法】FROM <image>[:<tag>]
 【解析】用于指定基础镜像，且必须是第一条指令；若省略了tag，则默认为 latest。

LABEL：指定镜像元数据
 【语法】LABEL <key>=<value> <key>=<value> „„
 【解析】LABEL 指令中可以以键值对的方式包含任意镜像的元数据信息，用于替代MAINTAINER 指令。
      通过 docker inspect 可查看到 LABEL 与 MAINTAINER 的内容。

ENV：设置环境变量
 【语法1】ENV <key> <value>
 【解析】用于指定环境变量，这些环境变量，后续可以被 RUN 指令使用，容器运行起来之后，也可以在容器中获取这些环境变量。

 【语法2】ENV <key1>=<value1> <key2>=<value2> ...
 【解析】可以设置多个变量，每个变量为一对<key>=<value>指定。

COPY：复制文本
 【说明】功能与 ADD 指令相同，只不过 src 不能是 URL。若 src 为压缩文件，复制到容器后不会自动解压。

ADD：复制和解包文件
 【语法 1】ADD <src> <dest>
 【语法 2】ADD ["<src>", "<dest>"] # 路径中存在空格时使用双引号引起来
 【解析】该指令将复制当前宿主机中指定文件 src 到容器中的指定目录 dest 中。src 可以是宿主机中的绝对路径，也可以时相对路径。
        但相对路径是相对于 docker build 命令所指定的路径的。src 指定的文件可以是一个压缩文件，压缩文件复制到容器后会自动解为  目录； 
        src 也可以是一个 URL，此时的 ADD 指令相当于 wget 命令；
        src 最好不要是目录，其会将该目录中所有内容复制到容器的指定目录中。
        dest 是一个绝对路径，其最后面的路径必须要加上斜杠，否则系统会将最后的目录名称当做是文件名的。

WORKDIR：指定工作目录
 【语法】WORKDIR path
 【解析】容器打开后默认进入的目录，一般在后续的 RUN、CMD、ENTRYPOINT、ADD 等指令中会引用该目录。
       可以设置多个 WORKDIR 指令。后续 WORKDIR 指令若用的是相对路径，
       则会基于之前 WORKDIR 指令指定的路径。
       在使用 docker run 运行容器时，可以通过-w 参数覆盖构建时所设置的工作目录。

RUN：执行shell命令
 【语法1】RUN <command>
 【解析】这里的<command>就是 shell 命令。docker build 执行过程中，会使用 shell 运行指定的 command。
 
 【语法2】RUN ["EXECUTABLE","PARAM1","PARAM2", ...]
 【解析】在 docker build 执行过程中，会调用第一个参数"EXECUTABLE"指定的应用程序运行，
       并使用后面第二、三等参数作为应用程序的运行参数。

CMD: 容器启动命令
 【语法1】CMD ["EXECUTABLE","PARAM1","PARAM2", ...]
 【解析】在容器启动后，即在执行完 docker run 后会立即调用执行"EXECUTABLE"指定的可执行文件，并使用后面第二、第三...等参数作为应用程序的运行参数。
 
 【语法 2】CMD command param1 param2, ...
 【解析】这里的 command 就是 shell 命令。在容器启动后会立即运行指定的 shell 命令。
 
 【语法 3】CMD ["PARAM1","PARAM2", ...]
 【解析】提供给 ENTERYPOINT 的默认参数。

run和cmd的区别：run是构建镜像时的命令，而cmd则是启动容器时的命令
在这里插入图片描述

ENTRYPOINT：入口点，功能类似于CMD,配置容器启动后执行的命令以及参数
 【语法1】ENTRYPOINT ["EXECUTABLE","PARAM1","PARAM2", ...]
 【解析】在容器启动过程中，即在执行 docker run 时，会调用执行"EXECUTABLE"指定的应用程序，并使用后面第二、第三...等参数作为应用程序的运行参数。
 
 【语法2】ENTRYPOINT command param1 param2, ...
 【解析】这里的 command 就是 shell 命令。在容器启动过程中，即在执行 docker run 时，会运行指定的 shell 命令。

EXPOSE: 暴露端口
 【语法】EXPOSE <port> [<port>...]
 【解析】指定容器准备对外暴露的端口号，但该端口号并不会真正的对外暴露。若要真正暴露，则需要在执行 docker run 命令时使用-p(小 p)来指定说要真正暴露出的端口号。

ONBUILD：子镜像引用父镜像的指令
 【语法】ONBUILD [INSTRUCTION] 
 【解析】该指令用于指定当前镜像的子镜像进行构建时要执行的指令。

VOLUME
 【语法】VOLUME ["dir1", "dir2", ...]
 【解析】在容器创建可以挂载的数据卷。

Docker网络模型

为了实现同一个宿主机以及跨宿主机的容器之间网络互联，Docker网络支持5种网络模式

1.none
2.bride
3.host
4.container
5.network-name

查看Docker默认的网络模式有三个

 docker network ls

在这里插入图片描述

网络模式指定

默认新建的容器使用Bridge模式，创建容器时，docker run命令使用以下选项指定网络模式格式

docker run --network <mode>
docker run --net=<mode>

<mode>: 可以是以下值
bridge
container：<容器名或容器ID>
host
none

docker run --network #再按两下Tab键
bridge      container:  host        ipvlan      macvlan     none        null        overlay

在这里插入图片描述

bridge网络模式

bridge网络模式概念
  1.bridge模式是docker默认的网络模式，即不指定任何模式就是bridge模式，也是使用比较多的模式；
  2.此模式创建的容器会为每一个容器分配自己的网络ip等信息，并将容器连接到一个虚拟网桥与外界通信；
  3.可以和外部网络之间进行通信，通过SNAT访问外网，使用DNAT可以让容器被外部主机访问，所以此模式也称为NAT模式。

bridge网络模式特点
  1.网络资源隔离：不同宿主机的容器无法直接通信，各自使用独立网络；
  2.无需手动配置：容器默认自动获取172.17.0.0/16的ip地址,此地址可以修改；
  3.可访问外网：利用宿主机的物理网卡，SNAT连接外网；
  4.外部主机无法直接访问容器：可以通过配置DNAT接受外网的访问；
  5.性能较低：因为需要通过NAT网络转换，所以会带来更多的损耗；
  6.端口管理繁琐：每个容器必须手动指定唯一的端口，容易产生端口冲突。

查看bridge模式信息

root@docker:~# docker network inspect bridge
[
    {
        "Name": "bridge",
        "Id": "700fc2656609bcbb19b0565c759eed7368e3d29d1f9b02f78a0701a653312431",
        "Created": "2024-05-28T01:33:04.396608546Z",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "c0f5460d0bb5d3ea015707c612f1a903083e0b1da7fd9093d33f282cb4215899": {
                "Name": "wordpress",
                "EndpointID": "38ed58998c8c76f70c10059967cbc4be891799f36a254b5355c62fd026e27e22",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

Host模式

Host模式概念
  1.如果指定host模式启动容器，那么新创建的容器不会创建自己的虚拟网卡，而是直接使用宿主机的网卡和IP地址，
  2.因此在容器里面查看到的IP信息就是宿主机的信息，
  3.访问容器的时候直接使用宿主机IP+容器端口即可，
  4.不过容器内除网络以外的其他资源，如：文件系统，系统进程等仍然和宿主机保持隔离。

Host模式特点
  1.使用参数-network host指定
  2.共享宿主机网络
  3.网络性能无损耗
  4.网络故障排除相对简单
  5.个容器网络无隔离
  6.网络字段无法分别统计
  7.端口管理困难，容易产生端口冲突
  8.不支持端口映射

发布自己的应用

发布一个Java的hello world

@RestController()
public class HelloWorld {

    @GetMapping("/hello")
     public String hello(){
        System.out.println("++++++++++Java: Hello Dockerfile+++++++++++++");
         return "Java: hello world Dockerfile";
     }
}

编写完成后，打包成jar包(HelloDocker.jar)上传到linux上的某个目录下
在这里插入图片描述
编写Dockerfile

FROM openjdk:8u102
LABEL auth="leilei" email="2369005098@qq.com" version="1.0"
COPY HelloDocker.jar HelloJava.jar
ENTRYPOINT ["java","-jar","HelloJava.jar"]
EXPOSE 8080

构建镜像
在这里插入图片描述

运行镜像，对外暴露9003端口

[root@localhost java]# docker run --name hello -dp 9003:8080 hello-jave:1.1
6b0d0439511e085faa34ef24515406602b89cc3e7e260570f9c8f4b9d25dbdf4

在这里插入图片描述
进入到容器里面查看
在这里插入图片描述
查看容器日志
在这里插入图片描述
浏览器访问我暴露出的9003端口
在这里插入图片描述
ok，java的hello world的小应用程序就以docker容器的方式运行成功了。

Mysql和Redis的Docker安装

Mysql

可以参考docker-hub的官方安装命令docker-hub-mysql
在这里插入图片描述

docker run --name mysql -dp 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

在这里插入图片描述
在这里插入图片描述

MySQL生产安装

为了保证数据的安全性，在生产环境下安装的 mysql 容器，在启动时都会使用数据卷来持久化数据。

docker run --name mysql \
-e MYSQL_ROOT_PASSWORD=root \
-v /root/mysql/data:/var/lib/mysql \
-v /root/mysql/log:/var/log/mysql \
-v /root/mysql/conf:/etc/mysql/conf.d \
-dp 3306:3306 \
mysql:5.7

在这里插入图片描述

MySQL集群安装

安装master容器

第一步：启动master容器，指定数据卷路径

docker run --name mysql_master \
-e MYSQL_ROOT_PASSWORD=root \
-v /root/mysql_master/data:/var/lib/mysql \
-v /root/mysql_master/log:/var/log/mysql \
-v /root/mysql_master/conf:/etc/mysql/conf.d \
-dp 3316:3306 \
mysql:5.7

第二步： 新建 my.cnf

[client]
default_character_set=utf8

[mysql]
default_character_set=utf8

[mysqld]
character_set_server=utf8

server_id=01
binlog-ignore-db=mysql
log-bin=master-log-bin
binlog_cache_size=1M
binlog_format=mixed
expire_logs_days=7
slave_skip_errors=1062

第三部：创建用户

mysql> create user 'slave'@'%' identified by '123456';
Query OK, 0 rows affected (0.00 sec)

第四步：给用户赋予权限

mysql> grant replication slave,replication client on *.* to 'slave'@'%';
Query OK, 0 rows affected (0.01 sec)

第五步：查看该用户权限

mysql> show grants for 'slave'@'%';
+-------------------------------------------------------------------+
| Grants for slave@%                                                |
+-------------------------------------------------------------------+
| GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%' |
+-------------------------------------------------------------------+
1 row in set (0.00 sec)

安装slave容器

第一步：启动slave容器，指定数据卷路径

docker run --name mysql_slave \
-e MYSQL_ROOT_PASSWORD=root \
-v /root/mysql_slave/data:/var/lib/mysql \
-v /root/mysql_slave/log:/var/log/mysql \
-v /root/mysql_slave/conf:/etc/mysql/conf.d \
-dp 3326:3306 \
mysql:5.7

第二步：新建my.cnf

[client]
default_character_set=utf8

[mysql]
default_character_set=utf8

[mysqld]
character_set_server=utf8

server_id=02
binlog-ignore-db=mysql
log-bin=slave-log-bin
binlog_cache_size=1M
binlog_format=mixed
expire_logs_days=7
slave_skip_errors=1062
relay_log=relay-log-bin
log_slave_updates=1
read_only=1

第三部：进入容器连接mysql

[root@localhost conf]# docker exec -it mysql_slave /bin/bash
bash-4.2# mysql -uroot -p 
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.44-log MySQL Community Server (GPL)

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

配置主从复制

1.查看master状态

mysql> show master status;
+-----------------------+----------+--------------+------------------+-------------------+
| File                  | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+-----------------------+----------+--------------+------------------+-------------------+
| master-log-bin.000001 |      617 |              | mysql            |                   |
+-----------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

2.slave 指定 master
在 slave 中通过运行 change master to 命令来指定其要连接的 master 相关信息。

mysql> change master to master_host='10.0.0.226',master_user='slave',master_password='123456',master_port=3316,master_log_file='master-log-bin.000001',master_log_pos=617,master_connect_retry=30,master_retry_count=3;
Query OK, 0 rows affected, 2 warnings (0.01 sec)

mysql> show slave status \G;
*************************** 1. row ***************************
               Slave_IO_State: 
                  Master_Host: 10.0.0.226
                  Master_User: slave
                  Master_Port: 3316
                Connect_Retry: 30
              Master_Log_File: master-log-bin.000001
          Read_Master_Log_Pos: 617
               Relay_Log_File: relay-log-bin.000001
                Relay_Log_Pos: 4
        Relay_Master_Log_File: master-log-bin.000001
             Slave_IO_Running: No
            Slave_SQL_Running: No
              Replicate_Do_DB: 
          Replicate_Ignore_DB: 
           Replicate_Do_Table: 
       Replicate_Ignore_Table: 
      Replicate_Wild_Do_Table: 
  Replicate_Wild_Ignore_Table: 
                   Last_Errno: 0
                   Last_Error: 
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 617
              Relay_Log_Space: 154
              Until_Condition: None
               Until_Log_File: 
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File: 
           Master_SSL_CA_Path: 
              Master_SSL_Cert: 
            Master_SSL_Cipher: 
               Master_SSL_Key: 
        Seconds_Behind_Master: NULL
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error: 
               Last_SQL_Errno: 0
               Last_SQL_Error: 
  Replicate_Ignore_Server_Ids: 
             Master_Server_Id: 0
                  Master_UUID: 
             Master_Info_File: /var/lib/mysql/master.info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: 
           Master_Retry_Count: 3
                  Master_Bind: 
      Last_IO_Error_Timestamp: 
     Last_SQL_Error_Timestamp: 
               Master_SSL_Crl: 
           Master_SSL_Crlpath: 
           Retrieved_Gtid_Set: 
            Executed_Gtid_Set: 
                Auto_Position: 0
         Replicate_Rewrite_DB: 
                 Channel_Name: 
           Master_TLS_Version: 
1 row in set (0.00 sec)
ERROR: 
No query specified

3.开启slave

start slave;

在这里插入图片描述
此时master和slave已经完成了主从复制，在master上新建一个数据库和数据表已经即时同步到slave上了。

再次验证主从是否读写分离，master可以读写数据，slave只能读数据。
验证slave节点上能否插入数据
在这里插入图片描述
查看master上是否有slave插入的数据。master上自然不会有Tony这条数据。
在这里插入图片描述
问题所在
slave上可以写数据，因为我们在配置文件中设置的是slave用户的只读权限，而slave节点上我们用的是root用户登录的。此时我们可以设置super用户为只读权限则slave节点就不能插入数据了。

mysql> set global super_read_only=1;
Query OK, 0 rows affected (0.00 sec)

在这里插入图片描述
在这里插入图片描述

Redis

单机安装Redis

docker run --name myredis \
-v /root/redis/redis.conf:/etc/redis/redis.conf \
-v /root/redis/data:/data \
-dp 6379:6379 \
redis:7.0 \
redis-server /etc/redis/redis.conf

在这里插入图片描述
在这里插入图片描述
进入redis容器
在这里插入图片描述

Redis一主两从集群搭建

现要搭建一个“一主两从”的 Redis 集群。这三个容器的端口号都保持默认，但对外暴露出的端口号分别为 6381、6382、6383。其中，6381 的为 master，另外两个为 slave。

1.复制三份 redis.conf
在两个slave的redis.conf上加上两个如下配置

slave-announce-ip ip地址
slave-announce-port 端口号

在这里插入图片描述
在这里插入图片描述

2.启动master容器

docker run --name myredis-1 \
-v /root/redis/redis1.conf:/etc/redis/redis.conf \
-v /root/redis/data/6381:/data \
-dp 6381:6379 \
redis:7.0 \
redis-server /etc/redis/redis.conf

在这里插入图片描述

启动slave容器
myredis-2

docker run --name myredis-2 \
-v /root/redis/redis2.conf:/etc/redis/redis.conf \
-v /root/redis/data/6382:/data \
-dp 6382:6379 \
redis:7.0 \
redis-server /etc/redis/redis.conf --slaveof 10.0.0.227 6381

在这里插入图片描述
myredis-3

docker run --name myredis-3 \
-v /root/redis/redis3.conf:/etc/redis/redis.conf \
-v /root/redis/data/6383:/data \
-dp 6383:6379 \
redis:7.0 \
redis-server /etc/redis/redis.conf --slaveof 10.0.0.227 6381

在这里插入图片描述
查看主从关系
master节点上
在这里插入图片描述
slave节点上
在这里插入图片描述
验证主从是否同步，在master上set一个值之后，两个slave节点可以直接get到
在这里插入图片描述

Redis 高可用集群搭建

主从集群存在的问题是，其容灾方式只能采用冷处理方案，无法在生产中使用。所以这里要搭建一个“一主两从三哨兵”的高可用集群，以达到热处理的容灾方案。

对于“一主两从”集群，仍使用前面的即可。下面直接搭建三个 Sentinel 节点的集群。
这三个容器的端口号都保持默认，但对外暴露出的端口号分别为 26381、26382、26383。

1.复制三份 sentinel.conf
复制 sentinel.conf 文件并重命名为 sentinel1.conf。
仅修改两处：

1.指定其要监视的 master 及<quorum>。
2.指定当前 sentinel 对外宣布的 IP 与端口号。其中 IP 为 docker 宿主机的 IP，端口号为其对外暴露的端口号。

2.启动 sentinel
2.1启动mysentinel-1

docker run --name mysentinel-1 \
-v /root/redis/sentinel1.conf:/etc/redis/sentinel.conf \
-dp 26381:26379 \
redis:7.0 \
redis-sentinel /etc/redis/sentinel.conf

在这里插入图片描述
2.2启动mysentinel-2

docker run --name mysentinel-2 \
-v /root/redis/sentinel2.conf:/etc/redis/sentinel.conf \
-dp 26382:26379 \
redis:7.0 \
redis-sentinel /etc/redis/sentinel.conf

在这里插入图片描述

2.3启动mysentinel-3

docker run --name mysentinel-3 \
-v /root/redis/sentinel3.conf:/etc/redis/sentinel.conf \
-dp 26383:26379 \
redis:7.0 \
redis-sentinel /etc/redis/sentinel.conf

在这里插入图片描述
关系查看
在这里插入图片描述
以上命令的查看结果说明 sentinel 对 master 的监视成功，说明高可用集群搭建成功。连
接任何一个 sentinel 容器节点查看到的信息与上面的都是相同的。
在这里插入图片描述

故障转移测试

为了验证高可用性，现将充当 master 的容器 myredis-1 停掉。

此时，再查看另外两个 redis 容器的状态数据，发现 myredis-2 成为了 myredis-3 的 slave，
在这里插入图片描述
myredis-3 成为了新的 master

在这里插入图片描述
此时再次启动myredis-1时，发现它成了myredis-3的slave节点
在这里插入图片描述
在这里插入图片描述

Docker compose

Docker Compose是Docker一个用于定义和管理多容器的容器编排工具
。通过使用Docker Compose，可以在单个YAML文件中配置应用的服务、网络和卷等，简化了多容器应用的部署和管理。解决了手动部署容器的弊端。

安装Docker compose

curl -SL https://github.com/docker/compose/releases/download/v2.26.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

在这里插入图片描述
赋予docker-compose执行权限
在这里插入图片描述

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

手工启动项目的步骤

现有java项目ssrm，windows本地运行结果如下
在这里插入图片描述
将项目在windows下使用到的mysql和redis全部转换成linux下的服务，10.0.0.227为我虚拟机的ip，此台机器上安装了mysql3306和redis6379
在这里插入图片描述
1.构建镜像
将项目打包成ssrm.jar,编写Dockerfile将其构建成finance:1.0镜像.
在这里插入图片描述

在这里插入图片描述
2.运行镜像
因为本java项目需要mysql和redis环境，所以我们最先运行了mysql和redis容器，此时我们先后手动启动了三个容器。我对外暴露9000的访问端口。
在这里插入图片描述
3.访问项目
在这里插入图片描述
项目已经基于容器的方式运行成功了。redis中也是有数据写入的。
在这里插入图片描述
访问日志也是正常的
在这里插入图片描述

手工启动项目的弊端

手工启动项目不仅繁琐易错，而且还存在一个致命问题：当前应用访问的 mysql 与 redis只能是运行在当前 Docker 宿主机之上的，否则将无法访问到它们。因为在应用的配置文件中已经将 mysql 与 redis 的 IP 进行了硬编码。而使用 Docker Compose 可以解决所有问题

Docker Compose的主要特性

Docker Compose的主要特性
  1.简化多容器应用的管理：
      使用Compose可以通过单个命令来启动、停止和管理多个容器，而不需要单独管理每个容器。

  2.使用YAML文件配置：
      Compose使用docker-compose.yml文件来定义应用服务、网络和卷的配置，易于阅读和维护。

  3.服务依赖管理：
      Compose允许您定义服务之间的依赖关系，确保服务按照正确的顺序启动和停止。

  4.环境变量支持：
      可以通过.env文件或在docker-compose.yml中使用环境变量，方便配置不同环境的参数。

  5.扩展和缩减服务：
      Compose支持通过命令轻松扩展或缩减服务的实例数量，以适应负载变化。

docker-compose常用命令

常用命令：
  docker-compose up：启动服务。
  docker-compose down：停止并删除服务。
  docker-compose ps：查看运行中的服务。
  docker-compose logs：查看服务日志。

Compose 编排启动项目

1.定义 compose.yml

services:
  app:
    build: ./
    container_name: myapp
    ports:
      - 9001:8080
    volumes:
      - ./logs:/var/applogs
    depends_on:
      - mysql
      - redis

  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root
    ports:
      - 3306:3306
    volumes:
      - /root/mysql/log:/var/log/mysql
      - /root/mysql/data:/var/log/mysql
      - /root/mysql/conf:/etc/mysql/conf.d

  redis:
    image: redis:7.0
    ports:
      - 6379:6379
    volumes:
      - /root/redis/redis.conf:/etc/redis/redis.conf
      - /root/redis/data:/data
    command: redis-server /etc/redis/redis.conf

修改application.yml配置文件
将 mysql 与 redis 的主机名修改为它们相应服务的名称。
在这里插入图片描述
之后重新打包上传
在这里插入图片描述

2.启动所有容器

docker-compose up -d

在这里插入图片描述
访问应用
Docker compose已经成功将项目运行起来了。
在这里插入图片描述
在这里插入图片描述
错误排查，可能会遇到端口占用的情况
在这里插入图片描述

3.指定各组件名称

compose2.yml

services:
  app:
    build: ./
    image: finance:3.0
    container_name: myapp
    ports:
      - 9001:8080
    volumes:
      - ./logs:/var/applogs
    networks:
      - ab
    depends_on:
      - leimysql
      - leiredis

  leimysql:
    image: mysql:5.7
    container_name: lmysql
    environment:
      MYSQL_ROOT_PASSWORD: root
    ports:
      - 3306:3306
    volumes:
      - /root/mysql/log:/var/log/mysql
      - /root/mysql/data:/var/log/mysql
      - /root/mysql/conf:/etc/mysql/conf.d
    networks:
      - ab

  leiredis:
    image: redis:7.0
    container_name: lredis
    ports:
      - 6379:6379
    volumes:
      - /root/redis/redis.conf:/etc/redis/redis.conf
      - /root/redis/data:/data
    networks:
      - ab
    command: redis-server /etc/redis/redis.conf

networks:
  ab:

因为指定了的各个组件的别名redis别名为leiredis，mysql别名为leimysql，所以java程序需要修改相应的服务名后重新打包
在这里插入图片描述

docker-compose -f compose2.yml up -d

在这里插入图片描述
指定自定义的服务名后，程序访问仍然是正常的
在这里插入图片描述

4.查看项目的Docker网络

docker network inspect finance_ab

[root@localhost finance]# docker network inspect finance_ab
[
    {
        "Name": "finance_ab",
        "Id": "468e5c3d0b3bc73ff5060c5db8929a0ee2f5fef8a51051d682d92e073de6eb5e",
        "Created": "2024-05-08T11:51:34.792743101+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.19.0.0/16",
                    "Gateway": "172.19.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "29d4052b7322b7a3e3eb06702566ff06376656a0c884fc9ec6b5fc8c7644fb0b": {
                "Name": "lmysql",
                "EndpointID": "f25454ba1da32168c709c7853d582a5cd6b5b1c9afd6894d375c1ded5c2581ab",
                "MacAddress": "02:42:ac:13:00:03",
                "IPv4Address": "172.19.0.3/16",
                "IPv6Address": ""
            },
            "4732bdaaa453065cee1eade619381f5baff9e63d8ce75d8abde5cf15c70596d2": {
                "Name": "lredis",
                "EndpointID": "c4da3f083e4e4f980b8ac96375cd29559c4fe52363ef6d936481a89f0d839332",
                "MacAddress": "02:42:ac:13:00:02",
                "IPv4Address": "172.19.0.2/16",
                "IPv6Address": ""
            },
            "60f6dead3dbca7a7e30eeb72d9b06c20d3f1bc6aaabf73d33d87bd2418f45ba0": {
                "Name": "myapp",
                "EndpointID": "05459a3e0349be81c79232a770683e27fbaedcf26fae046ed674116e6ea8967e",
                "MacAddress": "02:42:ac:13:00:04",
                "IPv4Address": "172.19.0.4/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {
            "com.docker.compose.network": "ab",
            "com.docker.compose.project": "finance",
            "com.docker.compose.version": "2.26.1"
        }
    }
]

5.管理服务

docker-compose down                      停止服务
docker-compose ps                        查看服务状态
docker-compose up --scale leimysql=3     扩展服务实例（例如，增加两个Mysql实例）：

Docker管理监控平台

DockerUI

docker run -d -p 7000:9000 -v /var/run/docker.sock:/var/run/docker.sock uifd/ui-for-docker

在这里插入图片描述
访问管理页面
在这里插入图片描述

Portainer

Portainer安装文档

Portainer可以管理集群，

docker volume create portainer_data

在这里插入图片描述

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

在这里插入图片描述
访问portainer管理页面：ip+端口号(10.0.0.227:7100)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Harbor镜像中心

安装Harbor

 wget https://github.com/goharbor/harbor/releases/download/v2.7.1/harbor-offline-installer-v2.7.1.tgz

访问Harbor镜像管理中心，配置文件里默认80端口
在这里插入图片描述
在这里插入图片描述

Harbor的高可用

Harbor高可用实现方案
   1.两台Harbor主机，一台nginx主机，
   2.两台Harbor主机相互同步，nginx主机做负载均衡，使用户无感知切换两台Harbor主机。

Harbor安装脚本来自马哥教育王晓春老师
此脚本我在Ubuntu20.04上执行成功了，在RockyLinx8.5中执行失败

#!/bin/bash
#
#********************************************************************
#Author:            wangxiaochun
#Date:              2020-02-04
#FileName:          install_harbor.sh
#URL:               http://www.wangxiaochun.com
#Description:       The test script
#Copyright (C):     2020 All rights reserved
#********************************************************************

DOCKER_VERSION="20.10.10"
UBUNTU_DOCKER_VERSION="5:${DOCKER_VERSION}~3-0~`lsb_release -si`-`lsb_release -cs`"
DOCKER_COMPOSE_VERSION=2.6.1
#DOCKER_COMPOSE_VERSION=1.29.2
DOCKER_COMPOSE_FILE=docker-compose-Linux-x86_64
HARBOR_VERSION=2.5.2
HARBOR_BASE=/apps
HARBOR_NAME=harbor.magedu.org
#HARBOR_NAME=`hostname -I|awk '{print $1}'`
HARBOR_IP=`hostname -I|awk '{print $1}'`
HARBOR_ADMIN_PASSWORD=123456

COLOR_SUCCESS="echo -e \\033[1;32m"
COLOR_FAILURE="echo -e \\033[1;31m"
END="\033[m"

. /etc/os-release

color () {
    RES_COL=60
    MOVE_TO_COL="echo -en \\033[${RES_COL}G"
    SETCOLOR_SUCCESS="echo -en \\033[1;32m"
    SETCOLOR_FAILURE="echo -en \\033[1;31m"
    SETCOLOR_WARNING="echo -en \\033[1;33m"
    SETCOLOR_NORMAL="echo -en \E[0m"
    echo -n "$1" && $MOVE_TO_COL
    echo -n "["
    if [ $2 = "success" -o $2 = "0" ] ;then
        ${SETCOLOR_SUCCESS}
        echo -n $"  OK  "    
    elif [ $2 = "failure" -o $2 = "1"  ] ;then 
        ${SETCOLOR_FAILURE}
        echo -n $"FAILED"
    else
        ${SETCOLOR_WARNING}
        echo -n $"WARNING"
    fi
    ${SETCOLOR_NORMAL}
    echo -n "]"
    echo 
}


install_docker(){
    if [ $ID = "centos" -o $ID = "rocky" ];then
        if [ $VERSION_ID = "7" ];then
            cat >  /etc/yum.repos.d/docker.repo  <<EOF
[docker]
name=docker
gpgcheck=0
#baseurl=https://mirrors.aliyun.com/docker-ce/linux/centos/7/x86_64/stable/
baseurl=https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/7/x86_64/stable/
EOF
        else     
            cat >  /etc/yum.repos.d/docker.repo  <<EOF
[docker]
name=docker
gpgcheck=0
#baseurl=https://mirrors.aliyun.com/docker-ce/linux/centos/8/x86_64/stable/
baseurl=https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/8/x86_64/stable/
EOF
        fi
	    yum clean all 
        ${COLOR_FAILURE} "Docker有以下版本"${END}
        yum list docker-ce --showduplicates
        ${COLOR_FAILURE}"5秒后即将安装: docker-"${DOCKER_VERSION}" 版本....."${END}
        ${COLOR_FAILURE}"如果想安装其它Docker版本，请按ctrl+c键退出，修改版本再执行"${END}
        sleep 5
        yum -y install docker-ce-$DOCKER_VERSION docker-ce-cli-$DOCKER_VERSION  \
            || { color "Base,Extras的yum源失败,请检查yum源配置" 1;exit; }
    else
	    dpkg -s docker-ce &> /dev/null && $COLOR"Docker已安装，退出" 1 && exit
        apt update || { color "更新包索引失败" 1 ; exit 1; }  
        apt  -y install apt-transport-https ca-certificates curl software-properties-common || \
            { color "安装相关包失败" 1 ; exit 2;  }  
        curl -fsSL https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
        add-apt-repository "deb [arch=amd64] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
        apt update
        ${COLOR_FAILURE} "Docker有以下版本"${END}
        apt-cache madison docker-ce
        ${COLOR_FAILURE}"5秒后即将安装: docker-"${UBUNTU_DOCKER_VERSION}" 版本....."${END}
        ${COLOR_FAILURE}"如果想安装其它Docker版本，请按ctrl+c键退出，修改版本再执行"${END}
        sleep 5
        apt -y  install docker-ce=${UBUNTU_DOCKER_VERSION} docker-ce-cli=${UBUNTU_DOCKER_VERSION}
    fi
    if [ $? -eq 0 ];then
        color "安装软件包成功"  0
    else
        color "安装软件包失败，请检查网络配置" 1
        exit
    fi
        
    mkdir -p /etc/docker
    tee /etc/docker/daemon.json <<-'EOF'
{
	  "registry-mirrors": ["https://si7y70hh.mirror.aliyuncs.com"],
	  "insecure-registries":["harbor.magedu.org:80"]
}
EOF
    systemctl daemon-reload
    systemctl enable docker
    systemctl restart docker
    docker version && color "Docker 安装成功" 0 ||  color "Docker 安装失败" 1
	echo 'alias rmi="docker images -qa|xargs docker rmi -f"' >> ~/.bashrc
	echo 'alias rmc="docker ps -qa|xargs docker rm -f"' >> ~/.bashrc
}



install_docker_compose(){
    if [ $ID = "centos" -o $ID = "rocky" ];then
        ${COLOR_SUCCESS}"开始安装 Docker compose....."${END}
        sleep 1
        if [ ! -e  ${DOCKER_COMPOSE_FILE} ];then
            #curl -L https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_VERSION}/${DOCKER_COMPOSE_FILE} -o /usr/bin/docker-compose
            curl -L https://get.daocloud.io/docker/compose/releases/download/v${DOCKER_COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m) -o /usr/bin/docker-compose
        else
            mv ${DOCKER_COMPOSE_FILE} /usr/bin/docker-compose
        fi
        chmod +x /usr/bin/docker-compose
    else 
        apt -y install docker-compose
    fi
    if docker-compose --version ;then
        ${COLOR_SUCCESS}"Docker Compose 安装完成"${END} 
    else
        ${COLOR_FAILURE}"Docker compose 安装失败"${END}
        exit
    fi
}

install_harbor(){
    ${COLOR_SUCCESS}"开始安装 Harbor....."${END}
    sleep 1
    if  [ ! -e  harbor-offline-installer-v${HARBOR_VERSION}.tgz ] ;then
        wget https://github.com/goharbor/harbor/releases/download/v${HARBOR_VERSION}/harbor-offline-installer-v${HARBOR_VERSION}.tgz || ${COLOR_FAILURE} "下载失败!" ${END}
    fi
    [ -d ${HARBOR_BASE} ] ||  mkdir ${HARBOR_BASE}
    tar xvf harbor-offline-installer-v${HARBOR_VERSION}.tgz  -C ${HARBOR_BASE}
    cd ${HARBOR_BASE}/harbor
    cp harbor.yml.tmpl harbor.yml
    sed -ri "/^hostname/s/reg.mydomain.com/${HARBOR_NAME}/" harbor.yml
    sed -ri "/^https/s/(https:)/#\1/" harbor.yml
    sed -ri "s/(port: 443)/#\1/" harbor.yml
    sed -ri "/certificate:/s/(.*)/#\1/" harbor.yml
    sed -ri "/private_key:/s/(.*)/#\1/" harbor.yml
    sed -ri "s/Harbor12345/${HARBOR_ADMIN_PASSWORD}/" harbor.yml
    sed -i 's#^data_volume: /data#data_volume: /data/harbor#' harbor.yml
    #mkdir -p /data/harbor
    ${HARBOR_BASE}/harbor/install.sh && ${COLOR_SUCCESS}"Harbor 安装完成"${END} ||  ${COLOR_FAILURE}"Harbor 安装失败"${END}
    cat > /lib/systemd/system/harbor.service <<EOF
[Unit]
Description=Harbor
After=docker.service systemd-networkd.service systemd-resolved.service
Requires=docker.service
Documentation=http://github.com/vmware/harbor

[Service]
Type=simple
Restart=on-failure
RestartSec=5
ExecStart=/usr/bin/docker-compose -f  ${HARBOR_BASE}/harbor/docker-compose.yml up
ExecStop=/usr/bin/docker-compose -f ${HARBOR_BASE}/harbor/docker-compose.yml down

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload 
systemctl enable  harbor &>/dev/null ||  ${COLOR}"Harbor已配置为开机自动启动"${END}
    if [ $?  -eq 0 ];then  
        echo 
        color "Harbor安装完成!" 0
        echo "-------------------------------------------------------------------"
        echo -e "请访问链接: \E[32;1mhttp://${HARBOR_IP}/\E[0m" 
		echo -e "用户和密码: \E[32;1madmin/${HARBOR_ADMIN_PASSWORD}\E[0m" 
    else
        color "Harbor安装失败!" 1
        exit
    fi 
}

docker info  &> /dev/null  && ${COLOR_FAILURE}"Docker已安装"${END} || install_docker

docker-compose --version &> /dev/null && ${COLOR_FAILURE}"Docker Compose已安装"${END} || install_docker_compose

install_harbor

两台主机之间怎么拷贝文件
在这里插入图片描述
root用户可以直接执行普通lei用户下的文件
在这里插入图片描述
脚本执行完了，docker，docker-compose，harbor都安装好了
在这里插入图片描述

flytalei
关注
专栏目录
jenkins教程+docker容器实际项目实战教程.pdf
07-26
jenkins教程+docker容器实际项目实战教程.pdf jenkins教程+docker容器实际项目实战教程.pdf
Docker超详细教程——入门篇+实战
热门推荐
Alex_yuan666的博客
07-12 3万+
docker入门详细教程，包含常用环境实战，每一步都是我安装验证过的
Docker入门教程（非常详细）从零基础入门到精通，看完这一篇就够了
2401_87298680的博客
09-21 2101
开发了一个项目 可以在本机运行 但是如果版本更新 可能就会导致服务不可使用 后期我们维护起来就很繁琐 因为对于每一个机器 我们都得进行环境的部署呀 配置呀什么的比如： 我在window系统下开发了一个项目（jar+redis+ES+Kafka+...） 但是我现在准备部署到服务器上去 因为不能夸平台 所以我还得重新去按照配置环境什么的 但是docker 就可以让我们 直接将项目打包然后部署上线了 不用一个个单独去维护。Docker图形化界面管理工具！提供一个后台面板供我们操作！类似于 宝塔面板。
Docker 实战
akumalzw的专栏
10-20 1334
Docker 实战
docker入门及实战（纯干货）
qq_44791614的博客
07-06 2109
要切记，对容器的变更是写入到容器的文件系统的，而不是写入到Docker镜像中的。一个镜像可以对应多个不同的容器，这是因为容器在运行时会加上一些自己的可变数据，这些数据会被写入到镜像中，因此不同的容器可以在不同的环境中运行（例如不同的操作系统、不同的应用场景等）。而容器是动态的，类似于运行代码的进程，是基于镜像创建的，包含了镜像和运行时的可变数据。总之，Docker镜像和容器是Docker容器化技术的两个重要概念，它们之间的关系类似于代码和进程之间的关系，镜像是静态的、不可变的，而容器是动态的、可变的。
【Docker】Docker 项目实战
Dragon的博客
08-20 1474
想要在开发环境能够结合 maven 自动化构建镜像，就需要先给你自己的电脑安装一个 Docker，目前 Docker 针对 Windows 和 Mac 平台都推出了 Desktop 桌面版本，直接按照官方文档安装即可。官方文档：https://docs.docker.com/desktop/install/windows-install/
docker 入门实战
11-10
Docker是一个开源的引擎，可以轻松的为任何应用创建一个轻量级的、可移植的、自给自足的容器。开发者在笔记本上编译测试通过的容器可以批量地在生产环境中部署，包括VMs（虚拟机）、bare metal、OpenStack 集群和...
docker入门实战
04-04
docker入门指南docker入门指南docker入门指南docker入门指南docker入门指南
Java基础进阶 Docker入门+实战-视频教程网盘链接提取码下载 .txt
02-22
本套视频是主要针对微服务架构落地解决技术...通过学习Docker能够完成对：微服务监控告警架构、微服务自动化部署、微服务之日志收集与性能监控、微服务之自动化测试与质量管理等架构的落地技术实现。 视频大小： 1.1G
Docker 入门教程 - GBase 8a
最新发布
10-31
南大通用大规模分布式并行数据库集群系统，简称：GBase8a MPP Cluster，它是在 GBase 8a 列存储数据库基础上开发的一款 Shared Nothing 架构的分布式并行数据库集群，具备高性能、高可用、高扩展特性，可以为超大...
Docker——入门实战 - 等一杯咖啡的博客 - CSDN博客1
08-03
简介Docker是种新兴的虚拟化技术，能够定程度上的代替传统虚拟机。不过，Docker 跟传统的虚拟化式相具有众多的优势。境，可以有效的配置各个版本的开发环境，
Docker基础入门实战（一）
lgxzzz的博客
02-21 1160
Docker基础入门实战（一）https://blog.51cto.com/lzhnb/2153225 Docker基础入门实战第1章          docker简介1.1  what is DockerDocker是一个开源的应用容器引擎，基于Go语言并遵从Apache2.0协议开源，源代码部署在GitHub上.
nginx的安装（亲测）
影子
04-13 1675
先安装虚拟机，和cnetos7mini版本 虚拟机的安装省略，可以参考前面： 注意：centos7之前是ipconfig查看网络，7以后就变成ip addr 本地的网卡：IO，虚拟出来的网卡是eno16777736，但是没有ip地址 修改网卡： vi /etc/sysconfig/network-scripts/ifcfg-eno16777736 要用root用户修改 重启网络服务： systemctl restart network 重启失败： 输入：jour..
Docker虚拟化平台实战
海浪—华的博客
03-15 1677
Docker虚拟化平台实战
Docker实战
m0_74444744的博客
11-08 274
Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口 Docker 是 PaaS 提供商 dotCloud 开源的一个基于 LXC 的高级容器引擎，源代码托管在 Github 上, 基于go语言并遵从Apache2.0协议开源。 Docker自2013年以来非常火热，无论是从 github 上的代码活跃度，还是Redhat在RH
Docker项目实战
左手代码右手诗
11-17 922
docker项目实战
Docker入门基础使用教程汇总（全是干货，简单实用）
liuwfeii的专栏
07-24 1万+
微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题1.1.1.应用部署的环境问题依赖关系复杂，容易出现兼容性问题开发、测试、生产环境有差异正在上传…重新上传取消例如一个项目中，部署时需要依赖于node.js、Redis、RabbitMQ、MySQL等，这些服务部署时所需要的函数库、依赖项各不相同，甚至会有冲突。给部署带来了极大的困难。
Docker入门实战：从基础到实战教程
《Docker入门实战》是一本由国内Docker社区DocKOne.io推出的实用教程，专为国内Docker爱好者打造，内容全面，涵盖了Docker的基础概念、安装与配置、实战应用、安全管理以及高级技术如Dockerfile、Docker Compose、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值