Docker相关开发环境安装

---

前言

以下是docker 相关环境安装部署集合，记录一下方便使用！

---

提示：以下是本篇文章正文内容，下面案例可供参考

Linux系统

1.更新系统

yum update

2.修改系统时间时区

• 添加时间

yum -y install chrony

• 启动时间插件

systemctl enable chronyd

• 设置时区

timedatectl set-timezone Asia/Shanghai

• 查看当前时间

date

3.关闭防火墙

视情况是否关闭

1、命令行界面输入命令“systemctl status firewalld.service”并按下回车键。

systemctl status firewalld.service

2、然后在下方可度以查看得到“active（running）”，此时说明防火墙已经被打开了。

3、在命令行中输入systemctl stop firewalld.service命令，进行关闭防火墙。

systemctl stop firewalld.service

注意:需要root权限才能关闭

4、然后再使用命令systemctl status firewalld.service，在下方出现disavtive（dead），这样就说明防火墙已经关闭。

systemctl status firewalld.service

5、再在命令行中输入命令“systemctl disable firewalld.service”命令，即可永久关闭防火墙。

systemctl disable firewalld.service

4.linux 笔记本不休眠

1. 找到配置文件

/etc/systemd/logind.conf，使用vim命令打开

vim /etc/systemd/logind.conf

2. 修改配置

配置文件中找到我们要修改的配置项：

• HandlePowerKey 按下电源键后的行为，默认power off
• HandleSleepKey 按下挂起键后的行为，默认suspend
• HandleHibernateKey 按下休眠键后的行为，默认hibernate
• HandleLidSwitch 合上笔记本盖后的行为，默认suspend

我们把HandleLidSwitch后面的suspend修改为lock，

 HandleLidSwitch=lock

3. 配置项意义：

ignore 忽略，跳过
power off 关机
eboot 重启
halt 挂起

suspend shell内建指令，可暂停目前正在执行的shell。若要恢复，则必须使用SIGCONT信息。所有的进程都会暂停，但不是消失(halt是进程关闭)

lock 仅锁屏，计算机继续工作。

4. 生效

必须要使用如下命令才能使上面的配置生效

systemctl restart systemd-logind

5.更改固定ip

修改网卡配置文件

 有线
 vi /etc/sysconfig/network-scripts/ifcfg-ens33

TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
BOOTPROTO="none"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="no"
IPV6INIT="no"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
NAME="ens33"
UUID="66af7510-3056-4481-a417-dde76aa9c711"
DEVICE="ens33"
ONBOOT="yes"
IPADDR="192.168.1.11"
PREFIX="32"
GATEWAY="192.168.1.1"
DNS1="192.168.1.1"

重启网络服务，执行命令：

sudo service network restart 　
或 
/etc/init.d/network restart

6.配置开机启动执行脚本

• 编写sh运行脚本

 vim /etc/init.d/proxy-client

#!/bin/bash
#chkconfig: 2345 22 80
#description: proxy client Service

/data/proxy-client-0.1/bin/startup.sh  >/dev/null 2>/dev/null

#!/bin/bash　　#告诉系统使用的shell；

#chkconfig: 2345 22 80

#chkconfig后面有三个参数2345,20和80告诉chkconfig程序，需要在rc2.d~rc5.d目录下，创建名字为 S20FIlebeat的文件连接，连接到/etc/rc.d/init.d目录下的的FIlebeat脚本。第一个字符是S，系统在启动的时候，运行脚本FIlebeat，就会添加一个start参数，告诉脚本，现在是启动模式。同时在rc0.d和rc6.d目录下，创建名字为K80FIlebeat的 文件连接，第一个字符为K，个系统在关闭系统的时候，会运行FIlebeat，添加一个stop，告诉脚本，现在是关闭模式。注意上面的三行中，第二，第三行是必须的，否则在运行chkconfig --add FIlebeat时，会报错。 如果运行chkconfig老是报错，如果脚本没有问题，建议直接在rc0.d~rc6.d下面创建到脚本的文件连接来解决，原理都是一样的。

• 给proxy添加可执行权限

chmod +x /etc/init.d/proxy-client 

• 注册我们的脚本

chkconfig --add proxy-client 

• 重启Linux服务测试结果

sudo reboot

• 关闭开机启动

[root@c69-01 ~]# chkconfig proxy-client  off
[root@c69-01 ~]# chkconfig --list proxy-client            	0:off	1:off	2:off	3:off	4:off	5:off	6:off

• 从chkconfig管理中删除test

[root@c69-01 ~]# chkconfig --list proxy-client            	0:off	1:off	2:off	3:off	4:off	5:off	6:off
[root@c69-01 ~]# chkconfig --del proxy-client 
[root@c69-01 ~]# chkconfig --list testservice test supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add proxy-client ')

安装jdk

1.jdk1.8 安装

sudo yum install java-1.8.0-openjdk-devel.x86_64 -y

2.jdk11 安装

sudo yum install java-11-openjdk-devel.x86_64

3.jdk 版本切换

update-alternatives --config java

Docker安装

之前使用的CentOS8由于停止维护了，这意味着无法再使用新版本的软件包更新了，由于Docker 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10， CentOS 7 满足最低内核的要求，所以我们在CentOS 7安装Docker。希望这篇文章对大家能有帮助。

1.CentOS安装Docker

Docker 分为 CE 和 EE 两大版本。CE 即社区版（免费，支持周期 7 个月）
EE 即企业版，强调安全，付费使用，支持周期 24 个月。
Docker CE 分为 stable test 和 nightly 三个更新频道。 官方网站上有各种环境下的安装指南，这里主要介绍
Docker CE 在 CentOS上的安装。

1.1.卸载（可选）

如果之前安装过旧版本的Docker，可以使用下面命令卸载：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

1.2.安装docker

安装yum工具

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

更新本地镜像源：官方

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

更新本地镜像源：阿里云

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

刷新 yum 缓存

sudo yum makecache fast

安装docker

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

1.3.启动docker

systemctl start docker

1.4.开启自启

systemctl enable docker

1.5.配置镜像加速

docker官方镜像仓库网速较差，我们需要设置国内镜像服务：

参考阿里云的镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

##创建文件夹

sudo mkdir -p /etc/docker

##在文件夹内新建一个daemon.json文件

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://3n4m4jry.mirror.aliyuncs.com"]
}
EOF

