docker run -i -t --name apache_web ubuntu /bin/bash
Isso cria um novo contêiner com um ID exclusivo e o nome apache_web. Também fornece um shell de root porque você especificou /bin/bash como o comando para executar. Agora, instale o servidor web Apache usando apt-get:
apt-get install apache2
Observe que você não precisa usar sudoporque você está executando como root dentro do recipiente. Observe que você fazer preciso correr apt-get updateporque, novamente, a lista de pacotes dentro do contêiner não é a mesma que está fora dele. (As outras instruções dentro do recipiente não requerem sudo a menos que explicitamente declarado.)
O normal apt-get a saída aparece e o pacote Apache2 é instalado em seu novo contêiner. Assim que a instalação for concluída, inicie o Apache, instale curle teste a instalação, tudo dentro do seu contêiner:
service apache2 start
apt-get install curl
curl http://localhost
Se você estivesse fazendo isso em um ambiente de produção, em seguida configuraria o Apache de acordo com seus requisitos e instalaria um aplicativo para ele servir. O Docker permite que diretórios fora de um contêiner sejam mapeados para caminhos dentro dele, portanto, uma abordagem é armazenar seu aplicativo Web em um diretório no host e torná-lo visível para o contêiner por meio de um mapeamento.
Crie um script de inicialização para um contêiner Docker
Lembre-se de que um contêiner Docker é executado apenas enquanto seu processo ou processos estiverem ativos. Portanto, se o processo iniciado ao executar um contêiner pela primeira vez for colocado em segundo plano, como um daemon do sistema, o Docker interromperá o contêiner. Portanto, você precisa executar o Apache em primeiro plano quando o contêiner for iniciado, para que o contêiner não saia assim que for iniciado.
Crie um roteiro, startapache.shem /usr/local/sbin:
apt-get install nano
nano /usr/local/sbin/startapache.sh
(Você não precisa usar o nano editor para fazer isso, mas é conveniente.)
O conteúdo de startapache.sh:
#!/bin/bash
. /etc/apache2/envvars
/usr/sbin/apache2 -D FOREGROUND
Salve o arquivo e torne-o executável:
chmod +x /usr/local/sbin/startapache.sh
Tudo o que esse pequeno script faz é trazer as variáveis de ambiente apropriadas para o Apache e iniciar o processo do Apache em primeiro plano.
Você terminou de modificar o conteúdo do contêiner, então pode sair do contêiner digitando exit. Quando você sair do contêiner, ele irá parar.
Confirme o contêiner para criar uma nova imagem Docker
Agora você precisa comprometer-se o contêiner para salvar as alterações feitas:
docker commit apache_web local:apache_web
O commit salvará seu contêiner como uma nova imagem e retorne um ID exclusivo. O argumento local:apache_web fará com que o commit seja colocado em um repositório local chamado local com uma etiqueta de apache_web.
Você pode ver isso executando o comando docker images:
REPOSITORY TAG IMAGE ID CREATED SIZE
local apache_web 540faa63535d 24 seconds ago 233MB
ubuntu latest b1e9cef3f297 4 weeks ago 78.1MB
Observe que os detalhes exatos da sua imagem – o ID da imagem e o tamanho do contêiner – serão diferentes do meu exemplo.
Noções básicas de rede Docker
Agora que você tem sua imagem, pode iniciar seu contêiner e começar a veicular páginas. Antes de fazer isso, vamos discutir como o Docker lida com a rede.
O Docker pode criar várias redes virtuais usadas pelos contêineres do Docker para se comunicarem entre si e com o mundo exterior:
- ponte: esta é a rede à qual os contêineres se conectam por padrão. O
bridgeA rede permite que os contêineres se comuniquem diretamente entre si, mas não com o sistema host. - hospedar: esta rede permite que os contêineres sejam vistos diretamente pelo host, como se quaisquer aplicativos dentro deles estivessem sendo executados como serviços de rede local.
- nenhum: Esta é essencialmente uma rede nula ou de loopback. Um contêiner conectado a
nonenão consegue ver nada além de si mesmo.
Também existem outros drivers de rede, mas esses três são cruciais para começar.
Quando você deseja iniciar um contêiner e fazer com que ele se comunique com outros contêineres e com o mundo externo, você precisa mapear manualmente as portas desse contêiner para o host. Para fins de meu exemplo, você pode fazer isso na linha de comando ao iniciar seu contêiner recém-criado:
docker run -d -p 8080:80 --name apache local:apache_web /usr/local/sbin/startapache.sh
O -p switch é usado para mapeamento de portas. Aqui, ele mapeia porta 8080 no host para porta 80 dentro do recipiente.
Depois de executar este comando, você poderá apontar um navegador da web para o endereço IP do host e ver a página padrão do servidor da web Apache.
Você pode ver o status do contêiner e os mapeamentos da porta TCP usando o comando docker ps comando:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS
NAMES
81d8985d0197 local:apache_web "/usr/local/sbin/sta…" 13 minutes ago Up 12 minutes 0.0.0.0:8080->80/tcp apache
Você também pode procurar os mapeamentos de rede usando o docker port comando, neste caso docker port apache
80/tcp -> 0.0.0.0:8080
Observe que você pode usar o -P opção no docker run comando para publicar todas as portas abertas no contêiner para o host e mapear uma porta alta aleatória, como 49153, de volta para a porta 80 no contêiner. Isso pode ser usado em scripts conforme necessário, mas geralmente é uma má ideia fazer isso em produção.
Neste ponto, você tem um contêiner Docker totalmente funcional executando seu processo Apache. Ao parar o contêiner, ele permanecerá no sistema e poderá ser reiniciado a qualquer momento através do docker restart comando.
Use Dockerfiles para automatizar construções de imagens Docker
Por mais educativo que seja construir contêineres Docker manualmente, é puro tédio fazer isso repetidamente. Para tornar o processo de construção fácil, consistente e repetível, o Docker fornece uma forma de automação para a criação de imagens Docker chamada Dockerfiles.
Dockerfiles são arquivos de texto armazenados em um repositório junto com imagens Docker. Eles descrevem como um contêiner específico é construído, permitindo que o Docker execute o processo de construção automaticamente para você. Aqui está um exemplo de Dockerfile para um contêiner mínimo, muito parecido com aquele que construí nos primeiros estágios desta demonstração:
FROM ubuntu:latest
RUN apt-get update
RUN apt-get install -y curl
ENTRYPOINT ("/bin/bash")
Se você salvar este arquivo como dftest em seu diretório local, você pode construir uma imagem chamada ubuntu:testing de dftest com o seguinte comando:
docker build -t ubuntu:testing -
No PowerShell, você usaria este comando:
cat .dftest | docker build -t ubuntu:testing -
Docker construirá uma nova imagem baseada no ubuntu:latest imagem. Então, dentro do container, ele realizará um apt-get update e usar apt-get instalar curl. Finalmente, ele definirá o comando padrão para ser executado na inicialização do contêiner como /bin/bash. Você poderia então executar:
docker run -i -t ubuntu:testing
Et voilá! Você tem um shell root em um novo contêiner criado de acordo com essas especificações. Observe que você também pode iniciar o contêiner com este comando:
docker run -i -t dftest
Vários operadores estão disponíveis para serem usados em um Dockerfile, como mapeamento de diretórios de host para contêineres, configuração de variáveis de ambiente e até mesmo configuração de gatilhos para serem usados em compilações futuras. Consulte a página de referência do Dockerfile para obter uma lista completa dos operadores do Dockerfile.
Próximas etapas com Docker
Há muito mais no Docker do que abordamos neste guia, mas você deve ter uma compreensão básica de como o Docker opera, uma compreensão dos principais conceitos do Docker e familiaridade suficiente para construir contêineres funcionais. Você pode encontrar mais informações no site do Docker, incluindo um tutorial on-line que fornece detalhes mais granulares sobre os recursos do Docker.
