docker 进阶 之容器数据卷 DockerFile Docker网络 --- 狂神说

最新推荐文章于 2024-04-18 17:12:46 发布
最新推荐文章于 2024-04-18 17:12:46 发布
阅读量9.9k 收藏 115
点赞数 27
分类专栏： 运维 文章标签： docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaozecheng/article/details/106165491
版权

笔记整理自 B站UP 狂神说Java Docker https://www.bilibili.com/video/BV1og4y1q7M4

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像！

数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删除了，删库跑路！需求：MySQL数据可以存储在本地！

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！

这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

image-20200516105258456

总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的！

使用数据卷

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

-v, --volume list                    Bind mount a volume

docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口
➜ ~ docker run -it -v /home/ceshi:/home centos /bin/bash
#通过 docker inspect 容器id 查看

image-20200515191647970

测试文件的同步

image-20200515191718470

再来测试！

1、停止容器

2、宿主机修改文件

3、启动容器

4、容器内的数据依旧是同步的

image-20200516110850431

好处：我们以后修改只需要在本地修改即可，容器内会自动同步！

实战：安装MySQL

思考：MySQL的数据持久化的问题

# 获取mysql镜像
➜  ~ docker pull mysql:5.7
# 运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
# 参考官网hub 
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动我们得
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
-- name 容器名字
➜  ~ docker run -d -p 3306: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

# 启动成功之后，我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306--和容器内的3306映射 

# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！

假设我们将容器删除

image-20200516112532950

发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。

具名和匿名挂载

# 匿名挂载
-v 容器内路径!
docker run -d -P --name nginx01 -v /etc/nginx nginx

# 查看所有的volume的情况
➜  ~ docker volume ls    
DRIVER              VOLUME NAME
local               33ae588fae6d34f511a769948f0d3d123c9d45c442ac7728cb85599c2657e50d
local            
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路劲！

# 具名挂载
➜  ~ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
➜  ~ docker volume ls                  
DRIVER              VOLUME NAME
local               juming-nginx

# 通过 -v 卷名：容器内路径
# 查看一下这个卷

image-20200516113545746

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/_data下
如果指定了目录，docker volume ls 是查看不到的

image-20200516114231435

# 三种挂载： 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径			#匿名挂载
-v 卷名：容器内路径		#具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的

拓展：

# 通过 -v 容器内路径： ro rw 改变读写权限
ro #readonly 只读
rw #readwrite 可读可写
docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx

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

初始Dockerfile

Dockerfile 就是用来构建docker镜像的构建文件！命令脚本！先体验一下！

通过这个脚本可以生成镜像，镜像

# 创建一个dockerfile文件，名字可以随便 建议Dockerfile
# 文件中的内容 指令(大写) 参数
FROM centos

VOLUME ["volume01","volume02"]

CMD echo "----end----"
CMD /bin/bash
#这里的每个命令，就是镜像的一层！

image-20200516121221066

# 启动自己写的镜像

image-20200516121459026

这个卷和外部一定有一个同步的目录

image-20200516121531626

查看一下卷挂载

docker inspect 容器id

image-20200516121630295

测试一下刚才的文件是否同步出去了！

这种方式使用的十分多，因为我们通常会构建自己的镜像！

假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

多个MySQL同步数据！

命名的容器挂载数据卷！

image-20200516122047440

--volumes-from list              Mount volumes from the specified container(s)
# 测试，我们通过刚才启动的

image-20200516123020050

image-20200516123128475

# 测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件
# 测试依旧可以访问

image-20200516123355034

多个mysql实现数据共享

➜  ~ docker run -d -p 3306: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
➜  ~ docker run -d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01  mysql:5.7
# 这个时候，可以实现两个容器数据同步！

结论：

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

但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

DockerFile

DockerFile介绍

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

构建步骤：

1、 编写一个dockerfile文件

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

3、 docker run运行镜像

4、 docker push发布镜像（DockerHub 、阿里云仓库)

image-20200516131400456

点击后跳到一个Dockerfile

image-20200516131441750

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

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

2、执行从上到下顺序

3、#表示注释

4、每一个指令都会创建提交一个新的镜像曾，并提交！

image-20200516131756997

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

Docker镜像逐渐成企业交付的标准，必须要掌握！

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

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

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

DockerFile的指令

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

实战测试

创建一个自己的centos

# 1.编写Dockerfile文件
vim mydockerfile-centos
FROM centos
MAINTAINER cheng<1204598429@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 文件路径 -t 镜像名:[tag] .
docker build -f mydockerfile-centos -t mycentos:0.1 .

image-20200516140831464

测试运行

image-20200516141629583

我们可以列出本地进行的变更历史

image-20200516141840706

我们平时拿到一个镜像，可以研究一下是什么做的

CMD 和 ENTRYPOINT区别

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

测试cmd