##重新加载文件

sudo systemctl daemon-reload

##重启docker

sudo systemctl restart docker

2.Docker镜像命令

一些镜像的基础命令，方便学习，可以去dockerhub上拉取镜像https://hub.docker.com/

2.1、查找镜像

docker search tomcat    # 从Docker Hub上查找tomcat镜像
STARS：                 # 关注度
docker search --filter=stars=300 tomcat     #从Docker Hub上查找关注度大于300的tomcat镜像

2.2、查看自己镜像列表

docker images
docker images -a            #列出本地所有的镜像
docker images -q            #只显示镜像ID
docker images --digests     #显示镜像的摘要信息
docker images --no-trunc    #显示完整的镜像信息

2.3、拉取镜像

不加tag(版本号) 即拉取docker仓库中 该镜像的最新版本latest 加:tag 则是拉取指定版本

docker pull 镜像名
docker pull 镜像名:tag

2.4、保存镜像

docker save 镜像名/镜像ID -o 镜像保存的名字 镜像保存的tag
例如：docker save -o redis.tar redis:latest

2.5、删除镜像

docker rmi -f 镜像名/镜像ID
#单个镜像删除，相当于：docker rmi java:latest
docker rmi java
#强制删除(删除正在运行的镜像，注：以后台方式运行的不能被强制删除)
docker rmi -f java
#多个镜像删除，不同镜像间以空格间隔
docker rmi -f java tomcat nginx
#删除本地全部镜像
docker rmi -f $(docker images -q)

2.6、加载镜像

docker load -i 镜像保存文件位置
例如：docker load -i redis.tar

3.Docker容器命令

3.1、查看容器

# 查看正在运行的容器
docker ps
# 查看所有容 包括停止的容器
docker ps -a
# -q参数，只显示container id
docker ps -q
# 查看容器详细信息
docker inspect demo1

3.2、容器启动与停止

#新建并启动容器，参数：-i  以交互模式运行容器；-t  为容器重新分配一个伪输入终端；--name  为容器指定一个名称
docker run -i -t --name mycentos 镜像名称/镜像ID

#后台启动容器，参数：-d  已守护方式启动容器
docker run -d mycentos

#启动止容器
docker start 容器id

# 重启容器
docker restart 容器id

# 关闭容器
docker kill 容器id
docker stop 容器id

-t 参数让Docker分配一个伪终端并绑定到容器的标准输入上
-i 参数则让容器的标准输入保持打开。
-c 参数用于给运行的容器分配cpu的shares值
-m 参数用于限制为容器的内存信息，以 B、K、M、G 为单位
-v 参数用于挂载一个volume，可以用多个-v参数同时挂载多个volume
-p 参数用于将容器的端口暴露给宿主机端口 格式：host_port:container_port 或者 host_ip:host_port:container_port
--name 容器名称
--net 容器使用的网络
-d 创建一个后台运行容器


# 容器内存等占用查看
docker stats

3.3、容器进入与退出

#使用run方式在创建时进入
docker run -it centos /bin/bash
#关闭容器并退出
exit
#仅退出容器，不关闭
快捷键：Ctrl + P + Q
快捷键：Ctrl + Shift + P + Q

3.4、容器进程

#top支持 ps 命令参数，格式：docker top [OPTIONS] CONTAINER [ps OPTIONS]
#列出redis容器中运行进程
docker top tomcat
#查看所有运行容器的进程信息
for i in  `docker ps |grep Up|awk '{print $1}'`;do echo \ &&docker top $i; done

3.5、容器日志

# 查看redis容器日志，默认参数
docker logs tomcat

# 查看redis容器日志，参数：-f  跟踪日志输出；-t   显示时间戳；--tail  仅列出最新N条容器日志；
docker logs -f -t --tail=20 redis

# 查看容器redis从2021年08月10日后的最新10条日志。
docker logs --since="2021-08-10" --tail=10 redis

3.6、容器修改

1. 更新 CPU 共享数量

# f361b7d8465 为 容器ID
docker update --cpu-shares 512 f361b7d8465

1. 更新容器的重启策略

docker update --restart=always f361b7d8465

docker update --restart=no f361b7d8465

1. 更新容器内存

docker update -m 500M f361b7d8465

Docker容器的重启策略如下：

no，默认策略，在容器退出时不重启容器
on-failure，在容器非正常退出时（退出状态非0），才会重启容器
on-failure:3，在容器非正常退出时重启容器，最多重启3次
always，在容器退出时总是重启容器
unless-stopped，在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

OPTIONS 说明

名称	描述
--blkio-weight	阻塞IO (相对权重)，介于10到1000之间，0表示禁用（默认禁止）
--cpu-period	限制CPU CFS（完全公平的调度程序）期限
--cpu-quota	限制CPU CFS（完全公平的调度程序）配额
--cpu-rt-period	API 1.25+，将CPU实时时间限制为微秒
--cpu-rt-runtime	API 1.25+，将CPU实时运行时间限制为微秒
--cpu-shares, -c	CPU份额（相对权重）
--cpus	API 1.29+，CPU数量
--cpuset-cpus	允许执行的CPU（0-3，0,1）
--cpuset-mem	允许执行的MEM（0-3，0,1）
--kernel-memory	内核内存限制
--memory-swap	交换限制等于内存加交换，“-1”以启用无限交换
--memory-reservatio	内存软限制
--memory, -m	内存限制
--pids-limit	API 1.40+，调节容器pids限制（-1表示无限制）
--restart	容器退出时重新启动策略以应用

4.Docker-compose使用

4.1.Compose介绍

Docker Compose是一个用来定义和运行复杂应用的Docker工具。一个使用Docker容器的应用，通常由多个容器组成。使用Docker Compose不再需要使用shell脚本来启动容器。
Compose 通过一个配置文件来管理多个Docker容器，在配置文件中，所有的容器通过services来定义，然后使用docker-compose脚本来启动，停止和重启应用，和应用中的服务以及所有依赖服务的容器，非常适合组合使用多个容器进行开发的场景。

4.2.Compose和Docker兼容性

compose文件格式版本	docker版本
3.4	                17.09.0+
3.3	                17.06.0+
3.2	                17.04.0+
3.1	                1.13.1+
3.0	                1.13.0+
2.3	                17.06.0+
2.2	                1.13.0+
2.1	                1.12.0+
2.0	                1.10.0+
1.0	                1.9.1.+

