Docker介绍及使用

最新推荐文章于 2023-08-27 14:46:22 发布

feng_zi-06

最新推荐文章于 2023-08-27 14:46:22 发布

阅读量1.4k

点赞数 2

文章标签： docker

本文链接：https://blog.csdn.net/weixin_43688217/article/details/121466652

版权

Docker为什么出现?

1.从开发到上线, 存在多套环境配置, 如:本地集成环境,测试环境,UAT环境,FAT环境,生产环境等.

2.版本的升级导致服务不可用, 这里...程序员经常会说在我的电脑上好好的啊,怎么在你那跑不起来了.

3.环境部署繁琐,每个服务都需要各种redis , MQ, Hadoop,elasticSearch中间件

*如果一个项目可以带上自身的环境打包**

**Docker给以上的问题,提出了解决方案**

1.java -> 打包 -> jar带上环境(镜像) -> Docker类似于一个应用商店 -> 相爱在发布需要的镜像 -> 开始运行

这里的镜像就类似,下载windows系统会自己带一些系统软件是一样的

2.Docker具备隔离性 , 避免了端口冲突 ,就类似于一个集装箱 ,相互之间隔离起来

3.一次编译到处运行，类似于java代码，应用及依赖的环境构建一次，可以到处运行

官网:Docker Documentation | Docker Documentation

仓库地址:Docker Hub

Docker能做什么

容器化技术不是模拟一个完整的操作系统，而是提取了核心的东西

Docker和虚拟机技术的不同

<u>传统虚拟机</u>：虚拟出一个硬件，运行一个完整的操作系统，然后在这个系统上安装运行软件

容器内的应用直接运行在宿主机的内容，容器是没有自己的内核，也没有硬件，所以很轻便

每个容器间是相互隔离的，容器内部有一个属于自己的文件系统，互不影响

镜像：就好比一个模板，可以通过这个模板创建容器服务，最终运行是在容器中运行

容器： Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建

仓库：就是存放镜像的地方，分为公有仓库和私有仓库。Docker Hub（默认国外）

安装Docker

CentOS 7版本

查看环境: 系统内核是3.10以上的

[banklogop@SYSOPS00204162 ~]$ uname -r
3.10.0-693.el7.x86_64
[banklogop@SYSOPS00204162 ~]$

系统版本：

cat /etc/os-release

卸载旧版本：

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

1.需要的安装包

yum install -y yum-utils

2.镜像

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 makecache fast

3.相关

# docker-ce 社区版 ee 企业版
yum install docker-ce docker-ce-cli containerd.io

查看安装是否成功

docker version

启动docker

systemctl start docker

运行hello-world

docker run hello-world
docker images  # 查看镜像

卸载Docker

yum remove docker-ce docker-ce-cli containerd.io # 卸载依赖
rm -rf /var/lib/docker  # 删除目录资源
rm -rf /var/lib/containerd

Docker底层原理

Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上，通过Socket从客户端访问，DockerServer接收到Docker-Client的指令，就会执行这个命令。

Docker的常用命令

帮助命令

docker version		#版本信息
docker info 		#系统信息，包括镜像和容器的数量
docker --help		#帮助命令
docker 命令 --help

帮助文档地址：

https://docs.docker.com/engine/reference/commandline/apphttps://docs.docker.com/engine/reference/commandline/app

镜像命令

docker images			#查看所有本地主机上的镜像
docker images --help	#查看此命令可以加的参数
#例
-a						#列出所有
-q						#只显示镜像的id

docker search 搜索镜像

#可通过条件过滤 镜像STARS大于3000的
--filter=STARS=3000
docker search [OPTIONS]
#例
docker search mysql

也可以通过docker的hub库查找

Docker Hub

docker pull 下载镜像

docker pull 镜像名 :tag	  #tag为版本号

docker pull mysql		  #例; 不写参数 默认下载最新版本
docker pull mysql:5.7

docker rmi 删除镜像

#例：
docker images
docker rmi -f e73346bd465		      #rmi 镜像 -f全部删除 可以根据id或者名字删除，可以指定多个
docker rmi -f $(docker images -aq)    #可以传参数，先查出所有，然后递归全部删除

容器命令

有了镜像才可以创建容器，下载一个centos镜像来测试学习

docker pull centos

新建容器并启动