# 编写dockerfile文件
$ vim dockerfile-test-cmd
FROM centos
CMD ["ls","-a"]
# 构建镜像
$ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .
# 运行镜像
$ docker run cmd-test:0.1
.
..
.dockerenv
bin
dev

# 想追加一个命令  -l 成为ls -al
$ docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\":
 executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled 
# cmd的情况下 -l 替换了CMD["ls","-l"]。 -l  不是命令所有报错

测试ENTRYPOINT

# 编写dockerfile文件
$ vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]
$ docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found ...
# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x   1 root root 4096 May 16 06:32 .
drwxr-xr-x   1 root root 4096 May 16 06:32 ..
-rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 16 06:32 dev
drwxr-xr-x   1 root root 4096 May 16 06:32 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

Dockerfile中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果！

实战：Tomcat镜像

1、准备镜像文件

​ 准备tomcat 和 jdk到当前目录，编写好README

image-20200516162443652

2、编写dokerfile

FROM centos #
MAINTAINER cheng<1204598429@qq.com>
COPY README /usr/local/README #复制文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/ #复制解压
ADD apache-tomcat-9.0.35.tar.gz /usr/local/ #复制解压
RUN yum -y install vim
ENV MYPATH /usr/local #设置环境变量
WORKDIR $MYPATH #设置工作目录
ENV JAVA_HOME /usr/local/jdk1.8.0_231 #设置环境变量
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 #设置环境变量
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib #设置环境变量 分隔符是：
EXPOSE 8080 #设置暴露的端口
CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out # 设置默认命令

3、构建镜像

# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .

4、run镜像

$ docker run -d -p 8080:8080 --name tomcat01 -v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test -v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs mytomcat:0.1

5、访问测试

6、发布项目(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)

发现：项目部署成功，可以直接访问！

我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布自己的镜像

Dockerhub

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

2、确定这个账号可以登录

3、登录

$ 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

4、提交 push镜像

image-20200516164434042

# 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
# 解决方法
# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
$ docker build -t chengcoder/mytomcat:0.1 .
# 第二种 使用docker tag #然后再次push
$ docker tag 容器id chengcoder/mytomcat:1.0 #然后再次push

阿里云镜像服务上

看官网 很详细https://cr.console.aliyun.com/repository/

$ sudo docker login --username=zchengx registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]
# 修改id 和 版本
sudo docker tag a5ef1f32aaae registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:1.0
# 修改版本
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]

image-20200516171012186

小结

image-20200516171155667

Docker 网络

理解Docker 0

清空所有网络

测试

image-20200515223236772

三个网络

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

image-20200516172041985

# 测试  运行一个tomcat
$ docker run -d --name tomcat01 tomcat

$ ip addr                               
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
551: vethbfc37e3@if550: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 1a:81:06:13:ec:a1 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::1881:6ff:fe13:eca1/64 scope link 
       valid_lft forever preferred_lft forever
       
$ docker exec -it 容器id 
$ ip addr
# 查看容器内部网络地址 发现容器启动的时候会得到一个 eth0@if551 ip地址，docker分配！
550: eth0@if551: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.069 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.074 ms

原理

1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！

https://www.cnblogs.com/bakari/p/10613710.html

再次测试ip add

image-20200515224036883

2 、在启动一个容器测试，发现又多了一对网络

image-20200516173259458

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

3、我们来测试下tomcat01和tomcat02是否可以ping通

$ docker-tomcat docker exec -it tomcat01 ip addr  #获取tomcat01的ip 172.17.0.2   
550: eth0@if551: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
$ docker-tomcat docker exec -it tomcat02 ping 172.17.0.2#让tomcat02ping tomcat01 
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.098 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms
# 可以ping通

image-20200516174248626

结论：tomcat01和tomcat02公用一个路由器，docker0。

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

小结：

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

image-20200516174701063

Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）

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

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

–link

$ docker exec -it tomcat02 ping tomca01   # ping不通
ping: tomca01: Name or service not known
# 运行一个tomcat03 --link tomcat02 
$ docker run -d -P --name tomcat03 --link tomcat02 tomcat
5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef
# 用tomcat03 ping tomcat02 可以ping通
$ docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.115 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms

# 用tomcat02 ping tomcat03 ping不通

探究：

docker network inspect 网络id 网段相同

image-20200516175904551

docker inspect tomcat03

image-20200516180308530

查看tomcat03里面的/etc/hosts发现有tomcat02的配置

image-20200516180629012

–link 本质就是在hosts配置中添加映射

现在使用Docker已经不建议使用–link了！

自定义网络，不适用docker0！

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

自定义网络

docker network
connect     -- Connect a container to a network
create      -- Creates a new network with a name specified by the
disconnect  -- Disconnects a container from a network
inspect     -- Displays detailed information on a network
ls          -- Lists all the networks created by the user
prune       -- Remove all unused networks
rm          -- Deletes one or more networks