4.3.安装docker-compose

两种最新的docker安装方式

1.从github上下载docker-compose二进制文件安装

• 下载最新版的docker-compose文件

sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

• 若是github访问太慢，可以用daocloud下载

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

• 添加可执行权限

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

• 测试安装结果

docker-compose --version

2.pip安装

sudo pip install docker-compose

Docker安装portainer 可视化

1、首先下载Portainer的Docker镜像；

docker pull portainer/portainer

2、然后再使用如下命令运行Portainer容器；

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

3、登陆

第一次登录的时候需要创建管理员账号，访问地址：http://192.168.1.101:9000/

Docker安装Nginx

Nginx 是一个高性能的 HTTP 和反向代理 web 服务器，同时也提供了 IMAP/POP3/SMTP 服务 。

1、查看可用的Nginx 版本

访问 Nginx 镜像库地址： https://hub.docker.com/_/nginx?tab=tags。

2、拉取最新版的Nginx 镜像

这里我们拉取官方的最新版本的镜像：

 docker pull nginx:latest

3、查看本地镜像

使用以下命令来查看是否已安装了 nginx：

 docker images

4、创建Nginx配置文件

mkdir -p /data/nginx/www /data/nginx/logs /data/nginx/conf

touch /data/nginx/conf/nginx.conf

5、nginx.conf 内容

user  root;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
    client_max_body_size 100m; 
    proxy_buffering off; 
	
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    
    access_log  /var/log/nginx/access.log  main;
    
    sendfile        on;
    #tcp_nopush     on;  
    keepalive_timeout  65;
    #gzip  on;

    server {
        listen       80;
        server_name  _;
    	rewrite ^(.*)\#(.*)$ $1#$2 redirect;
    
        #charset koi8-r;
        #access_log  /var/log/nginx/host.access.log  main;
    
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
        }  

        error_page  404              /404.html;
    
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }
    
        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}
    
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}
    
        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }

}

6、运行容器

安装完成后，我们可以使用以下命令来运行 nginx 容器：

docker run -d -p 80:80 --name nginx \
       --restart=always \
       -v /data/nginx/www:/usr/share/nginx/html \
       -v /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
       -v /data/nginx/logs:/var/log/nginx \
       nginx

参数说明：

• **–name nginx：容器名称。
• -p 80:80： 端口进行映射，将本地 80 端口映射到容器内部的 80 端口。
• -d nginx： 设置容器在在后台一直运行。
• -v: 文件系统映射

7、https 支持

使用多端口映射443端口，以及ssl 文件

docker run -d  -p 80:80 -p 443:443 --name nginx \
       --restart=always \
       -v /data/nginx/www:/usr/share/nginx/html \
       -v /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
       -v /data/nginx/conf/xx.xxxx.com.pem:/etc/nginx/xxxxx.com.pem \
       -v /data/nginx/conf/xx.xxxx.com.key:/etc/nginx/xxxxx.com.key \
       -v /data/nginx/logs:/var/log/nginx \
       nginx

nginx.conf 新增443 端口监听