docker run [可选参数] image
#参数说明
--name            容器名字 tomcat1 tomcat2 用来区分容器
-d                后台方式运行
-it                使用交互方式运行，进入容器查看内容      
-p                指定容器端口
    -p ip:主机端口：容器端口
    -p 主机端口：容器端口 （常用）
    -p 容器端口
    容器端口
-P                绑定指定端口

例：
docker run -it centos /bin/bash         #启动并进入容器

exit                                    #从容器中退回主机，容器会停止运行
ctrl + P + Q                            #容器不停止

列出所有运行的容器

docker ps                #列出当前正在运行的容器
-a                       #列出当前正在运行的容器 + 历史运行过的容器
-n=?                     #显示最近创建的容器
-q                       #只显示容器编号

删除容器

docker -rm 容器id                 #根据id删除
docker -rm -f $(docker ps -aq)    #删除所有

启动/停止容器操作

docker start 容器id        #启动容器
docker restart 容器id      #重启容器
docker stop 容器id         #停止容器
docker kill 容器id         #强制停止当前容器

常用其他命令

后台启动容器

# 命令 docker run -d 镜像名
docker run -d centos
#docker ps 发现 centos 停止了

#这里有一个坑，docker 容器使用后台运行，就必须有一个前台程序，docker如果发现没有应用就会自动停止
#nginx容器启动后，发现自己没有提供服务，就会立刻停止

查看日志

docker logs -f -t --tail 容器id            #-f展示所有信息，-t展示时间戳，-tail以字符串的形式炸展示


docker logs -f -t --tail 10 容器id         #展示10条

docker run -d centos /bin/sh -c "while true;do echo hello;sleep 1;done"        #如果没有日志，现插入一条日志输出

docker logs -tf --tail 10 容器id           #-tf展示所有

查看容器中进程信息

docker top 容器id        #杀进程时可以用

查看镜像元数据

docker inspect 容器id

进入当前正在运行的容器

#容器通常都是使用后台方式运行的，需要进入容器，修改一些配置时

docker exec -it 容器id bashShell

#例：
docker ps
docker exec -it 容器id /bin/bash        #/bin/bash 通过bash命令行进入
ps -ef


方式二：
docker attach 容器id

区别：
docker exec        #进入容器后开启一个新的终端，可以在里面操作
docker attach      #进入容器正在执行终端，不会启动新的进程

从容器内拷贝文件到主机

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

#例：
docker ps
docker attach 容器id
cd  /home
ls
touch test.java
exit
docker ps -a
docker cp 容器id:/home/test.java  /home

练习

部署nginx

docker search nginx        #搜索
#在hub.docker.com库查看有那些版本号

docker pull nginx          #下载
docker images              #查看镜像

docker run -d --name nginx01 -p 3344:80 nginx   #运行 -d后台运行，--name起名字-p 3344宿主机端口，80容器内部端口
docker ps                  #查看
curl localhost:3344        #自测

docker exec -it nginx01 /bin/bash               #进入容器内部
whereis nginx                                   #查找配置文件在那个目录

部署tomcat

docker run -it --rm tomcat:9.0        #管网推荐，运行的时候就会去下载，用完就删除，适合测试


docker pull tomcat:9.0
dokker images
docker run -d -p 3335:8080 --name tomacet01 tomcat
docker exec -it tomcat01 /bin/bash

#发现问题 1.linux命令少了 2.没有webapps 阿里云镜像原因，默认是最小的镜像，不必要的都剔除掉了，保证最小可运行的环境

部署ES+kibana

#es 暴露的端口很多
#es 十分的耗内存
#es 的数据一般需要放置到安全目录！挂载

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

#启动 linux就很卡
docker stats            #查看cpu状态
curl localhost:9200     #自测

#增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES-JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

可视化工具

portainer 是Docker的图形化界面管理工具 Rancher（CI/CD再用）

#--restart=always 启动方式 -v /var/run/docker.sock:/var/run/docker.sock 挂载 --privileged=true 权限
docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

curl localhost:8088        #本机测试

外网测试： ip:8088

设置登录密码

commit镜像

commit之后会把原有服务的配置打成一个新的镜像

docker commit            #提交容器成为一个新的版本
#参数： -a 作者，-m 描述，-p 提交时，将容器暂停

