Coleção de comandos comumente usados do Docker
Artigo Diretório
-
Coleção de comandos comumente usados do Docker - 1. Introdução ao docker
- Dois, cenários de aplicativos Docker
- Três, arquitetura Docker
- Quatro, instalação docker
- Cinco, uso de imagem docker
- Seis, o uso de contêiner docker
- Sete, crie um espelho
- Oito, gerenciamento de dados do docker
- Nove, estabelecimento de armazém privado local
- Dez, interconexão de contêiner
- 11. Resumo
1. Introdução ao docker
- Docker é um mecanismo de contêiner de aplicativo de código aberto, baseado na linguagem Go e de código aberto seguindo o protocolo Apache2.0.
- O Docker permite que os desenvolvedores empacotem seus aplicativos e pacotes dependentes em um contêiner leve e portátil e, em seguida, publiquem em qualquer
máquina Linux popular , também pode ser virtualizado. - Os contêineres usam o mecanismo de sandbox completamente e não haverá nenhuma interface entre si (aplicativos semelhantes ao iPhone) e, mais importante, a sobrecarga de desempenho do contêiner é extremamente baixa.
- Docker foi dividido em CE (Community Edition: Community Edition) e EE (Enterprise Edition: Enterprise Edition) desde a versão 17.03, podemos usar a Community Edition
Dois, cenários de aplicativos Docker
Empacotamento e publicação automatizados de aplicativos da Web.
Teste automatizado e integração e liberação contínuas.
Implante e ajuste bancos de dados ou outros aplicativos de segundo plano em um ambiente orientado a serviços.
Compile ou amplie a plataforma OpenShift ou Cloud Foundry existente do zero para construir seu próprio ambiente PaaS.
2.1 Vantagens do Docker
Docker é uma plataforma aberta para desenvolver, entregar e executar aplicativos. O Docker permite que você separe os aplicativos da infraestrutura para que o software possa ser entregue rapidamente. Com o Docker, você pode gerenciar sua infraestrutura da mesma forma que gerencia aplicativos. Usando o método do Docker para entregar, testar e implantar código rapidamente, você pode reduzir muito o atraso entre a gravação do código e sua execução em um ambiente de produção.
(1) Entregue seus aplicativos de forma rápida e consistente. O
Docker permite que os desenvolvedores usem os contêineres locais dos aplicativos ou serviços que você fornece para trabalhar em um ambiente padronizado, simplificando assim o ciclo de vida de desenvolvimento.
Os contêineres são ótimos para fluxos de trabalho de integração contínua e entrega contínua (CI / CD). Considere o seguinte cenário de exemplo:
Seus desenvolvedores escrevem código localmente e usam contêineres Docker para compartilhar seu trabalho com colegas.
Eles usam o Docker para enviar seus aplicativos ao ambiente de teste e realizar testes automatizados ou manuais.
Quando os desenvolvedores encontram erros, eles podem corrigi-los no ambiente de desenvolvimento e, em seguida, reimplementá-los no ambiente de teste para teste e verificação.
Após a conclusão do teste, enviar o patch para o ambiente de produção é tão simples quanto enviar a imagem atualizada para o ambiente de produção.
(2) Implantação e expansão responsivas
Docker é uma plataforma baseada em contêiner que permite cargas de trabalho altamente portáteis. Os contêineres do Docker podem ser executados na máquina do desenvolvedor, em uma máquina física ou virtual no data center, em um serviço de nuvem ou em um ambiente híbrido.
A portabilidade e os recursos leves do Docker também podem permitir que você conclua facilmente a carga de trabalho do gerenciamento dinâmico e, de acordo com as instruções das necessidades de negócios, expansão ou remoção em tempo real de aplicativos e serviços.
(3) O
Docker é leve e rápido para executar mais cargas de trabalho no mesmo hardware . Ele fornece uma alternativa viável, econômica e eficiente às máquinas virtuais baseadas em hipervisores, para que você possa usar mais poder de computação para atingir as metas de negócios. O Docker é muito adequado para ambientes de alta densidade e implantações de pequeno e médio porte, e você pode fazer mais com menos recursos.
Três, arquitetura Docker
- O Docker inclui três conceitos básicos:
Imagem: a imagem do Docker é equivalente a um sistema de arquivos raiz. Por exemplo, o espelho oficial ubuntu: 16.04 contém um conjunto completo do sistema de arquivos raiz do sistema mínimo Ubuntu 16.04.
Container: O relacionamento entre a imagem e o container é como a classe e instância na programação orientada a objetos.A imagem é uma definição estática, e o container é a entidade da imagem em tempo de execução. Os contêineres podem ser criados, iniciados, parados, excluídos, suspensos, etc.
Repositório: o repositório pode ser considerado um centro de controle de código para armazenar imagens.
Docker usa um modelo de arquitetura cliente-servidor (C / S) e usa APIs remotas para gerenciar e criar contêineres Docker.
Os contêineres Docker são criados por meio de imagens Docker.
O relacionamento entre contêineres e espelhos é semelhante a objetos e classes na programação orientada a objetos. - Docker orientado a objetos
- Objeto recipiente
- Classe espelho
Quatro, instalação docker
- Implante a versão 19 do docker
4.1 instalar dependências
yum -y install yum-utils device-mapper-persistent-data lvm2
//yum-utils 提供了yum-config-manager
//device mapper 存储驱动程序需要device-mapper-persistent-data和lvm2
//device mapper 是Linux2.6内核中支持逻辑卷管理的通用设备映射机制。
//它为实现用于存储资源管理的块设备驱动提供了一个而高度模块化的内核架构
4.2 Definir a fonte de imagem da nuvem Alibaba
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4.3 instalar docker-ce
yum -y install docker-ce
systemctl start docker.service
systemctl enable docker.service
setenforce 0
vim /etc/selinux/config
SELINUX=disabled
4.4 Aceleração de imagem
Digite o site oficial do Alibaba Cloud "" Search Mirror Acceleration "" Selecione a versão centos
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://1i3tpy0i.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
4.5 Otimização de rede
vim /etc/sysctl.conf
net.ipv4.ip_forward=1
sysctl -p
service network restart
systemctl restart docker
Cinco, uso de imagem docker
- Ver versão do docker
docker version
- Pesquisar espelho Nginx (armazém público)
docker search nginx
- Baixar imagem Nginx
docker pull nginx
- Baixe a última imagem oficial do Redis, que é equivalente a: docker pull redis: latest
docker pull redis
- Baixe todas as imagens Redis do warehouse
docker pull -a redis
- Depois de baixar o espelho do armazém privado
, o estabelecimento da biblioteca privada será apresentado em detalhes
docker pull bitnami/redis
- Download de várias camadas do AUFS (Sistema de Arquivos Associado)
- Armazenado em / var / lib / docker após o download
- / var / lib / docker / image / overlay / repositories / json // Baixar informações do arquivo
- Ver lista de espelhos
docker images //查看下载镜像信息
[root@localhost opt]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 7e4d58f0e5f3 8 days ago 133MB
REPOSITORY：表示镜像的仓库源
TAG：镜像的标签
IMAGE ID：镜像ID
CREATED：镜像创建时间
SIZE：镜像大小
//含中间映像层
docker images -a
//只显示镜像ID
docker images -q
//含中间映像层
docker images -qa
//显示镜像摘要信息(DIGEST列)
docker images --digests
//显示镜像完整信息
docker images --no-trunc
- Obter informações do espelho
docker inspect 7e4d58f0e5f3
- Adicionar novo rótulo
docker tag nginx:latest nginx:web
[root@localhost opt]# docker tag nginx:latest nginx:web
[root@localhost opt]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 7e4d58f0e5f3 8 days ago 133MB
nginx web 7e4d58f0e5f3 8 days ago 133MB
//查看镜像Nginx信息
[root@localhost opt]# docker images | grep nginx
nginx latest 7e4d58f0e5f3 8 days ago 133MB
nginx web 7e4d58f0e5f3 8 days ago 133MB
- Apagar espelho
docker rmi nginx:web （如果只有一个别名，那么这个就是删除docker。如果是多个标签，那么就是只是删除一个标签）
- Excluir docker
docker rmi docker——id 注：删除docker如果有其他别名需要删除只剩一个，才能删除docker
在删除容器之前需要先停止容器
- Exclusão de imagem única, equivalente a: docker rmi redis: mais recente
docker rmi redis
- Exclusão forçada (para processos de contêiner em execução com base em imagens)
docker rmi -f redis
- Exclua vários espelhos, separados por espaços entre diferentes espelhos
docker rmi -f redis tomcat nginx
- Exclua todos os espelhos locais em lote
docker rmi -f $(docker images -q)
- A imagem Nginx exportada é nomeada Nginx e armazenada no diretório opt
docker save -o 文件名 镜像id或者镜像别名
[root@localhost ~] docker save -o /opt/nginx 7e4d58f0e5f3
[root@localhost opt] docker save -o nginx1 nginx:latest
[root@localhost ~]cd /opt
[root@localhost opt] ll
总用量 133636
drwx--x--x. 4 root root 28 9月 17 15:43 containerd
-rw-------. 1 root root 136841216 9月 19 19:04 nginx
drwxr-xr-x. 2 root root 6 10月 31 2018 rh
- Importar imagem
docker load --input exportar nome do arquivo
docker load <exportar nome do arquivo
[root@localhost opt] docker load --input nginx
Loaded image ID: sha256:7e4d58f0e5f3b60077e9a5d96b4be1b974b5a484f54f9393000a99f3b6816e3d
[root@localhost opt] docker load < nginx
Loaded image ID: sha256:7e4d58f0e5f3b60077e9a5d96b4be1b974b5a484f54f9393000a99f3b6816e3d
[root@localhost opt] docker load --input nginx1
Loaded image: nginx:latest
Seis, o uso de contêiner docker
- Criação de contêiner
docker create -it nginx:latest /bin/bash
[root@localhost opt] docker create -it nginx:latest /bin/bash
59c4c2f2b6a00bceb196f1bbcfe02fc5a2e16edc66feb12310c9474bf939d833
- -i: Operação interativa.
- -t: terminal.
- / bin / bash: Depois que o nome da imagem é o comando, aqui queremos um shell interativo, então / bin / bash é usado.
- docker run: crie um novo contêiner e execute um comando
语法
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
OPTIONS说明：
-a stdin: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；
-d: 后台运行容器，并返回容器ID；
-i: 以交互模式运行容器，通常与 -t 同时使用；
-P: 随机端口映射，容器内部端口随机映射到主机的端口
-p: 指定端口映射，格式为：主机(宿主)端口:容器端口
-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
--name="nginx-lb": 为容器指定一个名称；
--dns 8.8.8.8: 指定容器使用的DNS服务器，默认和宿主一致；
--dns-search example.com: 指定容器DNS搜索域名，默认和宿主一致；
-h "mars": 指定容器的hostname；
-e username="ritchie": 设置环境变量；
--env-file=[]: 从指定文件读入环境变量；
--cpuset="0-2" or --cpuset="0,1,2": 绑定容器到指定CPU运行；
-m :设置容器使用内存最大值；
--net="bridge": 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；
--link=[]: 添加链接到另一个容器；
--expose=[]: 开放一个端口或一组端口；
--volume , -v: 绑定一个卷
实例
使用docker镜像nginx:latest以后台模式启动一个容器,并将容器命名为mynginx。
docker run --name mynginx -d nginx:latest
使用镜像nginx:latest以后台模式启动一个容器,并将容器的80端口映射到主机随机端口。
docker run -P -d nginx:latest
使用镜像 nginx:latest，以后台模式启动一个容器,将容器的 80 端口映射到主机的 80 端口,主机的目录 /data 映射到容器的 /data。
docker run -p 80:80 -v /data:/data -d nginx:latest
绑定容器的 8080 端口，并将其映射到本地主机 127.0.0.1 的 80 端口上。
$ docker run -p 127.0.0.1:80:8080/tcp ubuntu bash
使用镜像nginx:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
runoob@runoob:~$ docker run -it nginx:latest /bin/bash
- Ver container
docker ps -a
[root@localhost opt] docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
59c4c2f2b6a0 nginx:latest "/docker-entrypoint.…" 2 minutes ago Created pedantic_bose
//显示最近创建容器
docker ps -l
//显示最近创建的3个容器
docker ps -n 3
//不截断输出
docker ps --no-trunc
//获取镜像redis的元信息
docker inspect redis
//获取正在运行的容器redis的 IP
docker inspect --format='{
{range .NetworkSettings.Networks}}{
{.IPAddress}}{
{end}}' redis
//查看正在运行的容器
docker ps
//查看正在运行的容器的ID
docker ps -q
//查看正在运行+历史运行过的容器
docker ps -a
//显示运行容器总文件大小
docker ps -s
- Inicie o contêiner
docker start 59c4c2f2b6a0
查看镜像 up 状态
[root@localhost opt] docker start 59c4c2f2b6a0
59c4c2f2b6a0
[root@localhost opt] docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
59c4c2f2b6a0 nginx:latest "/docker-entrypoint.…" 3 minutes ago Up 9 seconds 80/tcp pedantic_bose
- Parar o recipiente
docker stop 容器ID
- Reiniciar contêiner
docker restart 容器ID
- Inicie o comando de execução para visualizar o diretório raiz do sistema
docker pull centos 7
docker create it centos 7 /bin/bash
docker start 8c6dd3246eb4
docker run nginx /usr/bin/bash -c ls
-
Fechar imediatamente após a execução, o status é encerrado
-
Execução contínua em segundo plano
-
Entrada de contêiner
[root@localhost opt] docker exec -it 8c6dd3246eb4 /bin/bash
docker exec ：在运行的容器中执行命令
-d :分离模式: 在后台运行
-i :即使没有附加也保持STDIN 打开
-t :分配一个伪终端
docker exec -i -t mynginx /bin/bash
docker exec -it 9df70f9a0714 /bin/bash
exit 退出
- Exportação de contêineres
docker export 8c6dd3246eb4 > nginx_c
8c6dd3246eb4：容器ID
Nginx_c :导出容器文件名
- Importação de contêiner (a imagem será gerada, mas o contêiner não será criado)
cat nginx_c | docker import - nginx:web
nginx_c：导出的容器文件名
nginx:web：新的容器名
- Exclua o contêiner (o contêiner deve ser parado)
[root@localhost opt] docker rm 8c6dd3246eb4
Error response from daemon: You cannot remove a running container 8c6dd3246eb42099dbf58e2730f348acc21b685a4f27c60185d9a427e1282f09. Stop the container before attempting removal or force remove
[root@localhost opt] docker stop 8c6dd3246eb4
8c6dd3246eb4
[root@localhost opt] docker rm 8c6dd3246eb4
8c6dd3246eb4
- Excluir contêineres em massa
方法一：docker ps -a | awk '{print "docker rm $1"}' | bash
方法二：
[root@localhost opt]docker rm -f $(docker ps -aq)
395dab3d44df
2b52ff42681f
1627dc7213cd
960857ff1ba0
59c4c2f2b6a0
//强制杀死进程容器（处于运行状态才能杀死进程-docker start id）
docker kill id
- Excluir um contêiner em execução
docker rm -f redis
- Excluir vários recipientes
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm
- -l Remove a conexão de rede entre os contêineres, o nome da conexão é db
docker rm -l db
- -v excluir o contêiner e excluir o volume de dados montado pelo contêiner
docker rm -v redis
- Não deletar nenhum espelho
vim none.sh
docker ps -a | grep "Exited" | awk '{print $1}'|xargs docker stop
docker ps -a | grep "Exited" | awk '{print $1}'|xargs docker rm
docker images|grep none|awk '{print $3}'|xargs docker rmi
-
-f: Exclui à força um contêiner em execução por meio do sinal SIGKILL.
-
-l: remove a conexão de rede entre os contêineres, não o próprio contêiner
-
-v: Exclui o volume associado ao contêiner.
-
Processo de contêiner
//top支持 ps 命令参数，格式：docker top [OPTIONS] CONTAINER [ps OPTIONS]
//列出redis容器中运行进程
docker top redis(容器ID)
//查看所有运行容器的进程信息
for i in `docker ps |grep Up|awk '{print $1}'`;do echo \ &&docker top $i; done
- Log de contêiner
//查看redis容器日志，默认参数
docker logs rabbitmq
//查看redis容器日志，参数：-f 跟踪日志输出；-t 显示时间戳；--tail 仅列出最新N条容器日志；
docker logs -f -t --tail=20 redis
//查看容器redis从2019年05月21日后的最新10条日志。
docker logs --since="2019-05-21" --tail=10 redis
-
pausa do docker: pausa todos os processos no contêiner
-
docker unpause: Retoma todos os processos no contêiner.
实例
暂停数据库容器db01提供服务。
docker pause db01
恢复数据库容器db01提供服务。
docker unpause db01
Sete, crie um espelho
- Crie uma imagem com base em um contêiner de imagem existente
docker create -it jasonlix/docker-cobbler /bin/bash
docker commit -m "new" -a "daoke" c83aee844ae0 daoke:test
docker images | grep daoke
- Criar com base no modelo local
将文件debian-7.0-x86-minimal.tar.gz拖至opt目录中
[root@localhost opt] cat debian-7.0-x86-minimal.tar.gz | docker import - daoke:new
sha256:6683b936f5574560c919751a6622d4131bb7fb4d88f7a9614c55fb7f554ef2c0
[root@localhost opt] docker images | grep new
daoke new 6683b936f557 13 seconds ago 215MB
- Construir imagem com base no dockerfile
mkdir apache
cd apache
vim Dockerfile
#基于的基础镜像
FROM centos
#维护镜像的用户信息
MAINTAINER The project <[email protected]>
#镜像操作指令安装Apache软件
RUN yum -y update
RUN yum -y install httpd
#开启80端口
EXPOSE 80
#复制网站首页文件
ADD index.html /var/www/html/index.html
#将执行脚本复制到镜像中
ADD run.sh /run.sh
RUN chmod 755 /run.sh
#启动容器时执行脚本
CMD ["/run.sh"]
vim run.sh
#!/bin/bash
rm -rf /run/httpd/*
exec /usr/sbin/apachectl -D FOREGROUND
echo "web test" > index.html
- Espelho de produção
docker build -t httpd:centos1 . (注意别忘了末尾有“.”)
- Nova imagem em execução no contêiner
docker run -d -p 1216:80 httpd:centos1
docker start 4fbc428fac3a (开启容器)
[root@localhost apache]docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4fbc428fac3a httpd:centos1 "/run.sh" 8 seconds ago Up 7 seconds 0.0.0.0:1216->80/tcp affectionate_lovelace
a4f43a12352e registry "/entrypoint.sh /etc…" 2 hours ago Exited (2) 40 minutes ago goofy_bose
ba786a224305 registry "/entrypoint.sh /bin…" 2 hours ago Exited (127) 2 hours ago zen_hamilton
- Teste o navegador real
- http://192.168.75.200:1216/
Oito, gerenciamento de dados do docker
(1) Operação de gerenciamento de dados
- Visualize convenientemente os dados gerados no contêiner
- Compartilhamento de dados entre vários contêineres
(2) Dois métodos de gestão
- Volume de dados: compartilhado entre o host e o contêiner
- Contêiner de volume de dados: compartilhado entre contêiner e contêiner
- Volume de dados: é um diretório especial para contêineres
(3) Criar volume de dados
docker run -d -v /data1 -v /data2 --name web httpd:centos
- Monte o diretório do host como um volume de dados (sincronize o diretório do host com o diretório do contêiner)
docker run -d -v /var/www:/data1 --name web-1 httpd:centos
- web-1 se refere ao nome do container, httpd: centos é um espelho, significa montar um diretório e gerar um espelho do container web-1 como httpd e o rótulo é centos
docker pull centos
//宿主机目录/var/www挂载容器中的/data1
docker run -v /var/www:/data1 --name web1 -it centos /bin/bash
cd /data1
touch test123
//返回宿主机进行查看
ls /var/www
- Recipiente de volume de dados
//数据卷容器
docker run --name web100 -v /data1 -v /data2 -it centos /bin/bash ##（加/bin/bash 就是可以直接进入容器）
- Novo contêiner de volume de dados de montagem de contêiner web100
docker run -it -volumes-from web100 --name db1 centos /bin/bash
注释：容器web100 和容器db1 所挂载的目录data1和data2 数据是同步运行的。
- Mapeamento de portas
docker run -d -p httpd:centos
docker run -d -p 49280:80 httpd:centos
docker ps -a
Nove, estabelecimento de armazém privado local
docker pull registry
[root@localhost /]# docker pull registry
Using default tag: latest
latest: Pulling from library/registry
cbdbe7a5bc2a: Pulling fs layer
47112e65547d: Pulling fs layer
46bcb632e506: Pulling fs layer
c1cc712bcecd: Pulling fs layer
3db6272dcbfa: Pulling fs layer
latest: Pulling from library/registry
cbdbe7a5bc2a: Pulling fs layer
47112e65547d: Pulling fs layer
46bcb632e506: Pulling fs layer
c1cc712bcecd: Pulling fs layer
3db6272dcbfa: Pulling fs layer
open /var/lib/docker/tmp/GetImageBlob684407966: no space left on device
---------------------------------------------------
vim /etc/docker/daemon.json
{
"insecure-registries":["192.168.75.200:5000"], //添加
"registry-mirrors": ["https://1i3tpy0i.mirror.aliyuncs.com"]
}
~
systemctl restart docker.service
docker create -it registry /bin/bash #新建容器
docker ps -a
[root@localhost docker]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ba786a224305 registry "/entrypoint.sh /bin…" 44 minutes ago Exited (127) 9 minutes ago zen_hamilton
docker start 231d40e811cd ##开启（不是up是正确的）
##宿主机的/data/registry自动创建挂载容器中的/tmp/registry
docker run -d -p 5000:5000 -v /data/registry:/tmp/registry registry
docker pull httpd
##更改标记为192.168.75.200:5000/httpd
docker tag httpd:latest 192.168.75.200:5000/httpd (标记IP地址与私有仓库的地址和端口相一致)
docker push 192.168.75.200:5000/httpd ##上传镜像
##获取私有仓库列表
curl -XGET http://192.168.75.200:500/v2/_catalog
docker pull 192.168.75.200:500/httpd ##测试私有仓库下载镜像
- Mapeamento de portas
docker run -d -P httpd:centos ##随机分配外部的映射端口
docker run -d -p 43992:80 httpd:centos ##指定端口映射
docker ps -a ##查看
Dez, interconexão de contêiner
(1) Mapeamento de portas para interconexão de contêineres
- Crie e execute o contêiner denominado web1, o número da porta é mapeado automaticamente
docker run -itd -P --name web1 ecntos /bin/bash
- Crie e execute o contêiner denominado web2, conecte-se a web1 e comunique-se com ele
docker run -itd -P --name web2 --link web1:web1 centos /bin/bash
- No contêiner web2, ping web1
O mapeamento de portas não é a única maneira de conectar o docker a outro contêiner.
O Docker tem um sistema de conexão que permite que vários contêineres sejam conectados e compartilhem informações de conexão.
A conexão docker cria um relacionamento pai-filho, em que o contêiner pai pode ver as informações do contêiner filho.
(2) Configurações de rede para interconexão de contêiner
新建网络
下面先创建一个新的 Docker 网络。
$ docker network create -d bridge test-net
参数说明：
-d：参数指定 Docker 网络类型，有 bridge、overlay。
其中 overlay 网络类型用于 Swarm mode，在本小节中你可以忽略它。
连接容器
运行一个容器并连接到新建的 test-net 网络:
$ docker run -itd --name test1 --network test-net ubuntu /bin/bash
打开新的终端，再运行一个容器并加入到 test-net 网络:
$ docker run -itd --name test2 --network test-net ubuntu /bin/bash
apt-get update
apt install iputils-ping
下面通过 ping 来证明 test1 容器和 test2 容器建立了互联关系。
如果 test1、test2 容器内中无 ping 命令，则在容器内执行以下命令安装 ping（即学即用：可以在一个容器里安装好，提交容器到镜像，在以新的镜像重新运行以上俩个容器）。
11. Resumo
- A tecnologia de contêiner do Docker pode criar facilmente um contêiner leve, portátil e autossuficiente para qualquer aplicativo em um host.
- Espelho, contêiner e warehouse são os três conceitos principais do docker.
- Dockerfile é um script interpretado pelo programa docker. O dockerfile consiste em várias instruções, e cada instrução corresponde a um comando no Linux.
- Gerenciar o volume de dados principal e o modo de contêiner de volume de dados dos dados no contêiner docker.