Docker
CentOS 8用此命令更换yum源
1. cd /etc/yum.repos.d/
2. mkdir bak
3. mv CentOS-* bak
4. rm -rf *
5. wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
6. yum makecache
#发布一个项目，例如jar的同时，还能带上我们的运行环境(jdk redis mysql ...)一起发布
安装Docker
环境 centos 7，推荐内核版本4.0以上
一、查看当前系统内核 uname -r
#[root@MiWiFi-R3600-srv redis]# uname -r
3.10.0-1160.45.1.el7.x86_64
二、卸载旧版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
三、需要的安装包
yum install -y yum-utils device-mapper-persistent-data lvm2
四、使用阿里云镜像安装
默认国外yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
阿里云 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
五、更新yum索引
yum makecache fast
六、安装docker
yum install docker-ce docker-ce-cli containerd.io
七、
# 配置 /etc/docker/daemon.json,写入以下配置，如果没有这个文件就新建一个
{
"registry-mirrors":[
"https://9cpn8tt6.mirror.aliyuncs.com",
"https://registry.docker-cn.com"
],
"dns":["8.8.8.8","114.114.114.114"]
}
八、启动docker
systemctl start docker
九、查看是否安装成功
docker version
命令
一、镜像命令
卸载docker
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
帮助命令
docker 命令 --help
查看所有镜像
docker images
镜像搜索
docker search mysql
[root@MiWiFi-R3600-srv docker]# docker search mysql
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 13234 [OK]
下载镜像
#docker pull 镜像名[:tag]
docker pull mysql #如果不写tag,则默认是latest最新版本
docker pull mysql:5.7.39 #下载指定版本 指定的tag版本一定要在官方能够找到的
#https://hub.docker.com/_/mysql/
删除单个镜像
docker rmi -f <镜像id>
删除多个镜像
docker rmi -f <镜像id> <镜像id> <镜像id> <镜像id>
删除所有镜像
docker rmi -f $(docker images -aq)
二、容器命令
新建容器并启动
# docker run [可选参数] image
# 参数说明
--name="NAME" 容器名
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器端口 -p 8080:8080
-p 主机端口:容器端口（常用）
-p 容器端口
-P 随机指定端口
# docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql
查看运行中的容器
docker ps
查看所有容器
docker ps -a
进入容器内部
docker exec -it 容器id /bin/bash
删除容器
docker rm 容器ID #删除容器
docker rm -f 容器ID #可以强制删除运行中的容器
docker rm -f $(docker ps -aq) #删除全部容器
容器启动或停止
docker start 容器ID #启动容器
docker restart 容器ID #重启容器
docker stop 容器ID #停止容器
docker kill 容器ID #强制停止当前容器
三、常用其他命令
查看日志
docker logs -tf --tail 10 容器ID #查看10条容器日志
docker logs -tf 容器ID #查看当前容器所有日志
查看容器进程
# docker top 容器ID
[root@MiWiFi-R3600-srv /]# docker top be28a6df8974
UID PID PPID C STIME TTY TIME
polkitd 48793 48775 0 13:46 ? 00:00:03
查看元数据
docker inspect 容器ID
容器内的文件拷贝到主机
# docker cp 容器ID:容器内文件路径 主机路径
[root@MiWiFi-R3600-srv /]# docker cp be28a6df8974:java.txt /
查看容器端口
docker port 容器ID #查看正在运行的容器端口
Docker commit
docker commit -a "runoob.com" -m "my apache" a404c6c174a2 mymysql:v1
docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
-a :提交的镜像作者；
-c :使用Dockerfile指令来创建镜像；
-m :提交时的说明文字；
-p :在commit时，将容器暂停。
Docker 容器数据卷
如果数据都在容器中，那么我们容器删除，数据就会丢失
需求：数据持久化
容器之间有一个数据共享的技术，Docker容器中产生的数据，同步到本地
这就是卷技术
将容器内的目录挂载到本地系统上
使用数据卷
方式一、直接使用命令来挂载 -v
#docker run -it -v -p 主机端口：容器内端口 端口映射
docker run -it -v 主机目录：容器内目录
查看
docker inspect 容器ID
"Mounts": [
{
"Type": "bind",
"Source": "/test",
"Destination": "/home",
"Mode": "",
"RW": true,
"Propagation": "rprivate"
},
{
"Type": "volume",
"Name": "61143c0d71c615ad73b2ae4bb8505aa07c0bde53be35ab669f4c194bb8eced86",
"Source": "/var/lib/docker/volumes/61143c0d71c615ad73b2ae4bb8505aa07c0bde53be35ab669f4c194bb8eced86/_data",
"Destination": "/var/lib/mysql",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
挂载mysql
docker run --name mysql -p 3307:3306 -v /test/mysql/conf:/etc/mysql/conf.d -v /test/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7
docker run -d -p 3306:3306 -v /usr/local/dockerfile/mysql/log:/var/log/mysql -v /usr/local/dockerfile/mysql/conf:/etc/mysql/conf.d -v /usr/local/dockerfile/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7
#注释 将mysql容器内的conf和data目录挂载到宿主机的/test/mysql 、 /usr/local/dockerfile/mysql目录
具名和匿名挂载
#匿名挂载
-v 容器路径
docker run -d -p --name nginx -v /etc/nginx nginx
只写了容器内路径
可以通过docker volume ls 查看
#具体名挂载
-v 名称：容器路径（名称前面没有/，有/就是代表路径了）
docker run -d -p --name nginx -v juming:/etc/nginx nginx
可以通过docker volume inspect juming查看
在没有指定主机目录的情况下，所有挂载默认路径在 /var/lib/docker/volumes/ 目录下
DockerFile初体验
方式二、DockerFile
dockerFile就是用来构建docker镜像的文件
#文件内容 匿名挂载
[root@localhost dockerfile]# cat dockerfile1
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "-------end--------"
CMD /bin/bash
#命令 docker build -f /usr/local/dockerfile/dockerfile1 -t zjy/centos:1.0 .
[root@localhost dockerfile]# pwd
/usr/local/dockerfile
[root@localhost dockerfile]# docker build -f /usr/local/dockerfile/dockerfile1 -t zjy/centos:1.0 .
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM centos
---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
---> Running in 31920a7d7bad
Removing intermediate container 31920a7d7bad
---> 711122db9aae
Step 3/4 : CMD echo "-------end--------"
---> Running in 7d05ef10ad31
Removing intermediate container 7d05ef10ad31
---> 5695eb00a99e
Step 4/4 : CMD /bin/bash
---> Running in 2468f5e0a9e5
Removing intermediate container 2468f5e0a9e5
---> 210bb64dac21
Successfully built 210bb64dac21
Successfully tagged zjy/centos:1.0
[root@localhost dockerfile]#
查看镜像
[root@localhost dockerfile]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
zjy/centos 1.0 210bb64dac21 2 minutes ago 231MB
nginx latest 51086ed63d8c 13 days ago 142MB
centos latest 5d0da3dc9764 13 months ago 231MB
[root@localhost dockerfile]#
通过编写dockerfile文件，再执行docker build命令生成一个镜像
[root@1685c20eca8f /]# ls -l
total 0
lrwxrwxrwx. 1 root root 7 Nov 3 2020 bin -> usr/bin
drwxr-xr-x. 5 root root 360 Oct 19 02:07 dev
drwxr-xr-x. 1 root root 66 Oct 19 02:07 etc
drwxr-xr-x. 2 root root 6 Nov 3 2020 home
lrwxrwxrwx. 1 root root 7 Nov 3 2020 lib -> usr/lib
lrwxrwxrwx. 1 root root 9 Nov 3 2020 lib64 -> usr/lib64
drwx------. 2 root root 6 Sep 15 2021 lost+found
drwxr-xr-x. 2 root root 6 Nov 3 2020 media
drwxr-xr-x. 2 root root 6 Nov 3 2020 mnt
drwxr-xr-x. 2 root root 6 Nov 3 2020 opt
dr-xr-xr-x. 286 root root 0 Oct 19 02:07 proc
dr-xr-x---. 1 root root 27 Oct 19 02:07 root
drwxr-xr-x. 11 root root 163 Sep 15 2021 run
lrwxrwxrwx. 1 root root 8 Nov 3 2020 sbin -> usr/sbin
drwxr-xr-x. 2 root root 6 Nov 3 2020 srv
dr-xr-xr-x. 13 root root 0 Oct 19 00:15 sys
drwxrwxrwt. 7 root root 171 Sep 15 2021 tmp
drwxr-xr-x. 12 root root 144 Sep 15 2021 usr
drwxr-xr-x. 20 root root 262 Sep 15 2021 var
drwxr-xr-x. 3 root root 18 Oct 19 02:18 volume01
drwxr-xr-x. 2 root root 6 Oct 19 02:07 volume02
#在刚刚自己创建镜像中，能看到volume 01 和 02，一定与外部有一个同步的目录
使用docker inspect 容器ID 查看挂载信息
数据卷容器
容器之间数据共享
以上面dockerfile文件制作的镜像为基础
#启动第一个容器
docker run -itd --name d01 zjy/centos:1.0
#启动第二个容器，并通过volumes-from挂载到d01（相当于d02继承了d01一样）
docker run -itd --name d02 --volumes-from d01 zjy/centos:1.0
d01就是数据卷容器
进入容器后，通过ls -l可以看到在d01和d02中都有volume01和volume02两个文件夹
#在任意一个容器的volumes01或volumes02目录中创建文件，在另一个容器可以看到是同步的
当容器d01删除后，d02依然还会有这份数据。所以只要还有容器再用，数据就不会丢失
#例一、多个mysql数据同步
docker run -d -p 3306:3306 -v /usr/local/dockerfile/mysql/log:/var/log/mysql -v /usr/local/dockerfile/mysql/conf:/etc/mysql/conf.d -v /usr/local/dockerfile/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7.39
docker run -d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=root --name mysql02 --volumes-from mysql mysql:5.7.39
DockerFile
#dockerFile是用来构建docker镜像的文件!
构建步骤：
1.编写dockerfile文件
2.docker build 构建成一个镜像
3.docker run 运行
4.docker push 发布(DockerHub、阿里云镜像仓库)
#----------------------------------------------------
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "-------end--------"
CMD /bin/bash
#----------------------------------------------------
基础知识：
1.每个保留关键字（指令）都必须是大写字母
2.指令按从上到不的顺序执行
3.#表示注释
4.每一个指令都会创建一个新的镜像层并提交
dockerfile是面向开发的，我们以后发布项目、做镜像就需要编写dockerfile文件
Docker镜像已经逐渐成为企业交付的标准
指令说明：
FROM xxx #基础镜像，一切从这里开始构建
MAINTAINER xxx #指定作者 例如 姓名+邮箱
RUN xxx #镜像构建时需要运行的命令
ADD xxx #添加一个需要的功能，例如需要添加一个mysql
WORKDIR xxx #镜像工作目录
VOLUME xxx #需要挂载到哪个位置
EXPOSE xxx #指定对外暴露的端口
CMD xxx #指定容器启动时需要运行的命令 只有最后一个才生效，可被替代
ENTRYPOINT xxx #指定容器启动时需要运行的命令 可以追加命令
ONBUILD #当构建一个被继承 dockerfile ，这个时候就需要运行 OBBUILD 指令
COPY xxx #类似ADD，把文件拷贝到镜像中
ENV xxx #构建的时候，设置环境变量
CMD 与 ENTRYPOINT区别
#CMD
#------dockerfile--------
FROM centos
CMD ["ls","-a"]
#------------------------
docker build -f docker-cmd-test -t cmdtest:1.0 .
docker run -it mycentos:1.0
会发现一进入容器就会默认执行ls -a列出所有目录
docker run 4fa4e686165d -l 会报错
#ENTRYPOINT
#------dockerfile--------
FROM centos
ENTRYPOINT ["ls","-a"]
#------------------------
docker build -f docker-entrypoint-test -t entrypoint:1.0 .
docker run -it entrypoint:1.0
会发现一进入容器就会默认执行ls -a列出所有目录
docker run 4fa4e686165d -l 不会报错，并且会列出所有目录
实战测试：创建自己的centos
#99%的镜像都是以 FROM scratch 为基础的，然后再配置需要的软件
一、编写dockerfile配置文件
#-----------------------------------------------
FROM centos
MAINTAINER zjy<2542309709@qq.com>
#环境目录
ENV MYPATH /usr/local
#工作目录
WORKDIR $MYPATH
#安装自己需要的软件
RUN cd /etc/yum.repos.d/
RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
RUN yum makecache
RUN yum update -y
RUN yum -y install vim
RUN yum -y install net-tools
#暴露1111端口
EXPOSE 1111
#输出
CMD echo $MYPATH
CMD echo "--------------end----------------"
#启动时执行该命令
CMD /bin/bash
#-----------------------------------------------
二、构建容器
docker build -f mydockerfile-centos -t mycentos:1.0 .
#docker history 镜像ID 可以查看镜像的构建过程
三、创建并启动容器
docker run -it mycnetos:1.0
Dockerfile制作tomcat镜像
一、编写dockerfile配置文件,就以Dockerfile命名，官方命名，使用这个名字可以在build的时候不写 -f
#-----------------------------------------------
FROM centos
MAINTAINER zjy<2542309709@qq.com>
#ADD指令会自动解压安装包
ADD apache-tomcat-9.0.68.tar.gz /usr/local/
ADD jdk-8u261-linux-x64.tar.gz /usr/local/
#环境目录
ENV MYPATH /usr/local
#工作目录
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_261
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.68
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.68
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.68/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.68/logs/catalina.out
#-----------------------------------------------
二、构建镜像
docker build -t zjytomcat .
三、创建容器
docker run -d -p 9090:8080 --name zjytomcat -v /usr/local/dockerfile/tomcat/test:/usr/local/apache-tomcat-9.0.68/webapps/test -v /usr/local/dockerfile/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.68/logs zjytomcat
四、访问
http://192.168.245.128:9090/
DockerFile打包jar包
1.目录
[root@localhost jdcx]# ls
dist Dockerfile easy-web-app.jar logs
[root@localhost jdcx]#
2.Dockerfile
# 基础镜像使用java
FROM openjdk:8-jre-alpine
#设置字符集
ENV LANG en_US.UTF-8
#启动端口
EXPOSE 82
#启动命令
ENTRYPOINT ["java","-XX:+UnlockExperimentalVMOptions","-XX:+UseCGroupMemoryLimitForHeap","-jar","-Duser.timezone=Asia/Shanghai","/data/easy-web-app.jar"]
3.docker build -t jdcx-web:1.0 .
4.启动容器
docker run -d --name jdcxweb -p 82:82 jdcx-web:1.0
发布镜像到DockerHub
#1.注册docker hub 账号
https://hub.docker.com/
#2.在服务器上提交我们的镜像
[root@localhost dockerfile]# 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
docker login -u xxx
#3.发布镜像 push
docker push zjy/zjytomcat:1.0
如果提示 tag does not exist: zjytomcat:1.0 可以增加一个tag
#docker tag 镜像id 注册的用户名/zjytomcat:1.0
docker tag 9b85b4236809 standupzjy/zjytomcat:1.0
docker push standupzjy/zjytomcat:1.0
Docker网络
理解 docker0
# ip addr 查看网卡
#进入容器内部查看网卡信息,会发现docker给容器分配了一个名为docker0的网卡信息
发现宿主机可以互ping通容器内部IP地址
#只要安装了docker，就会分配一个docker0的网卡，只要docker启动了容器，就会给容器分配一个IP
容器与容器之间也是可以互ping的
#所有容器在不指定网络的情况下，都是通过docker0路由的
容器互联 --link
假如我们编写了一个服务，其中数据库连接是通过IP指定的，如果数据库IP换掉了，我们如何访问？如果处理这个问题，可以通过名字进行访问
# 通过 --link进行连接
docker run -d -P --name a1 --link a2 tomcat
这样就可以直接在a1中 ping a2了，而不是通过IP进行ping
但是这样的方式只能 a1 ping a2,不能a2 ping a1;因为在 --link 的时候其实是a1这边做了hosts的配置
# cat /etc/hosts 容器内查看hosts配置
[root@d5f0fd44bae3 local]# 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.4 d5f0fd44bae3
172.17.0.5 a2 0d1694b0bf0f
#发现
a1 : 172.17.0.4
a2 : 172.17.0.5
有这样一条配置 172.17.0.5 a2 0d1694b0bf0f
所以可以直接通过 ping a2 访问
如果在a1中编辑/etc/hosts文件 172.17.0.4 a1 0d1694b0bf0f
则可以a2 ping a1了
以前容器只能 ping IP
现在可以ping 容器名了
容器内安装软件
# 先配置 /etc/docker/daemon.json,写入以下配置，如果没有这个文件就新建一个
{
"registry-mirrors":[
"https://9cpn8tt6.mirror.aliyuncs.com",
"https://registry.docker-cn.com"
],
"dns":["8.8.8.8","114.114.114.114"]
}
# 重启docker
systemctl restart docker.service
# 进入容器内再安装软件
# apt update 必须先执行
常用软件 [vim] [ping] [ip addr]
# 安装ipaddr
apt install -y iproute2
# 安装ifconfig
apt install -y net-tools
# 安装ping
apt install -y iputils-ping
# 安装vim
apt install -y vim
# 批量安装
apt update && apt install -y iproute2 && apt install -y net-tools && apt install -y iputils-ping && apt install -y vim
自定义网络
#创建自定义网络 (推荐使用)
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
#不写 --driver 默认也是 bridge模式
#查看自己配置的网络
docker network ls
NETWORK ID NAME DRIVER SCOPE
be2fb090ab09 bridge bridge local
38e49e42262e host host local
2b8a818fdf2b mynet bridge local
878c51da0a0b none null local
可以看到一条 NAME=mynet的网络配置
#使用自定义网络 --net mynet
docker run -d -P --name tomcat-net-01 --net mynet tomcat
docker run -d -P --name tomcat-net-02 --net mynet tomcat
自定义网络的好处就是，不需要 --link，即可以ping IP,也可以ping 容器名
网络连通
1.如果自定义了一个网络mynet
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
docker0的网络是否可以和自定义网络mynet连通？
如果想实现这样的效果，那么需要做一个网络连接
#docker network connect [options] NETWORK CONTAINER
docker network connect mynet d01
这样d01容器就能ping mynet的网络了
Docker安装Nginx
docker search nginx
docker pull nginx
#新建一个测试容器
docker run -d --name nginx-test -p 7777:80 nginx
#把测试容器的配置文件copy的宿主机目录
docker cp nginx-test:/etc/nginx /usr/local/docker/nginx/conf
#删除测试容器
docker rm -f nginx-test
#启动容器并挂载
docker run --name nginx -p 8080:80 -v /usr/local/docker/nginx/conf:/etc/nginx -v /usr/local/docker/nginx/html:/usr/share/nginx/html -v /usr/local/docker/nginx/logs:/var/log/nginx -d nginx
#这样做的目录是防止在直接挂载的时候报错，会提示提示找不到nginx配置目录
#我的目录
/usr/local/dockerfile/nginx
#启动nginx
docker start nginx
#测试连接
curl localhost:8080
#如果访问403，在nginx/html目录下面新建一个index.html,写入Hello World就可以了
要想编辑nginx配置
下载vim
因为容器是与本地隔绝的，所以我们要先安装vim
apt-get update #更新包管理
apt-get install vim -y #安装vim
root@99e97eefcc5a:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
nginx配置目录 /etc/nginx
nginx的html文件目录/usr/share/nginx
vim etc/nginx/nginx.conf
Docker安装Redis
#1.拉取镜像
docker pull redis
#2.创建宿主机文件挂载目录，自已选择
mkdir -p /usr/local/dockerfile/redis/6379/
#3.网站可以下载对应的redis.conf
https://hub.docker.com/_/redis
#4.把自己下载的redis.conf上传到redis6379目录中
#5.新建容器并挂载
docker run --restart=always --log-opt max-size=100m --log-opt max-file=2 -p 6379:6379 --name redis6379 -v /usr/local/dockerfile/redis/6379/conf/redis.conf:/etc/redis/redis.conf -v /usr/local/dockerfile/redis/6379/data:/data -d redis redis-server /etc/redis/redis.conf --appendonly yes --requirepass zjyjava
#-----------------------------------参数解释--------------------------------------#
–restart=always 总是开机启动
–log是日志方面的
-p 6379:6379 将6379端口挂载出去
–name 给这个容器取一个名字
-v 数据卷挂载
/home/redis/myredis/myredis.conf:/etc/redis/redis.conf 这里是将 liunx 路径下的myredis.conf 和redis下的redis.conf 挂载在一起。
/home/redis/myredis/data:/data 这个同上
-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 设置密码
#-----------------------------------END--------------------------------------#
#6.进入容器
docker exec -it redis6379 redis-cli
#7.先验证密码
auth zjyjava
#8.查看密码
config get requirepass
Redis集群
分片 + 高可用+ 负载
r-m1 r-m2 r-m3
r-s1 r-s2 r-s3
有这样六台主机，3台master,3台slave。当master挂掉之后,slave要能够顶上去
# 1.构建一个redis网络
docker network create redis-net --subnet 172.38.0.0/16
# 2.shell脚本创建6个redis配置
for port in $(seq 1 6);
do
mkdir -p /usr/local/docker/redis-cluster/node-${port}/conf
touch /usr/local/docker/redis-cluster/node-${port}/conf/redis.conf
cat <<EOF>/usr/local/docker/redis-cluster/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done
# 3.创建6个redis容器
# 格式
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /usr/local/docker/redis-cluster/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-v /usr/local/docker/redis-cluster/node-${port}/data:/data \
-d --net redis-net --ip 172.38.0.1${port} redis redis-server /etc/redis/redis.conf
# shell脚本创建
for port in $(seq 1 6);
do
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} -v /usr/local/docker/redis-cluster/node-${port}/conf/redis.conf:/etc/redis/redis.conf -v /usr/local/docker/redis-cluster/node-${port}/data:/data -d --net redis-net --ip 172.38.0.1${port} redis redis-server /etc/redis/redis.conf
done
# 4.创建集群
docker exec -it redis-1 /bin/sh
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
# 5.查看
docker exec -it redis-1 redis-cli -c
cluster info 查看集群信息
cluster nodes 查看节点信息
Docker安装Mysql
#1.拉取镜像
docker pull mysql:5.7
#2.建立挂载目录
mkdir -p /usr/local/docker/mysql
#3.创建容器并挂载目录
docker run -d -p 3306:3306 -v /usr/local/docker/mysql/log:/var/log/mysql -v /usr/local/docker/mysql/conf:/etc/mysql/conf.d -v /usr/local/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7
Docker安装Jenkins
docker pull jenkins/jenkins
mkdir -p /usr/local/docker/jenkins
chmod 777 /usr/local/docker/jenkins
docker run -d -u root --name jenkins -p 8850:8080 -v /usr/local/docker/jenkins/jdk1.8:/usr/local/src/jdk/jdk1.8 -v /usr/local/docker/jenkins/maven:/usr/local/maven -v /usr/local/docker/jenkins/jenkins_home:/var/jenkins_home jenkins/jenkins
vi /usr/local/docker/jenkins/jenkins_home/hudson.model.UpdateCenter.xml
#将 url 修改为 清华大学官方镜像：https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json
cat /usr/local/docker/jenkins/jenkins_home/secrets/initialAdminPassword 查看密码
输入密码后，选择 安装推荐的插件
等待插件安装
Docker安装Git-Lab
#1.接取镜像
docker pull gitlab/gitlab-ce
#2.在宿主机创建目录
mkdir -p /usr/local/docker/gitlab/config
mkdir -p /usr/local/docker/gitlab/data
mkdir -p /usr/local/docker/gitlab/logs
#3.启动容器
docker run -d -p 4430:443 -p 800:80 -p 220:22 --name gitlab -v /usr/local/docker/gitlab/config:/etc/gitlab -v /usr/local/docker/gitlab/logs:/var/log/gitlab -v /usr/local/docker/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce
#4.修改配置
vi /usr/local/docker/gitlab/config/gitlab.rb
# 配置http协议所使用的访问地址,不加端口号默认为80
external_url 'http://192.168.245.128'
# 配置ssh协议所使用的访问地址和端口
gitlab_rails['gitlab_ssh_host'] = '192.168.245.128'
gitlab_rails['gitlab_shell_ssh_port'] = 220 # 此端口是run时22端口映射的220端口
#配置超时设置
gitlab_rails['webhook_timeout'] = 90
gitlab_rails['git_timeout']=90
http://192.168.245.128:800
#刚启动页面会显示 502，稍等一个就好了
查看root的初始密码：
docker exec -it gitlab grep 'Password:' /etc/gitlab/initial_root_password
SpringBoot服务打包Docker镜像
# 查看端口占用情况
netstat -apn|grep 9999
# 查看端口详细信息
netstat -apn|grep 9999
# 杀掉进程
kill -9 9999
# 一、编写Dockerfile
FROM java:8
MAINTAINER standupzjy<2542309709@qq.com>
RUN mkdir -p /usr/local/projects
WORKDIR /usr/local
ADD *.jar /usr/local/projects/app.jar
CMD ["--server.port=9999"]
EXPOSE 9999
ENTRYPOINT ["java", "-jar", "/usr/local/projects/app.jar"]
# 二、把jar包和Dockerfile上传到服务器后开始构建
docker build -t standup-cyco .
docker run -d -p 9999:9999 --name cyco standup-cyco
# 三、前端配置,先挂载安装nginx
#------------------------------前端----------------------------------------
# nginx.conf
# 注意，nginx.conf中的路径，是容器内的路径，不是宿主机的路径
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
gzip on;
ssi on;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
map $time_iso8601 $logdate {
'~^(?<ymd>\d{4}-\d{2}-\d{2})' $ymd;
default 'date-not-found';
}
access_log /var/log/nginx/access-$logdate.log main;
server {
listen 80;
server_name 127.0.0.1;
location / {
root /usr/share/nginx/html;
index index.html index.htm;
try_files $uri $uri/ /index.html;
}
location /api {
proxy_pass http://192.168.245.128:9999;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size 500m;
proxy_next_upstream off;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
#assessmgmt_front
#credit_web_xygz
#credit_web_xynb
#assesscontrol_front
#----------------------------------------------------------------------------------------------
# 四、把前端打好包放到指定目录下
# 五、查看连接是否正常，然后就能正常访问了
Jenkins
jenkins插件
maven maven工具
puslish over ssh 发布工具
Build Authorization 访问jenkins触发器的链接时触发构建，可以免登录
全局配置中配置maven的settings.xml的路径
系统配置中配置publish ssh(远程ssh主机)的地址，配置完成后在maven项目里面可以选择构建完成后推送到ssh服务器
服务器需要装git yum install git
jenkins在配置git的时候，如果输入了链接还提示错误，需要检查gitlab的完整链接 IP和端口
jenkins在配置maven或jdk路径的时候，一定是配置容器内的路径，而不是宿主机的路径。包括maven中的仓库配置也是在容器内
SSH publish超时机制
输出命令时一定注意不要让窗口卡住，不然jenkins会认为构建一直没完成
例如当我们在配置jenkins项目的后置执行 nohup java -jar xxx.jar $后，会启动Java程序，并生成一个nohut.out文件
再次构建还会去启动java文件，这个时候可能会报错
shell的日志输出
nohup java -jar /usr/local/app.jar >mylog.log 2>&1 &
**数据流重定向**
数据流重定向就是将某个命令执行后应该要出现在屏幕上的数据传输到其他地方
标准输入 stdin：代码为0，使用<或<<
标准输出 stdout：代码为1，使用>或>>
标准错误输出 stderr：代码为2，使用2>或2>>
>覆盖写
>>追加写
前置执行shell脚本
前置执行sehll的目的是关闭之前运行的进程，然后重新启动。就不会在未关闭之前启动导致卡住
脚本后缀是sh,例如 aaa.sh。用 ./aaa.sh执行
#------------------------------START----------------------------
#删除历史数据
rm -rf nohup.out
#获取正在运行的jar包的pid
pid=`ps -ef | grep cyco | grep 'java -jar' | awk '{printf $2}'`
#声明的pid是变量，用$取值
echo $pid
#杀死进程
kill -9 $pid
#------------------------------END----------------------------
获取传进来的参数，用$1接收；例如执行脚本时 ./aaa.sh cyco
#------------------------------START----------------------------
#删除历史数据
rm -rf nohup.out
#获取正在运行的jar包的pid
pid=`ps -ef | grep $1 | grep 'java -jar' | awk '{printf $2}'`
#声明的pid是变量，用$取值
echo $pid
#杀死进程
kill -9 $pid
#------------------------------END----------------------------
获取传进来的参数，用$1接收；例如执行脚本时 ./aaa.sh cyco
#------------------------------START----------------------------
#删除历史数据
rm -rf nohup.out
#赋值传进来的参数
appname=$1
echo $appname
#获取正在运行的jar包的pid
pid=`ps -ef | grep $appname | grep 'java -jar' | awk '{printf $2}'`
#-z判空，前面一定有空格，固定写法
#如果pid是空的就提示，否则执行kill命令
if [ -z $pid ]
then
echo "$appname:$pid not started..."
else
#杀死进程
kill -9 $pid
echo "$appname:$pid stoping..."
#fi用于闭环if
fi
#------------------------------END----------------------------
#来自jpom，非jenkins
#----------------------------START----------------------------
#进入项目部署目录
cd /usr/local/project/dcy-fast
#赋值jar名称
appName=dcy-web
echo $appName
#当前运行环境(dev,test,prod)
env=test
#删除历史数据
rm -rf $appName.log
rm -rf logs
#创建备份目录
mkdir backups
#获取正在运行的jar包的pid
pid=`ps -ef | grep $appName | grep 'java -jar' | awk '{print $2}'`
echo "当前运行的dcy-web.jar pid:$pid"
#-z判空，前面一定有空格，固定写法
#如果pid是空的就提示，否则执行kill命令
if [ -z $pid ]
then
echo "$appName:$pid not started..."
else
#杀死进程
kill -9 $pid
echo "$appName:$pid stoping..."
#fi用于闭环if
fi
#启动jar包
echo "$appName:waiting with start"
nohup java -jar $appName.jar --spring.profiles.active=$env >$appName.log 2>&1 &
echo "$appName:Application started successfully"
#备份jar包
echo "开始执行$appName.jar包备份"
currDate=`date '+%Y%m%d%H%M'`
cp -R dcy-web.jar ./backups/dcy-web$currDate.jar
echo "dcy-web.jar包备份完成,名称:dcy-web$currDate.jar"
# 删除一天前创建的文件
echo "开始删除前一天创建的件"
find ./backups -name "*.jar" -ctime +1 -type f -exec rm -rf {} ;
echo "前一天创建的文件删除完成"
#------------------------------END----------------------------
效果
[root@192 jenkins]# ./stop.sh bai
bai
bai:25540 stoping...
jenkins cron表达式
每隔5分钟构建一次
H/5 * * * *
每两小时构建一次
H H/2 * * *
每天中午12点定时构建一次
H 12 * * *
每天下午18点定时构建一次
H 18 * * *
在每个小时的前半个小时内的每10分钟
H(0-29)/10 * * * *
每两小时45分钟，从上午9:45开始，每天下午3:45结束
45 9-16/2 * * 1-5
每两小时一次，每个工作日上午9点到下午5点(也许是上午10:38，下午12:38，下午2:38，下午4:38)
H H(9-16)/2 * * 1-5
Poll SCM
自动每隔一段固定时间去检查版本管理工具（SVN/GIT）上的代码是否有改动，如果有改动就进行构建.专业术语就是：定时检查源码变更（根据SCM软件的版本号），如果有更新就checkout最新code下来，然后执行构建动作
Build periodically：周期进行项目构建（源码是否发生变化没有关系）
每15分钟构建一次：H/15 * * * * 或*/5 * * * *
每天8点构建一次：0 8 * * *
每天8点~17点，两小时构建一次：0 8-17/2 * * *
周一到周五，8点~17点，两小时构建一次：0 8-17/2 * * 1-5
每月1号、15号各构建一次，除12月：H H 1,15 1-11 *
*/5 * * * * （每5分钟检查一次源码变化）
0 2 * * * （每天2:00 必须build一次源码）