#http节点中可以添加多个server节点
server{
    #监听443端口
    listen       443 ssl;
    #对应的域名，把xxxxxxx.com改成你们自己的域名就可以了
    server_name xxxxxxx.com;
    ssl on;
    ssl_certificate /etc/nginx/xxxxx.com.pem;
    ssl_certificate_key /etc/nginx/xxxxx.com.key;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    ssl_prefer_server_ciphers on;

    location /api {
        proxy_pass http://10.2.0.5:9091;
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }

    location /admin {
        proxy_pass http:/10.2.0.5:9090;
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
}

8、负载均衡

tcp 负载

#nginx tcp loadbalance config
stream {
    upstream MyServer{
       #hash $remote_addr consistent;
       server 127.0.0.1:6000 weight=1 max_fails=3 fail_timeout=30s;
       server 127.0.0.1:6002 weight=1 max_fails=3 fail_timeout=30s;
     }

     server {
     proxy_connect_timeout 1s;
     #proxy_timeout 3s;
     listen 8000;
     proxy_pass MyServer;
     tcp_nodelay on;
   }
}

http 负载

upstream pptbackend {
server 127.0.0.1:8082;
server 127.0.0.1:8083;
}

server {
    listen       80;
    server_name  localhost;

​
location /ppt/ {
proxy_pass http://pptbackend;
index index.html index.htm index.jsp;

    }
}

Docker安装Redis

1、搜索redis镜像

docker search redis

2、拉取镜像

docker pull redis

3、挂载配置文件

1）、挂载redis的配置文件

2）、挂载redis 的持久化文件（为了数据的持久化）。

mkdir -p /data/redis/conf /data/redis/data

4、启动redis 容器

docker run --restart=always \
        -p 6379:6379 --name redis \
        -v /data/redis/data:/data  \
        -d redis redis-server \
        --requirepass "123456" \
        --appendonly yes

指定redis.conf 文件启动

docker run --restart=always \
      --log-opt max-size=100m \
      --log-opt max-file=2 \
      -p 6379:6379 --name redis \
      -v /data/redis/conf/:/etc/redis/redis.conf \
      -v /data/redis/data:/data \
      -d redis redis-server /etc/redis/redis.conf  \
      --requirepass "123456"  \
      --appendonly yes  

• –restart=always： 总是开机启动
• –log：是日志方面的
• -p 6379:6379： 将6379端口挂载出去
• –name ：给这个容器取一个名字
• -v ：数据卷挂载
• -d redis ：表示后台启动redis
• redis-server /etc/redis/redis.conf ：以配置文件启动redis，加载容器内的conf文件，最终找到的是挂载的目录 /etc/redis/redis.conf 也就是liunx下的/home/redis/myredis/myredis.conf
• –appendonly yes： 开启redis 持久化
• –requirepass 000415： 设置密码

5、测试

通过docker ps指令查看启动状态

docker ps 

查看容器运行日志

## 当前日志
docker logs -f redis

##30分钟之内的日志情况。
docker logs --since 30m myredis

6、配置文件

redis.conf

# bind 192.168.1.100 10.0.0.1
# bind 127.0.0.1 ::1
#bind 127.0.0.1

protected-mode no
port 6379
tcp-backlog 511
requirepass 000415
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 30
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-disable-tcp-nodelay no
replica-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly yes
appendfilename "appendonly.aof"
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-max-len 128
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

Docker安装mysql

1、查看要下载的mysql镜像

docker hub镜像仓库中为我们开发要
打开docker hub 网站
dockerHub官网地址

2、拉取镜像

不指定版本号，默认下载最新版本:

docker pull mysql:8.0.31-debian

指定版本号:

docker pull mysql:5.7.40

3、挂载配置文件

1）、挂载mysql的配置文件

2）、挂载mysql的数据文件

mkdir -p /data/mysql/conf/  /data/mysql/logs  /data/mysql/data

4、mysql.cnf 配置文件

[mysqld]
user=mysql
default-authentication-plugin=mysql_native_password

# 表示允许任何主机登陆MySQL
bind-address=0.0.0.0 
default-storage-engine=INNODB
character-set-server=utf8mb4

# 导入文件限制
max_allowed_packet=1024M

# 8.0版本自适应参数【很重要的配置】
innodb_dedicated_server=on
lower_case_table_names = 1
default-time-zone='+08:00'
sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION'
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4

5、启动mysql容器

docker run -p 3306:3306 --name mysql \
        --restart=always \
        -v /data/mysql/conf:/etc/mysql/conf.d \
        -v /data/mysql/logs:/logs \
        -v /data/mysql/data:/var/lib/mysql \
        -e MYSQL_ROOT_PASSWORD=123456 \
        -d mysql
        
docker run -p 3306:3306 --name mysql -v /home/mysql/conf:/home/mysql/conf.d -v /home/mysql/logs:/logs -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7

6、修改mysql 外网访问密码

docker exec -it mysql /bin/bash
mysql -r -p123456
use mysql
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
FLUSH PRIVILEGES;
exit
exit

7、数据库定时备份

7.1、bakmysql.sh 定时脚本

#!/bin/bash
#用户名
USER="root"
#密码
PASSWORD="123456"
#数据库名
DATABASE="test

> 这里是引用

"
#docker 镜像名
DOCKERNAME="mysql"

BACKUP_DIR=/data/bakmysql/db/ #备份文件存储路径
LOGFILE=/data/bakmysql/db/data_backup.log #日记文件路径
DATE=`date '+%Y%m%d-%H%M'` #日期格式（作为文件名）
DUMPFILE='cradmin'-$DATE.sql #备份文件名
ARCHIVE='cradmin'-$DATE.sql.tgz #压缩文件名
OPTIONS="-u$USER -p$PASSWORD $DATABASE"
#mysqldump －help

#判断备份文件存储目录是否存在，否则创建该目录
if [ ! -d $BACKUP_DIR ] ;
then
        mkdir -p "$BACKUP_DIR"
fi

#开始备份之前，将备份信息头写入日记文件
echo " " >> $LOGFILE
echo " " >> $LOGFILE
echo "———————————————–" >> $LOGFILE
echo "BACKUP DATE:" $(date +"%y-%m-%d %H:%M:%S") >> $LOGFILE
echo "———————————————– " >> $LOGFILE

#切换至备份目录
cd $BACKUP_DIR
#使用mysqldump 命令备份制定数据库，并以格式化的时间戳命名备份文件
docker exec -ti $DOCKERNAME mysqldump $OPTIONS > $DUMPFILE
#判断数据库备份是否成功
if [[ $? == 0 ]]; then
    #创建备份文件的压缩包
    tar czvf $ARCHIVE $DUMPFILE >> $LOGFILE 2>&1
    #输入备份成功的消息到日记文件
    echo "[$ARCHIVE] Backup Successful!" >> $LOGFILE
    #删除原始备份文件，只需保 留数据库备份文件的压缩包即可
    rm -f $DUMPFILE
else
    echo "Database Backup Fail!" >> $LOGFILE
fi

#备份最近5天的数据 -mtime +5 按照文件的更改时间来查找文件，+5表示文件更改时间距现在5天以前；如果是 -mmin +5 表示文件更改时间距现在5分钟以前。
find ${BACKUP_DIR} -mtime +5 -name "cradmin-*.sql.tgz" -exec rm -f {} \;
	
#输出备份过程结束的提醒消息
echo "Backup Process Done"

7.2、编辑定时任务列表

crontab -e

7.3、添加定时任务 （ 每天凌晨1点执行一次）

0 0 1 * * ?  /bin/sh  /data/bakmysql/bakmysql.sh

7.4、查看设置的定时任务是否成功：

crontab -l

Docker安装Nexus私服

1、安装Nexus

下载一个nexus3的镜像：

docker pull sonatype/nexus3

2、挂载配置文件

挂载Nexus的数据文件

mkdir /data/nexus-data && chown -R 200 /data/nexus-data

3、启动容器

使用nexus3镜像创建并启动一个容器，指定暴露8081端口到对应主机的8081端口，将容器内部/var/nexus-data挂载到主机/data/nexus-data目录。

docker run -d -p 8081:8081 --name nexus -v /data/nexus-data:/nexus-data --restart=always sonatype/nexus3

4、修改账号和密码

在浏览器输入：http://ip:8081访问

Nexus3的初始账号密码已经不是admin/admin123。

密码保存在 /nexus-data下的 admin.password 中

进入容器

docker exec -it  nexus  /bin/bash

进入容器后，找到admin.password ，查看并复制密码。

cat nexus-data/admin.password

登陆，输入密码,直接 next，提示重置密码

5、设置 proxy 代理仓库

添加阿里云公共仓库

maven-aliyun   阿里
http://maven.maven-aliyun.com/nexus/content/groups/public/

repo1
http://repo1.maven.org/maven2/

apache
http://repo.maven.apache.org/maven2

将阿里云公共仓库添加到maven这个group类型的仓库，并调整优先级

6、获取私服地址

http://192.168.44.8:8081/repository/maven-public/

7、maven使用私服jar

maven配置私服有两种方式

• 全局模式，通过配置maven的配置文件 setting.xml
• 项目独享模式，通过配置项目中的pom.xml

需要项目中使用jar 的配置过程： 先要引入jar包，然后需要在 setting.xml或者pom.xml文件中添加资源地址.

7.1全局模式

maven的配置文件 setting.xml

<!-- 个人仓库 -->
	 <mirror>
      <id>maven-public</id>
      <mirrorOf>*</mirrorOf>
      <url>http://192.168.153.8:8081/repository/maven-public/</url>
    </mirror>

 <!-- 阿里云仓库 -->
    <mirror>
      <id>alimaven</id>
      <mirrorOf>central</mirrorOf>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
    </mirror>
  
    <!-- 中央仓库1 -->
    <mirror>
      <id>repo1</id>
      <mirrorOf>central</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://repo1.maven.org/maven2/</url>
    </mirror>
  
    <!-- 中央仓库2 -->
    <mirror>
      <id>repo2</id>
      <mirrorOf>central</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://repo2.maven.org/maven2/</url>
    </mirror>

7.2项目独享模式

项目中的pom.xml

    #### 使用nexus私服
	<repositories>
		<repository>
			<id>nexus</id>
			<name>nexus</name>
			<url>http://192.168.44.8:8081/repository/maven-public/</url>
			<releases>
				<enabled>true</enabled>
			</releases>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

	<pluginRepositories>
		<pluginRepository>
			<id>nexus</id>
			<name>my-nexus-repository</name>
			<url>http://192.168.153.8:8081/repository/maven-public/</url>
			<releases>
				<enabled>true</enabled>
			</releases>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
	</pluginRepositories>
    
    
    
    #### 使用阿里云
     <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

8、打包本地jar上传私服

本地jar上传到私服，有两种方式，一种是maven客户端配置，deploy上传；一种是在管理后台手动上传。下面分别介绍这两种方法。

8.1maven客户端上传

8.1.1.需要配置maven的setting.xm

在servers 标签中添加配置

<servers>	
<server>
	 <!-- 与 pom文件中的 distributionManagement id对应 -->
		<id>nexus-releases</id>
		<username>admin</username>
		<password>admin123</password>
    </server>
	<server>
	  <id>nexus-snapshots</id>
	  <username>admin</username>
	  <password>admin123</password>
	</server>
  </servers>

8.1.2.在项目中配置

需要在 pom文件中配置加入

<distributionManagement>
    <repository>
        <!-- 与 maven setting 文件中的 server id对应 -->
        <id>nexus-releases</id>
        <url>http://192.168.44.8:8081/repository/maven-releases/</url>
    </repository>
    <snapshotRepository>
        <id>nexus-snapshots</id>
        <url>http://192.168.44.8:8081/repository/maven-snapshots/</url>
        <uniqueVersion>true</uniqueVersion>
    </snapshotRepository>
</distributionManagement>

8.1.3.发布打包

• 执行 mvn clean package -Dmaven.test.skip=true deploy
• 执行成功后私服中查看

5.2私服web地址上传

进入上传页面进行上传操作

Docker安装nacos

1、拉取镜像

docker pull nacos/nacos-server

2、挂载目录

mkdir -p /data/nacos/logs/                           #新建logs目录
mkdir -p /data/nacos/conf/                           #新建配置文件
vi /data/nacos/conf/application.properties           #修改配置文件 

3、配置持久化数据库脚本

application.properties

# spring
server.servlet.contextPath=/nacos
server.contextPath=/nacos
server.port=8848
spring.datasource.platform=mysql
nacos.cmdb.dumpTaskInterval=3600
nacos.cmdb.eventTaskInterval=10
nacos.cmdb.labelTaskInterval=300
nacos.cmdb.loadDataAtStart=false
db.num=1
db.url.0=jdbc:mysql://192.168.1.101:3306/nacos?characterEncoding=utf8&connectTimeout=10000&socketTimeout=30000&autoReconnect=true&allowPublicKeyRetrieval=true&serverTimezone=UTC
db.user=root
db.password=123456
### The auth system to use, currently only 'nacos' is supported:
nacos.core.auth.system.type=nacos


### The token expiration in seconds:
nacos.core.auth.default.token.expire.seconds=18000

### The default token:
nacos.core.auth.default.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789

### Turn on/off caching of auth information. By turning on this switch, the update of auth information would have a 15 seconds delay.
nacos.core.auth.caching.enabled=false
nacos.core.auth.enable.userAgentAuthWhite=false
nacos.core.auth.server.identity.key=serverIdentity
nacos.core.auth.server.identity.value=security
server.tomcat.accesslog.enabled=false
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D
# default current work dir
server.tomcat.basedir=
## spring security config
### turn off security
nacos.security.ignore.urls=/,/error,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/v1/auth/**,/v1/console/health/**,/actuator/**,/v1/console/server/**
# metrics for elastic search
management.metrics.export.elastic.enabled=false
management.metrics.export.influx.enabled=false

nacos.naming.distro.taskDispatchThreadCount=10
nacos.naming.distro.taskDispatchPeriod=200
nacos.naming.distro.batchSyncKeyCount=1000
nacos.naming.distro.initDataRatio=0.9
nacos.naming.distro.syncRetryDelay=5000
nacos.naming.data.warmup=true       

4、启动容器

docker run -d -p 8848:8848 \
     -e MODE=standalone  \
     -e PREFER_HOST_MODE=hostname \
     -v /data/nacos/logs:/home/nacos/logs \
     -v /data/nacos/conf/application.properties:/home/nacos/conf/application.properties \
     --restart=always \
     --name nacos nacos/nacos-server

5、nacos集群

docker run -d --name nacos1 --hostname nacos1 \
--net=host \
--restart=always \
--add-host nacos1:172.16.9.45 \
--add-host nacos2:172.16.9.46 \
--add-host nacos3:172.16.9.47 \
-e PREFER_HOST_MODE=hostname \
-e MYSQL_SERVICE_HOST=172.16.9.45 \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=asdw@123 \
-e MYSQL_SERVICE_PORT=3306 \
-e NACOS_SERVERS="nacos1:8848 nacos2:8848 nacos3:8848" \
-v /root/nacos/config/custom.properties:/home/nacos/init.d/custom.properties \
-v /root/nacos/logs:/home/nacos/logs \
nacos/nacos-server

这里重点解释一下 --net=host，这里是采用docker的主机模式，也就是无网桥，直接占用本机的端口。网上很多人的例子都是在一台机子下面做多个不同端口的nacos，来模拟伪集群，所以很多人都是-p 8848:8848就OK了。而在不同机子上时，nacos其实不仅仅使用到了8848端口，还用了其他一些端口，比如7848等。所以，要么你就要暴露所有的端口，要么简单点直接使用–net=host即可

Nginx做高可用负载，nginx.conf的配置修改

在最后一行添加，也就是和http同级

stream {
    upstream nacos {
        server 172.16.9.45:8848;
        server 172.16.9.46:8848;
        server 172.16.9.47:8848;
    }
    server {
        listen 8848;
        proxy_pass nacos;
    }
}

6、打开Nacos并登陆

http://192.168.44.8:8848/nacos/#/login
用户：nacos/nacos

Docker安装RabbitMQ

1、拉取镜像

docker pull rabbitmq

2、创建并运行 RabbitMQ 容器

docker run -d    \
    -p 15672:15672  \
	-p 5672:5672   \
	-e RABBITMQ_DEFAULT_VHOST=/   \
	-e RABBITMQ_DEFAULT_USER=guest   \
	-e RABBITMQ_DEFAULT_PASS=guest   \
	--hostname myRabbit   \
	--name rabbitmq   \
	--restart=always \
	rabbitmq

参数说明：

-restart=always：开机自启

-d：表示在后台运行容器
-p：将容器的端口 5672（应用访问端口）和 15672 （控制台Web端口号）映射到主机中
-e：指定环境变量
RABBITMQ_DEFAULT_VHOST：默认虚拟机名
RABBITMQ_DEFAULT_USER：默认的用户名
RABBITMQ_DEFAULT_PASS：默认的用户密码
–hostname：指定主机名（RabbitMQ 的一个重要注意事项是它根据所谓的 节点名称 存储数据，默认为主机名）
–name rabbitmq：设置容器名称； rabbitmq：容器使用的镜像名称

3、启动rabbit_management

方法一：

1）、先进入rabbitmq容器

docker exec -it rabbitmq /bin/bash

2）、再执行命令

rabbitmq-plugins enable rabbitmq_management

方法二：

docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management

4、访问

http://192.168.44.8:15672/#/queues

登陆后 Queues -> Add a new queue -> Durability: Durable 持久数据, Transient 临时数据

5、问题相关

linux 部署 rabbitmq后，打开rabbitmq管理界面。点击channels，会报错
Stats in management UI are disabled on this node

#进入rabbitmq容器
docker exec -it {rabbitmq容器名称或者id} /bin/bash

#进入容器后，cd到以下路径
cd /etc/rabbitmq/conf.d/

#修改 management_agent.disable_metrics_collector = false
echo management_agent.disable_metrics_collector = false > management_agent.disable_metrics_collector.conf

#退出容器
exit

#重启rabbitmq容器
docker retart {rabbitmq容器id}

Docker安装ES，kibana

1、部署单点es

1.1.创建网络

因为我们还需要部署kibana容器，因此需要让es和kibana容器互联。这里先创建一个网络：

docker network create es-net

查看网络列表

docker network ls

1.2.加载镜像

这里我们采用elasticsearch的:7.9.3版本的镜像，这个镜像体积非常大，接近1G。不建议大家自己pull。

如果已有镜像包，直接load

docker load -i 文件

无镜像包，pull

docker search elasticsearch:7.9.3

docker pull elasticsearch:7.9.3

1.3.创建宿主机文件夹与docker容器映射

mkdir -p /data/elasticsearch/config
mkdir -p /data/elasticsearch/data
mkdir -p /data/elasticsearch/logs
mkdir -p /data/elasticsearch/plugins

elasticsearch.yml 文件

# 可访问IP
http.host: 0.0.0.0

# 跨域
http.cors.enabled: true
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization

# 安全功能
xpack.security.enabled: false

在宿主机宿主机文件夹给予权限

sudo chown -R 1000:1000 /data/elasticsearch

1.4.运行镜像命令

docker run -d  --restart=always --name es \
    -e ES_JAVA_OPTS="-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v /data/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
    -v /data/elasticsearch/data:/usr/share/elasticsearch/data \
    -v /data/elasticsearch/logs:/usr/share/elasticsearch/logs \
    -v /data/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
    elasticsearch:7.9.3

命令解释：

• -e "cluster.name=es-docker-cluster"：设置集群名称
• -e "http.host=0.0.0.0"：监听的地址，可以外网访问
• -e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小
• -e "discovery.type=single-node"：非集群模式
• -v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录
• -v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录
• -v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录
• --privileged：授予逻辑卷访问权
• --network es-net ：加入一个名为es-net的网络中
• -p 9200:9200：端口映射配置

1.5.测试访问

http://192.168.44.8:9200/

如下显示则成功：

{
  "name" : "793680b1ef20",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "nvJbqediRJiXz-rT3s_QYg",
  "version" : {
    "number" : "7.17.7",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "78dcaaa8cee33438b91eca7f5c7f56a70fec9e80",
    "build_date" : "2022-10-17T15:29:54.167373105Z",
    "build_snapshot" : false,
    "lucene_version" : "8.11.1",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

1.6.配置 TLS 安全功能

1.6.1、在 elasticsearch.yml 中添加如下配置

# 安全功能
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true

1.6.2、重启elasticsearch服务

systemctl restart elasticsearch

1.6.3、设置elasticsearch密码

# 进入容器
docker exec -it es /bin/bash
# 生成密码
/usr/share/elasticsearch/bin/elasticsearch-setup-passwords interactive

1.6.4、验证

浏览器直接访问http://127.0.0.1:9200,会出现输入用户名、密码的弹窗，

输入elastic和自己设置的密码后，才能看到elasticsearch信息；

账号：elastic 
密码：自己设置的

1.6.5、修改密码

下面的示例为将elastic的密码设置为"123456"

curl -H "Content-Type:application/json" -XPOST -u elastic 'http://127.0.0.1:9200/_xpack/security/user/elastic/_password' -d '{ "password" : "123456" }'

*如果密码忘了怎么办？如何重置密码？
1、修改elasticsearch.yml 配置，将身份验证相关配置屏蔽掉；
2、重启ES,查看下索引,发现多了一个.security-7索引，将其删除
3、到此就回到ES没有设置密码的阶段了，如果想重新设置密码，请从第一步开始

2、安装Kibana

Elasticsearch可视化工具，必须要和es版本保持一致

2.1.拉取 kibana 镜像

docker pull kibana:7.9.3

2.2.创建宿主机文件夹与docker容器映射

mkdir -p /data/kibana/config

kibana.yml 文件

#
# ** THIS IS AN AUTO-GENERATED FILE **
#

# Default Kibana configuration for docker target
server.name: kibana
server.host: "0"
elasticsearch.hosts: [ "http://elasticsearch:9200" ]
monitoring.ui.container.elasticsearch.enabled:  true

2.2.运行镜像命令

docker run -d --restart=always --name kibana \
       -e ELASTICSEARCH_HOSTS=http://es:9200 \
       -v /data/kibana/config:/usr/share/kibana/config \
       --network=es-net \
       -p 5601:5601  \
       kibana:7.9.3

• –name kibana 起别名
• –network=es-net 加入一个名为es-net的网络中，与elasticsearch在同一个网络中
• -restart=always 开启启动
• -e ELASTICSEARCH_HOSTS=http://192.168.44.8:9200 es主机IP+端口
• -p 5601:5601 对外暴露端口
• -d 后台运行

2.3.测试访问

http://192.168.44.8:5601/

2.3.4.给Kibana设置账号密码

第1步：配置账号密码，在kibana.yml配置文件中添加以下内容。 命令：vi config/kibana.yml

# 添加以下内容
elasticsearch.username: "elastic"
elasticsearch.password: "你在es中设置的密码"

第2步：保存配置文件后，退出容器，重启kibana容器。

第3步：重启后，输入kibana的访问地址：http://192.168.1.10:5601,这时已经提示让你输入账号密码了。

账号：elastic  
密码：你刚才设置的

3、ES 分词器

3.1、安装ik分词器

下载7.17.6版本分词器，需要与es 版本对应才可以

https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.9.3/elasticsearch-analysis-ik-7.9.3.zip

上传离线包到此目录/data/elasticsearch/plugins

# 重启
docker restart es

# 查看日志
docker logs -f es

3.2、测试分词器

3.2.1、ik分词器包含两种模式：

ik_smart：最少切分，分词少，但占用内存低一些
ik_max_word：最细切分，分词多，但占用内存多

POST /_analyze
{
"analyzer": "ik_smart",
"text": "张三老铁学习java！"
}

3.2.2、拓展与停用

修改ik分词器目录中的config目录中的ikAnalyzer.cfg.xml文件：

<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">ext.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords">stopword.dic</entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

指定拓展与停止文件后，在当前目录下新建ext.dic与stopword.dic
ext.dic

stopword.doc
有现在的文件，不需要新建，直接追加

4、总结

Es应该是目前市场上最主流的开源搜索引擎，对比完lucene,solr发现确实如此，而且es的生态也更加丰富，在大数据方向，elk几乎是必学必会的技能，国内外大厂也都有基于es的应用。

罗万象的博客：https://blog.csdn.net/laoyang360/article/details/52244917

GitHub：https://github.com/elastic/elasticsearch

ES中文网，Es下载，中文文档等：https://www.elastic.co/cn/

Es中文社区：https://elasticsearch.cn/

Docker中安装Gitlab

1、安装Gitlab

​ GitLab是一个Git的代码托管工具，有免费的社区版允许我们在本地搭建代码托管网站，也有付费的企业版网站，能够在线托管代码。

1.1.搜索images

可以看到镜像有很多，选择gitlab-ce-zh，因为这是中文版，还是看中文版的比较舒服,版本的话就根据自己的喜好。

docker search gitlab-ce-zh

1.2.下载images

docker pull twang2218/gitlab-ce-zh

安装过程会比较久，慢慢等待安装完成。

1.3.启动Git服务

docker run -d   \
    -p 9043:443 \
    -p 9080:80 \
    -p 9022:22 \
    --restart always \
    --name gitlab \
    -v /data/gitlab/etc:/etc/gitlab \
    -v /data/gitlab/log:/var/log/gitlab \
    -v /data/gitlab/data:/var/opt/gitlab \
    --privileged=true \
    twang2218/gitlab-ce-zh
    
    
    
    docker run -d   \
    -p 9043:443 \
    -p 9080:80 \
    -p 9022:22 \
    --restart always \
    --name gitlab \
    -v D:\Docker\gitlab\etc:/etc/gitlab \
    -v D:\Docker\gitlab\log:/var/log/gitlab \
    -v D:\Docker\gitlab\data:/var/opt/gitlab \
    --privileged=true \
    twang2218/gitlab-ce-zh

这里解释一下这串代码的情况，复制的话就复制上面的命令

docker run
-d #后台运行，全称：detach
-p 8443:443 #将容器内部端口向外映射
-p 8090:80 #将容器内80端口映射至宿主机8090端口，这是访问gitlab的端口
-p 8022:22 #将容器内22端口映射至宿主机8022端口，这是访问ssh的端口
–restart always #容器自启动
–name gitlab #设置容器名称为gitlab
-v /data/gitlab/etc:/etc/gitlab #将容器/etc/gitlab目录挂载到宿主机/usr/local/gitlab/etc目录下，若宿主机内此目录不存在将会自动创建
-v /data/gitlab/log:/var/log/gitlab #与上面一样
-v /data/gitlab/data:/var/opt/gitlab #与上面一样
–privileged=true #让容器获取宿主机root权限
twang2218/gitlab-ce-zh #镜像的名称，这里也可以写镜像ID

1.4.查看Gitlab是否已经启动

// 添加-a 参数，把启动的，没有启动的都列出来

docker ps

查看当前运行日志

docker logs  -f  gitlab

1.5.配置Gitlab

修改/data/gitlab/etc/gitlab.rb 文件

external_url 因为默认会用这个端口号作为gitlab的nginx的监听端口。因为我们这里其实是监听的80端口，所以要额外配置映射端口

如果80端口映射80端口，则无需配置。

nginx['listen_port'] = 80
external_url 'http://192.168.44.8:9080'

ssh 拉取配置下面这个

gitlab_rails['gitlab_ssh_host'] = '192.168.44.8'
gitlab_rails['gitlab_shell_ssh_port'] = 9022

配置完成后重启容器

//容器外重启
docker restart gitlab

1.6.GitLab内存问题

GitLab占用内存非常恐怖，解决方法

减少数据库缓存

postgresql['shared_buffers'] = "64MB"

减少数据库并发数

postgresql['max_worker_processes'] = 1

减少sidekiq并发数

sidekiq['concurrency'] = 1

减少进程数

unicorn['worker_processes'] = 1
nginx['worker_processes'] = 2

减少超时时间

unicorn['worker_timeout'] = 10

将worker内存上限设置小一点

unicorn['worker_memory_limit_min'] = "100 * 1 << 20"
unicorn['worker_memory_limit_max'] = "220 * 1 << 20"

禁用prometheus

prometheus_monitoring['enable'] = false

1.7.gitlab邮箱配置

#Sending application email via SMTP设置
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.qq.com"
gitlab_rails['smtp_port'] = 465
gitlab_rails['smtp_user_name'] = "630447476@qq.com" # 邮箱登录名称
gitlab_rails['smtp_password'] = "oskirrxanxlzbehf"  # POP3/SMTP/IMAP服务授权密码
gitlab_rails['smtp_domain'] = "smtp.qq.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_tls'] = true

##修改gitlab配置的发信人
gitlab_rails['gitlab_email_enabled'] = true
gitlab_rails['gitlab_email_from'] = '630447476@qq.com' # 显示名字
gitlab_rails['gitlab_email_display_name'] = 'gitlab'
gitlab_rails['gitlab_email_reply_to'] = '630447476@qq.com'

1.8.GitLab登陆

http://192.168.44.8:9080/users/sign_in

用户名：root

密码：git123456

首次登陆会让设置密码，此密码为管理员rooot密码

2、常用命令

//容器外停止
docker stop gitlab ``// 这里的gitlab 就是我们上一步docker run 当中使用--name 配置的名字

//容器外重启
docker restart gitlab

//进入容器命令行
docker exec -it gitlab bash

//容器中应用配置，让修改后的配置生效
gitlab-ctl reconfigure

//容器中重启服务
gitlab-ctl restart

//日志查看 
docker logs  -f --tail=10  gitlab

Docker部署Canal

Canal是阿里开源的一款基于Mysql数据库binlog的增量订阅和消费组件，通过它可以订阅数据库的binlog日志，然后进行一些数据消费，如数据镜像、数据异构、数据索引、缓存更新等。相对于消息队列，通过这种机制可以实现数据的有序化和一致性。

canal-server 安装

1、拉去canal镜像,不加版本号，默认为latest

docker pull canal/canal-server:latest

2、查看镜像是否拉去成功

docker images

3、拉取完成后，先启动下canal，主要是为了从里面copy出配置文件

#启动镜像

docker run --name canal -d canal/canal-server

#进入容器 查看配置文件路径

docker exec -it canal bash

#创建本地文件夹

 mkdir -p /data/canal/conf /data/canal/logs 

#找到文件位置后 exit退出容器 将容器内部文件copy到外部 copy到/docker/canal/conf

docker cp canal:/home/admin/canal-server/conf/canal.properties /data/canal/conf
docker cp canal:/home/admin/canal-server/conf/example/instance.properties /data/canal/conf

4.修改配置文件

instance.properties

# 设置serverd，一般设置为IP，同一局域网内注意要唯一，如果相同，则它们之间不能设定为主备关系, 目前最新的服务端版本已不需要配置serverId参数
# canal.instance.mysql.slaveId=23
# 数据地址
canal.instance.master.address=192.168.1.88:3306
canal.instance.dbUsername=root
canal.instance.dbPassword=123456
# binlog解析的过滤规则，采用正则表达式 默认为全部表
canal.instance.filter.regex = .*\\..*

canal.properties

# canal admin 配置
canal.admin.manager = 192.168.1.101:8089
canal.admin.port = 11110
canal.admin.user = admin
canal.admin.passwd = 01A6717B58FF5C7EAFFF6CB7C96F7428EA65FE4C

5、修改完成后 ，之前的canal容器关闭，重新起一个新的容器

#关闭并移除容器
docker rm -f canal

#启动新的 这里-v是将外部的文件挂载到容器内部 这样就不用每次启动都要配置参数了

docker run --name canal -p 11111:11111 -d \
-v /data/canal/conf/instance.properties:/home/admin/canal-server/conf/example/instance.properties \
-v /data/canal/conf/canal.properties:/home/admin/canal-server/conf/canal.properties \
-v /data/canal/logs/:/home/admin/canal-server/logs/ \
canal/canal-server

6、修改开机启动

docker update --restart=always canal

7、数据库配置

mysql 开启binlog日志

log-bin=mysql-bin #binlog文件名
binlog_format=ROW #选择row模式
server_id=1 #mysql实例id,不能和canal的slaveId重复

mysql中创建canal用户

CREATE USER 'canal'@'%' IDENTIFIED BY 'canal';
GRANT SHOW VIEW, SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

canal-admin安装

1、拉取 canal-admin

docker pull canal/canal-admin:latest

# 本地启动
docker run -d -it -h 0 \
-e server.port=8089 \
-e canal.adminUser=admin \
-e canal.adminPasswd=admin123 \
--name=canal-admin \
-p 8089:8089 \
-m 1024m canal/canal-admin

账号admin，初始密码123456(登陆密码并不是admin123，连接密码才是admin123)

# 外部数据库启动
docker run -d -it -h 127.0.0.1 \
-e server.port=8089 \
-e spring.datasource.address=:3306  \
-e spring.datasource.database= canal_manager  \
-e spring.datasource.username= canal  \
-e spring.datasource.password= canal  \
-e canal.adminUser=admin \
-e canal.adminPasswd=admin123 \
--name=canal-admin -p 8089:8089 \
canal/canal-admin

本地启动进入容器查看密码

docker exec -it canal-admin bash
mysql -u -p
select password('admin123');

whyour/qinglong安装

docker 部署

docker 安装

sudo curl -sSL get.docker.com | sh

启动容器

docker run -dit \
  -v $PWD/ql:/ql/data \
  -p 5700:5700 \
  --name qinglong \
  --hostname qinglong \
  --restart unless-stopped \
  whyour/qinglong:latest

docker-compose 部署

docker-compose 安装

sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

启动容器

mkdir qinglong
wget https://raw.githubusercontent.com/whyour/qinglong/master/docker/docker-compose.yml

# 启动
docker-compose up -d
# 停止
docker-compose down