#例
docker images
docker run -it -p 8080:8080 tomcat
docker ps
docker exec -it 容器id /bin/bash
cd webapps
ls
cd ..
cp -r webapps.dist/* webapps
docker ps
docker commit -a="author" -m="description" 容器id tomcat02:1.0.0
docker images

容器数据卷

什么是容器数据卷

在使用docker容器的时候，会产生一系列的数据文件，（如mysql数据库的数据）这些数据文件在删除容器时是会消失的，但是有时候里面的数据是有价值的，如果容器之间有一个共享的技术，Docker容器中产生的数据，同步到本地！

这就是卷技术，目录挂载，将容器内部的目录挂载到linux上面！实现容器的持久化和同步操作，并支持数据共享！

使用数据卷

方式一：

docker run -it -v /宿主机目录:/ 容器内目录镜像名

docker run -it -v /home/test:/home centos /bin/bash  #在home添加数据就会同步到/home/test下
docker inspect 容器id            #查看是否挂载成功

好处：在linux上修改配置，会同步到容器内部的配置

MySQL同步数据

docker search mysql
docker pull mysql:5.7
#运行数据，需要数据挂载 注意安装启动msyql的时候需要配置密码

docker images
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

# -d后台运行
# -p端口隐射
# -v卷挂载
# -e环境配置
# --name容器名字

具名和匿名挂载

#匿名挂载
-v 容器内路径
docker run -d -p --name nginx01 -v /etc/nginx nginx
docker volume --help
docker volume ls            #查看所有卷的情况

#这里发现,在-v只写了容器内路径,没有写容器外路径,这就是匿名挂载


#具名挂载
docker run -d -p --name nginx02 -v juming-nginx:etc/nginx nginx
docker volume ls
docker volume inspect juming-nginx    #查看挂载路径

#通过-v 卷名:容器内路径
#所有docker容器内的卷,没有指定目录的情况下都是在/var/lib/docker/volumes/下
通过具名挂载可以方便的找到我们的卷,大多数情况使用的具名挂载

区分具名挂载,匿名挂载,指定路径挂载

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

拓展:

#通过 -v 容器内路径 ro rw 改变读写权限
ro readonly  #只读
rw readwrite #可读写

#一旦设置了容器权限,容器对我们挂载出来的内容就有限定了
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

#ro 只要看到ro就说明这个路径只能通过宿主机来操作,容器内部是无法操作!

Dockerfile

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

步骤:

1.创建一个Dockerfile 文件,名字可以随意,建议Dockerfile

2.文件中的内容如下: 切记!指令要大写 (这里的每个命令就代表镜像的一层)

FROM centos
VOLUME {"volume01","volume02"}
CMD echo "...end..."
CMD /bin/bash

3.开始构建镜像,在存放dockerfile的目录下执行,最后的.代表上下文路径

docker build -f /home/docker-test-volume/dockerfile1 -t test/centos:1.0 .

4.启动镜像

docker images
docker run -it 容器id /bin/bash

这种构建自己的镜像,以后会很常用,VOLUME {"volume01","volume02"} 是匿名挂载

数据卷容器

实现多个msyql同步数据

--volumes-from 类似与java中子类继承父类

#启动第一个容器
docker run -it --name docker01 test/centos:1.0
ls -l
ctrl + p + q #退出不停止
docker ps
docker run -it --name docker02 --volumes-from docker01 test/centos:1.0
ls -l

docker run -it --name docker03 --volumes-from docker01 test/centos:1.0

#即使删除docker01, 02 03 文件依然存在

结论:

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

但是一旦持久到了本地,本地的数据是不会删除的

总结:

通过-v 是把数据同步到本地, 分为两种模式(匿名挂载和具名挂载)

通过Dockerfile的VOLUME {"volume01","volume02"} 可以实现镜像内部挂载

通过--volumes-from可以实现多个容器之间的数据继承挂载

Dockerfile介绍

构建步骤:

1.编写一个dockerfile文件

2.docker build 构建称为一个镜像

3.docker run 运行镜像

4.docker push 发布镜像可以发布到(DokerHub,阿里云镜像仓库)

官网给的镜像都是基础包,很多功能没有,通常都会自己去大件自己的镜像

Dockerfile构建过程

概念:

1.每个保留关键字(指令) 都是必须大写字母

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

3.#表示注释

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

Dockerfile:构建文件,定义一切的步骤

DockerImages:通过Dockerfile构建生成的镜像,最终发布和运行的产品

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

Dockerfile指令

FROM	基础镜像,一切从这里开始构建
MAINTAINER	镜像是谁写的,姓名,邮箱
RUN	镜像构建需要运行的命令
ADD	添加内容(比如需要的tomcat压缩包)
WORKDIR	镜像的工作目录
VOLUME	挂载的目录
EXPOSE	保留端口配置
CMD	指定容器启动的时候要运行的命令,只有最后一个生效,可替代
ENTRYPOINT	指定容器启动的时候要运行的命令,可以追加命令
ONBUILD	当构建一个被继承Dockerfile就会运行ONBUILD的指令
COPY	类似ADD,将文件拷贝到镜像中
ENV	构建的时候设置环境变量

构建自己的centos

1.编写Dockerfile的文件

vim mydockerfile

FROM centos
MAINTAINER feng<123456@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80
CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash

2.通过这个文件构建镜像

docker build -f mydockerfile -t mycentos:1.0 .

3.运行

docker images
docker run -it mycentos:1.0
docker history 容器id            #可以查看镜像的制作过程

制作Tomcat镜像

1.准备镜像文件, tomcat和jdk压缩包

2.编写Dockerfile文件,build会自动寻找这个文件,不需要加-f指定

FROM centos
MAINTAINER feng<123456@qq.com>

COPY readme.txt /usr/local/readme.txt
ADD jdk-8ull-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/

RUN yum -y install vim
ENV MYPATH /usr/lcoal
WORKDIR $MYPATH

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

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalins/out

3.构建镜像

docker build -t diytomcat .

4.启动

dicker images
docker run -d -p 9090:8080 --name MyTomcat -v /home/test:/usr/local/apache-tomcat-9.0.22/webapps/test -v /home/log:/usr/local/apache-tomcat-9.0.22/logs diytomcat

5.访问测试

curl localhost:9090

6.发布项目(由于做了挂载,直接在本地编写项目发布就可以)

web.xml

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

  </web-app>

index.jsb

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>首页</title>
<style>
    *{
    padding:0;
    margin:0;
    font-family:"微软雅黑";
}
.header{
    height:72px;
    background:#458fce ;
}
.header .logo{
    color:#fff ;
    line-height:70px;
    font-size:30px;
    margin-left:20px;
    display:inline-block;
    text-align:center;

}
a {
    color: #fff ;
    text-decoration: none ;
}
.header .login{
    float:right;
    color:#fff ;
    line-height:72px;
    margin-right:2px;
    display:inline-block;
}
.banner{
    height:380px;
    overflow:hidden;
    background: #ddd;
}
</style>
</head>
<body>
    <div class="header">
        <div class="logo">web实践</div>
        <div class ="login">
            <a href ="javascript:void(0)">登录</a>
            <span>|</span> 
            <a href ="javascript:void(0)">故事</a>
        </div>
    </div>
</body>
</html>

发布镜像到DockerHub

地址:https://hub.docker.com

docker login --help        #查看登录命令
docker login -u 帐号
docker images
docker push 作者/diytomcat:1.0

提交的时候也是按照镜像的层级来进行提交的

Docker网络

#清空环境
docker rmi -f ${docker images -aq}

ip addr    #网络地址
docker exec -it tomcat01 ip addr    #发现容器启动的时候,docker会分配一个ip地址

docker run -d -p --name tomcat01 tomcat  #容器外是否可以ping通容器内的tomcat呢

证明linux可以ping通容器内部的tomcat

原理:

每启动一个docker容器,docker就会给容器分配一个ip,只要安装了docker,就会有一个网卡docker0,使用桥接模式,evth-pair技术

evth-pair就是一对虚拟设备接口,都是成对出现的,一段连着协议,一段彼此相连,,所以容器内生成的网卡都是一对的

正因为有这个特性,evth-pair充当一个桥梁,连接各种虚拟网络设备

docker exec -it tomcat02 ping tomcat01的ip        #测试tomcat01和tomcat02是否可以ping通

结论 :两个tomcat是可以ping通的

tomcat01和tomcat02有一个公用的路由器 docker0,在不指定网络的环境下,都是经过docker0

docker中所有的网络接口都是虚拟的,虚拟的转发效率高

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

容器互连 --link

假设:

我们编写了一个微服务,database url = ip,项目不重启,数据库ip更换了,怎么使用名字来进行访问呢?

解决:

通过--link 就可以解决网络连通问题

docker run -d -p --name tomcat03 --link tomcat02 tomcat
docker exec -it tomcat03 ping tomcat02    #发现是可以ping通的

但是反向是不可以ping通的,需要重新配置一下

探究原理:

docker exec -it tomcat03 cat /etc/hosts        #查看linux上hosts配置文件

发现hosts文件加了一条地址映射

--link就是在hosts配置中加了一个172.18.0.3 tomcat02 容器id (不建议使用)

自定义网络

docker network --help
docker network ls              #查看所有的网络
docker network rm mynet        #移除网络

网络模式:

bridage    #桥接 docker默认模式,
none       #不配置网络
host       #和宿主机共享网络
container  #容器网络连通(局限很大)

测试

docker rm -f $(docker ps -aq)
docker network --help
docker run -d -p --name tomcat01 --net bridge tomcat  #默认模式,域名不能访问

#自定义
docker network create --help
docker network create --driver bridge --subnet 192.168.0.0/16 --geteway 192.168.0.1 mynet
#--driver模式 使用桥接 --subnet子网 --geteway网关
docker network ls
docker newwork inspect mynet

#启动 使用自己定义的网络
docker run -d -p --name tomcat-net-01 --net mynet tomcat
docker run -d -p --name tomcat-net-02 --net mynet tomcat

docker network inspect mynet

docker exec -it tomcat-net-01 ping 192.168.0.3
docker exec -it tomcat-net-01 ping tomcat-net-02

自定义的网络docker都已经维护好了对应的关系,推荐使用

假设:

redis和mysql 做了集群搭建,可以保证使用不同的网络,保证集群的安全

网络连通

如果让容器docker0去直接连接自定义的tomcat-net-01是不可行, 因为两个之间的网段是不一样的,那如何实现呢

使用connect步骤

docker run -d -p --name tomcat01 tomcat
docker run -f -p --name tomcat02 tomcat

docker network --help
docker network connect --help

#测试
docker network connect mynet tomcat01            #连通之后就是将tomcat01放到了mynet网络里
dokcer network inspect mynet
docker exec -it tomcat01 ping tomcat-net-01

#网卡与网卡之间是不可以连通的,只有容器和网卡连通

docker搭建Redis集群

1、创建redis集群的自定义网络

docker network create redis --subnet 172.38.0.0/16
docker network ls                #查看自定义的网络
docker network inspect redis     #查看自定义的网络详情

2、利用shell脚本创建集群的目录、配置文件以及用自定义网络启动redis

shell脚本

for port in $(seq 1 6);\
do \
mkdir -p /myfile/redis/node-${port}/conf
touch /myfile/redis/node-${port}/conf/redis.conf
cat << EOF >> /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

docker run -p 637${port}:6379 -p 1637${port}:16379 --nane redis-${port} \
-v /myfile/redis/node-${port}/data:/data \
-v /myfile/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

3、用自定义网络分别启动redis

#redis-1
docker run -p 6371:6379 -p 16371:16379 --nane redis-1 \
-v /myfile/redis/node-1/data:/data \
-v /myfile/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#redis-2
docker run -p 6372:6379 -p 16372:16379 --nane redis-2 \
-v /myfile/redis/node-2/data:/data \
-v /myfile/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#redis-3
docker run -p 6373:6379 -p 16373:16379 --nane redis-1 \
-v /myfile/redis/node-3/data:/data \
-v /myfile/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#redis-4
docker run -p 6374:6379 -p 16374:16379 --nane redis-1 \
-v /myfile/redis/node-4/data:/data \
-v /myfile/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#redis-5
docker run -p 6375:6379 -p 16375:16379 --nane redis-1 \
-v /myfile/redis/node-5/data:/data \
-v /myfile/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#redis-6
docker run -p 6376:6379 -p 16376:16379 --nane redis-1 \
-v /myfile/redis/node-6/data:/data \
-v /myfile/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

4、创建集群

doker exec -it redis-1 /bin/sh        #这里redis采用的是sh不是bash
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、连接集群

redis-cli-c        #redis-cli是单机, +c是集群
cluster info
cluster nodes      #查看借点

6、测试

set a b
docker stop redis-3
get a

SpringBootd打包Docker镜像

1、构建springboot项目

2、打包应用

3、编写Dockerfile

FROM java:8

MAINTAINER yihj "yihj@yinghaikeji.com"
  
COPY *.jar /app.jar

CMD ["server.prot:8080"]

EXPOSE 8080

ENTRYPOINT ["java","-Dspring.profiles.active=online","-jar","/app.jar"]

4、上传jar包和Dockerfile , 构建镜像

docker build -t springboot-docker .
docker images

5、发布镜像

docker run -d -p --name springboot-docker01 springboot-docker
docker ps
curl localhost:端口号

feng_zi-06

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