查看所有的docker网络

image-20200516190316073

网络模式

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

none ：不配置网络，一般不用

host ：和所主机共享网络

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

测试

# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# bridge就是docker0
$ docker run -d -P --name tomcat01 tomcat
等价于 => docker run -d -P --name tomcat01 --net bridge tomcat

# docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！
# 我们可以 自定义一个网络
$ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

image-20200516191139944

$ docker network inspect mynet;

image-20200516191407065

启动两个tomcat,再次查看网络情况

image-20200516191844240

image-20200516192007371

在自定义的网络下，服务可以互相ping通，不用使用–link

image-20200516192134673

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

好处：

redis -不同的集群使用不同的网络，保证集群是安全和健康的

mysql-不同的集群使用不同的网络，保证集群是安全和健康的

image-20200516192504367

网络连通

image-20200516193243146

image-20200516193259185

# 测试两个不同的网络连通  再启动两个tomcat 使用默认网络，即docker0
$ docker run -d -P --name tomcat01 tomcat
$ docker run -d -P --name tomcat02 tomcat
# 此时ping不通

image-20200516193554931

# 要将tomcat01 连通 tomcat—net-01 ，连通就是将 tomcat01加到 mynet网络
# 一个容器两个ip（tomcat01）

image-20200516193848337

# 01连通 ，加入后此时，已经可以tomcat01 和 tomcat-01-net ping通了
# 02是依旧不通的

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

实战：部署Redis集群

image-20200516194419471

# 创建网卡
docker network create redis --subnet 172.38.0.0/16
# 通过脚本创建六个redis配置
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >> /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-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

# 通过脚本运行六个redis
for port in $(seq 1 6);\
docker run -p 637${port}:6379 -p 1667${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/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
docker exec -it redis-1 /bin/sh #redis默认没有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

image-20200516202902241

docker搭建redis集群完成！

image-20200516203323971

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i60F3UA4-1589635687509)(C:/Users/xiao/Pictures/md/image-20200516203010672.png)]

我们使用docker之后，所有的技术都会慢慢变得简单起来！

SpringBoot微服务打包Docker镜像

1、构建SpringBoot项目

2、打包运行

mvn package

3、编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

4、构建镜像

# 1.复制jar和DockerFIle到服务器
# 2.构建镜像
$ docker build -t xxxxx:xx  .

5、发布运行

以后我们使用了Docker之后，给别人交付就是一个镜像即可！

chengCodeX
关注
  • 27
    点赞
  • 踩
  • 115
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
狂神说Java--Docker（通俗易懂）
m0_64924660的博客
06-20 2624
笔记整理来源 B站UP主狂神说Javahttps://space.bilibili.com/95256449/Docker为什么出现？一款产品： 开发–上线 两套环境！应用环境，应用配置！开发 — 运维。 问题：我在我的电脑上可以允许！版本更新，导致服务不可用！对于运维来说考验十分大？环境配置是十分的麻烦，每一个及其都要部署环境(集群Redis、ES、Hadoop…) !费事费力。发布一个项目( jar + (Redis MySQL JDK ES) ),项目能不能带上环境安装打包！之前在服务器配置一个应用的
狂神说Docker容器学习笔记全部.pdf
12-22
狂神说Docker容器学习笔记全
【狂神说Java】Docker镜像讲解 | Docker容器数据卷 | DockerFile | Docker网络 | Springboot微服务打包docker镜像
Martin-share的博客
11-19 752
docker的理念回顾将应用和环境打包成一个镜像！数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！（需求：数据可以持久化）MySQL，容器删了，删库跑路！（需求：MySQL数据可以存储在本地）容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux主机上面！总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的！dockerfile是用来构建docker镜像的文件！命令参数脚本！
Day03-数据卷与Dockerfile
最新发布
苦难带不走梦想
04-18 1046
应用场景：通过1个文件Dockerfile，docker build可以自动化生成自定义 镜像我们目前都是手动拉取镜像，手动进行配置，手动安装依赖，手动编译安装，创建用户…，这个过程类似于命令行使用ansible模块(繁琐，不方便重复执行)书写Dockerfile把之前手动创建自定义镜像的过程，通过Dockerfile里面的指令实现，类似于书写playbookDockerfile用于根据要求自动创建 镜像数据卷挂载手动自定义镜像。
【Docker】从零开始：9.Docker命令:Push推送仓库（Docker Hub，阿里云）
圈小圈DBA的博客
11-24 5936
Docker Push是Docker的一个命令，用于将本地的Docker镜像推送到仓库中。总之，公有仓库和私有仓库各有优缺点，用户可以根据实际需求选择适合自己的仓库类型。在这已经看到我们推送成功了。在这已经看到我们推送成功了。
【Docker】常用命令 docker push
好久不见的流星
03-19 1312
在深入探讨命令之前，我们首先需要了解什么是Docker镜像。Docker镜像是一个轻量级、独立的可执行软件包，其中包含了运行应用程序所需的一切：代码、运行时、系统工具、系统库以及设置。命令就是用来将这些镜像推送到远程镜像仓库的。通过本文的介绍，读者应该对命令有了更深入的了解。这个命令是将本地镜像推送到远程镜像仓库的关键步骤，使得镜像可以在不同的环境中共享和使用。建议读者在实践中多多尝试，深入理解如何使用命令将不同的镜像推送到不同的镜像仓库中。这将有助于更好地管理和分享Docker镜像资源。
Ubantu docker学习笔记（三）docker账号push及Dockerfile优化
小唐同学超级呆的博客
03-16 752
我们详细学习了镜像的拉扯pull和push的过程，通过我们自己创建账号，进行上传和下载 然后我们对于docker的结构优化也简略的说了说，在实际的开发过程中，我们还可以通过一些yum和apt自带的命令来进行优化，以及一些优秀的社区工具Docker——squash等！嘿嘿，docker真好玩！！！
B站狂神docker.zip
08-12
B站狂神Docker笔记
绕过SSL双向校验抓取Soul App的数据包
Circle-C的博客
02-05 1万+
参考了这篇文章：Android抓包总结 - 先知社区https://xz.aliyun.com/t/6551#toc-10 毫无反编译经验的我，硬着头皮参考这篇文章抓到数据，记录一下抓包过程，全部是按照参考文章来的，这里我补充了一些细节以及自己遇到的坑。 软件： soul_v3.4.0.apk IDAPRO V6.8 https://pan.baidu.com/s/1hqYImNE...
狂神docker笔记（超详细）.rar
06-14
狂神docker教学视频笔记，截图标注很全（本人增加了很多额外的标注），帮助更好理解，敲了很久，实在不易。上传来帮助大家学习，一方面攒点积分！
Docker 学习笔记
10-25
docker， 云平台应用开发的一个方向， 虚拟机技术的一个应用， 大数据的延伸。
docker镜像push到仓库
热门推荐
strivew的博客
04-01 1万+
docker镜像push到仓库
【从头开始学docker系列之五，分享自己的镜像 使用push命令】
dangkei 的专栏
06-13 211
我们使用pull命令拉取的镜像都是官方制作好的标准镜像供我们免费使用， 同样我们也可以把自己制作的镜像分享到docker的hub上供其他人使用，具体的方法是这样的。
1.狂神说java-docker入门笔记
大李出奇迹的博客
11-11 919
狂神视频地址：https://www.bilibili.com/video/BV1og4y1q7M4?p=1 <<三体>>： 弱小和无知不是生存的障碍，傲慢才是。 即使再小的帆，就往死里学 狂神说java-docker笔记Docker 学习大纲展示1.Docker概述1.1Docker为什么出现？2.Docker安装3.docker命令帮助命令镜像命令容器命令 Docker 学习大纲展示 Docker 概述 Docker安装 Docker命令 镜像命令 容器命令 操作命令 。。。.
狂神说Java -- Docker 容器数据卷
TT-Learning
07-10 387
文章目录1.什么是容器数据卷2.使用数据卷2.1 直接使用命令来挂载3.实战：MySQL4.具名和匿名挂载4.1 匿名挂载4.2 具名挂载4.3 拓展（权限）5.初始 Dockerfile6.数据卷容器6.1 多个MySQL实现数据共享 1.什么是容器数据卷 问题1： 如果数据在容器中，那么我们容器删除之后，数据就会丢失； 需求1： 数据可以持久化； 问题2： 例如MySQL数据库容器化，当容器删除了，删库跑路，数据也就丢失了； 需求2： MySQL数据可以存储在本地； 宿主机和容器之间可以有一个数据共享的
Docker push 命令
yygr的博客
04-30 2158
https://www.jianshu.com/p/1c8b96cf1f13 Docker hub注册用户 到官网注册账号：https://hub.docker.com/ 在本地Linux登录docker： docker@default:~$ docker login Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to ht
docker学习笔记——进阶
String小四的博客
07-12 756
本套笔记是记录学习《狂神说java——docker》课程笔记，仅供学习使用。 docker学习笔记——入门https://blog.csdn.net/m0_37258694/article/details/107195591 1容器数据卷 1.1什么是容器数据卷 docker的理念回顾 将应用和环境打包成一个镜像！ 数据？如果数据都在容器中，那么我们删除容器，数据就会丢失！需求：数据可以持久化 Mysql，容器删了，衫裤跑了！：需求：Mysql数据可以存储到本地！ 容器之间可以有一个数据共享
狂神说Docker笔记，详细上课笔记
02-20
狂神说Docker笔记，详细上课笔记。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值