Programa
Containerization and Virtualization with Docker and Kubernetes
0 min
O NGINX dentro de um contêiner do Docker pode fornecer um serviço da Web confiável em muitos ambientes. Você pode estar trabalhando em um site pessoal, em um serviço leve da Web ou em um projeto de laboratório doméstico. O Docker pode ajudar você a mantê-lo consistente em diferentes máquinas e configurações. Essa abordagem oferece uma maneira de executar o NGINX com menos preocupações de sobrecarga ao alternar entre desenvolvimento e produção. É comum confiar no Docker para o empacotamento simples do servidor Web, o que facilita o compartilhamento dos seus projetos sem etapas manuais complicadas.
Este artigo explica como você pode executar uma imagem pronta do NGINX, como servir conteúdo de seu computador local e como criar sua imagem com recursos personalizados. Ele também aborda as etapas de configuração de um proxy reverso, além do uso do Docker Compose para implantação de vários serviços. No final, você verá como gerenciar contêineres com alguns comandos simples e terá uma visão detalhada de como integrar o Docker e o NGINX para tarefas práticas.
Se você é novo no Docker, não deixe de conferir nosso Guia do Docker para iniciantes para que você aprenda todos os fundamentos.
O que é o Docker NGINX?
O Docker NGINX refere-se à execução do servidor da Web NGINX dentro de um contêiner leve. Os contêineres do Docker são semelhantes a pequenos pacotes que contêm um aplicativo e todas as dependências de que ele precisa.
O NGINX é um servidor da Web popular conhecido pelo bom desempenho, fácil configuração e manuseio flexível do tráfego HTTP. O emparelhamento do NGINX com o Docker é interessante porque mantém o ambiente consistente. Se você implantar no macOS, Windows ou Linux, o conteúdo do contêiner permanecerá o mesmo. Isso significa que ele se comporta de forma idêntica, independentemente do sistema operacional do host.
Uma imagem típica do Docker para o NGINX inclui o software do servidor, uma configuração padrão e uma estrutura de diretório para arquivos hospedados. Você pode executar esse contêiner imediatamente ou ajustá-lo mapeando pastas específicas, ajustando arquivos de configuração ou criando uma imagem com base em seu próprio Dockerfile. Ao fazer isso, você pode adicionar módulos ou scripts personalizados para personalizar o NGINX para o seu aplicativo.
Para saber mais sobre como colocar aplicativos em contêineres, consulte nosso artigo Como colocar um aplicativo em contêiner usando o Docker para você. Nele, você encontrará mais detalhes sobre como colocar em contêineres aplicativos de machine learning com o Docker de uma forma amigável para iniciantes.
Pré-requisitos
Antes de você começar a executar contêineres do NGINX, confirme se o Docker está instalado. O Docker tem instaladores oficiais para macOS, Windows e várias distribuições Linux. A documentação do Docker fornece um processo passo a passo para cada sistema operacional.
Confira nossa Introdução ao Docker para que você tenha um guia abrangente sobre como começar a usar o Docker.
Teste a instalação com um comando rápido, como, por exemplo, "Você está pronto?
docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
Version: 28.0.1
API version: 1.48
Go version: go1.23.6
Git commit: 068a01e
Built: Wed Feb 26 10:38:16 2025
OS/Arch: darwin/arm64
Context: desktop-linux
Server: Docker Desktop 4.39.0 (184744)
Engine:
Version: 28.0.1
API version: 1.48 (minimum version 1.24)
Go version: go1.23.6
Git commit: bbd0a17
Built: Wed Feb 26 10:40:57 2025
OS/Arch: linux/arm64
Experimental: false
containerd:
Version: 1.7.25
GitCommit: bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
runc:
Version: 1.2.4
GitCommit: v1.2.4-0-g6c52b3f
docker-init:
Version: 0.19.0
GitCommit: de40ad0Se você vir detalhes da versão, isso significa que o Docker está pronto. Além do Docker em si, você precisa de acesso à Internet para extrair a imagem do NGINX do Docker Hub. Se você planeja criar sua imagem, precisará de um editor de texto para escrever um Dockerfile. Qualquer editor de texto funciona bem, mas escolha um que seja confortável para você.
Configuração do NGINX em um contêiner do Docker
Executar o NGINX a partir de uma imagem pronta geralmente é o método mais rápido. Você pode extraí-lo do Docker Hub em questão de segundos e, em seguida, iniciar um contêiner. Depois disso, você verá a página padrão no navegador. Esse processo curto costuma ser a primeira etapa em muitas configurações de servidor baseadas no Docker.
Extração da imagem do Docker do NGINX
A imagem oficial do NGINX está disponível publicamente no Docker Hub com o nome nginx.
Faça o seguinte:
docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete
bef2ee7fab45: Download complete
d9b636547744: Downloading [======================> ] 12.58MB/28.04MB
0994e771ba34: Downloading [===> ] 3.146MB/40.56MB
589701e352f8: Download complete
13f89c653285: Download complete
8e77214beb25: Download complete Isso vai para o registro e obtém a versão mais recente. Quando tudo estiver concluído, você poderá verificar se ele existe em seu computador:
docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 124b44bfc9cc 6 weeks ago 280MB
keras-custom-training-container latest <none> 7de0f04013e5 7 Esse comando mostra uma lista de imagens em sua biblioteca local. Você deverá ver a imagem nginx na tabela. Isso significa que você está pronto para criar um contêiner a partir dele. Descubra uma lista de imagens de que você precisaria para seus projetos de ciência de dados em nosso 12 principais imagens de contêineres do Docker para machine learning e IA tutorial.
Executando o contêiner do NGINX
Quando a imagem do NGINX estiver no seu sistema, você poderá iniciar o contêiner com um único comando:
docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70Esse comando faz várias coisas. Ele executa um contêiner chamado mynginx em segundo plano (devido à opção -d ). Ele mapeia a porta 8080 no seu computador host para a porta 80 dentro do contêiner. Esse mapeamento de portas significa que você pode visitar http://localhost:8080 em seu navegador e você verá a página padrão do NGINX. O contêiner usa a imagem nginx obtida do Docker Hub.
O novo contêiner deve continuar em execução porque o NGINX está ativo. Se você verificar os registros com:
docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14)
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3Você pode ver todas as mensagens que o NGINX escreveu.
Fornecimento de conteúdo personalizado com o NGINX
Talvez você queira exibir uma página HTML, em vez da página padrão incluída na imagem do contêiner. Você pode criar um arquivo simples em seu computador local e montá-lo no contêiner. Isso mantém seu conteúdo separado do contêiner. Sempre que você ajustar sua página, poderá atualizar o navegador para ver a alteração.
Criando uma página HTML personalizada
Escolha um local conveniente em sua máquina local. Possivelmente, uma pasta chamada html_content em seu diretório pessoal. Crie um arquivo index.html nesse local. Pode ser assim:
<html>
<head>
<title>My NGINX Page</title>
</head>
<body>
<h1>Hello from my Docker NGINX setup!</h1>
<p>This is a custom page served from a local folder.</p>
</body>
</html>Essa é uma página HTML básica. Você pode colocar qualquer texto ou estilo que desejar. Adicione imagens ou JavaScript, ou qualquer outra coisa que atenda às suas necessidades.
Montagem da página HTML no contêiner do NGINX
A imagem oficial do NGINX serve conteúdo de /usr/share/nginx/html por padrão. Você pode mapear sua pasta local para esse local dentro do contêiner. Isso é feito com o sinalizador -v (volume) no Docker. Interrompa qualquer contêiner existente chamado mynginx para evitar um conflito de portas:
docker stop mynginx
docker rm mynginxEm seguida, inicie um novo contêiner:
docker run --name mynginx -p 8080:80 -d \
-v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18Substitua /path/to/html_content pelo caminho real em seu computador. Dessa forma, sempre que você navegar para http://localhost:8080o contêiner exibirá o arquivo HTML que você colocou em html_content. Por padrão, se você chamá-lo de index.html, o NGINX carregará esse arquivo automaticamente.
Essa abordagem é vantajosa quando você deseja ajustar o conteúdo regularmente. Você não precisa reconstruir o contêiner todas as vezes. O servidor extrai o conteúdo de sua pasta local em tempo real.
Se você vir um aviso relacionado à permissão, talvez seja necessário garantir que o usuário local e o Docker possam ler essa pasta.
No Linux, isso pode significar ajustar a propriedade ou as permissões do arquivo. No Windows ou no macOS, isso pode significar conceder permissão ao Docker para acessar sua unidade.
Criando uma imagem personalizada do Docker do NGINX
A montagem de uma pasta local é uma solução rápida para testes simples. Talvez você queira módulos extras, uma configuração especial ou algum outro ajuste. É nesse ponto que a criação de uma imagem pode ser útil.
O Docker facilita a criação de um pequeno arquivo de receita, conhecido como Dockerfile, que configura um contêiner exatamente como você deseja. Em seguida, você terá uma imagem que poderá compartilhar com outras pessoas ou enviar para um registro. Isso pode ser mais conveniente do que dizer às pessoas para montarem um monte de arquivos locais.
Criando um Dockerfile
Um Dockerfile é apenas um arquivo de texto simples. Você pode chamá-lo de Dockerfile ou escolher outro nome, se preferir. Coloque-o em um novo diretório. Aqui está um exemplo simples:
FROM nginx:latest
COPY index.html /usr/share/nginx/html/index.htmlIsso usa a imagem oficial do nginx:latest como base. Em seguida, ele copia um arquivo local chamado index.html para a pasta padrão de conteúdo da Web no contêiner. Você pode incluir mais linhas se precisar delas. Por exemplo, você pode copiar um nginx.conf personalizado ou adicionar módulos que deseja instalar. Isso depende de suas necessidades. Se você quiser apenas colocar uma página estática, o snippet acima é suficiente.
Quando você tiver esse Dockerfile no lugar, adicione o index.html personalizado na mesma pasta. Então você pode construir. O comando típico é:
docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED docker:desktop-linux
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 245B 0.0s
=> [internal] load metadata for docker.io/library/nginx:latest 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load build context 0.0s
=> => transferring context: 365B 0.0s
=> [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19 2.3s
=> => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19 2.3s
=> [2/2] COPY index.html /usr/share/nginx/html/index.html 0.0s
=> exporting to image 0.1s
=> => exporting layers 0.0s
=> => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a 0.0s
=> => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1 0.0s
=> => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b 0.0s
=> => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5 0.0s
=> => naming to docker.io/library/mynginximage:latest 0.0s
=> => unpacking to docker.io/library/mynginximage:latest 0.0sO ponto no final indica o diretório atual como o contexto de compilação. O Docker lê o Dockerfile nesse diretório. Você terá uma imagem chamada mynginximage em seu sistema local. Verifique com:
docker images
mynginximage latest d35c2bbe10ab 36 seconds ago 281MBVocê deverá ver o novo nome na lista. Com essa abordagem, o Dockerfile e o HTML são combinados em uma única imagem. Você não precisa montar nada em tempo de execução.
Criação e execução da imagem personalizada
Agora que o mynginximage foi criado, você pode executá-lo:
docker run --name mycustomnginx -p 8080:80 -d mynginximageCertifique-se de interromper o contêiner anterior para evitar conflitos de porta.
Esse contêiner serve automaticamente a página que você colocou no Dockerfile. Se você abrir um navegador em http://localhost:8080, deverá ver esse texto HTML.
Você pode compartilhar seu Dockerfile com outras pessoas ou enviar a imagem criada para um registro. Em seguida, seus colegas de equipe ou de trabalho podem ativá-lo sem copiar as pastas locais.
Isso conclui o processo de criação de uma imagem NGINX personalizada mínima. Você começou com a base oficial, copiou um ou dois arquivos e produziu um novo contêiner que inclui seu site personalizado. Você pode estender o Dockerfile ainda mais. Por exemplo, você pode querer mudar a configuração para lidar com o PHP com php-fpm em uma compilação de vários estágios ou adicionar módulos personalizados que o NGINX não envia por padrão.
Essa abordagem destaca a flexibilidade do Docker: cada camada do Dockerfile pode lidar com uma determinada tarefa, e a imagem final pode ser distribuída facilmente. Você tem controle sobre o conteúdo da Web, além da opção de ajustar as configurações para que o contêiner se adapte ao seu projeto.
Explore estas 10 ideias de projetos do Docker para aprender o Docker com projetos práticos focados na criação e otimização de aplicativos de ciência de dados.
Configurando o NGINX como um proxy reverso
O NGINX pode direcionar as solicitações de entrada para outros serviços no mesmo sistema ou até mesmo para serviços executados em máquinas separadas. Normalmente, isso é chamado de configuração de proxy reverso. Você pode colocar o NGINX na frente de um grupo de aplicativos para que as solicitações possam passar por um único ponto de entrada.
Isso é comum quando você tem vários contêineres do Docker escutando em portas diferentes e deseja um único nome de domínio para tudo. O NGINX escuta em uma porta padrão, como 80 ou 443, e encaminha o tráfego para o serviço correto com base no caminho, no nome do host ou em outros fatores.
Entendendo o proxy reverso
Quando o NGINX é configurado dessa forma, o cliente não tem conhecimento da comunicação em segundo plano. O NGINX atua como a face pública, recebendo e encaminhando solicitações e, em seguida, enviando respostas de volta ao cliente.
Esse design simplifica a estrutura da sua rede. Ele também oferece a oportunidade de ajustar o cache, adicionar certificados TLS, lidar com o balanceamento de carga ou realizar outras tarefas avançadas. Geralmente, é mais fácil gerenciar essas tarefas em um único local, em vez de dispersá-las entre vários serviços.
Um cenário típico pode envolver um contêiner executando o NGINX na porta 80, que envia solicitações a um contêiner de aplicativo na porta 3000. Enquanto o cliente visita o site http://yourdomain.com, o tráfego é direcionado para um contêiner separado nos bastidores.
Isso pode permitir que o contêiner do aplicativo mantenha a porta padrão, com o mínimo de sobrecarga para o usuário. Outro motivo para fazer isso é que você pode querer ocultar os detalhes internos dos seus serviços ou apresentar uma estrutura de URL uniforme.
Configuração do NGINX para proxy reverso
Para conseguir isso, você precisa de um arquivo de configuração para o NGINX personalizado que usa diretivas de proxy. Você pode fazer isso montando um novo arquivo de configuração ao executar o contêiner ou criando uma imagem personalizada que o inclua. Aqui está um exemplo simples para ilustrar a ideia geral:
server {
listen 80;
location / {
proxy_pass http://myapp:3000/;
}
}No trecho acima, qualquer solicitação que chegar ao contêiner do NGINX na porta 80 será enviada para myapp:3000. O nome myapp sugere que há outro contêiner acessível por esse nome, o que é comum quando você usa a rede do Docker .
Se estiver usando contêineres autônomos, você poderá mapear o endereço IP do contêiner ou usar o IP do host. Você também pode adicionar configurações mais avançadas, como proxy_set_header Host $host, ou ajustar os valores de tempo limite para se adequar ao seu aplicativo.
Se você optar por montar esse arquivo em tempo de execução, poderá fazer algo assim:
docker run --name nginxproxy -p 8080:80 -d \
-v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
--network mynetwork \
nginxEsse comando executa o contêiner do NGINX, montando seu site local nginx.conf como a configuração padrão. Ele também conecta o contêiner a uma rede do Docker chamada mynetwork, onde reside seu outro contêiner (myapp). Essa costuma ser a abordagem mais simples se você quiser manter sua configuração fora do contêiner.
Também é possível colocar esse arquivo em um Dockerfile se você quiser um arranjo estático. Qualquer uma das abordagens pode funcionar, desde que as referências correspondam à forma como você nomeou seus contêineres e redes.
Esse design permite que você tenha um único domínio ou IP para todos os seus serviços da Web, juntamente com uma porta comum. Se estiver lidando com vários contêineres de back-end, você poderá definir vários locais na sua configuração, cada um apontando para uma porta de contêiner diferente. O NGINX pode então rotear para cada serviço com base no caminho da URL. Essa é uma abordagem popular para microsserviços porque consolida os pontos de entrada de maneira organizada.
Usando o Docker Compose para implantação do NGINX
Um proxy reverso geralmente se torna mais útil quando você tem vários contêineres que trabalham juntos. O Docker Compose é uma ferramenta que permite que você defina vários serviços em um único arquivo. Em seguida, você pode aumentá-los ou diminuí-los com um único comando. Isso reduz a chance de erros na criação de contêineres ou no mapeamento de portas, pois todos os detalhes residem em um arquivo padrão.
Introdução ao Docker Compose
O Docker Compose permite que você gerencie conjuntos de contêineres. Você descreve cada serviço, especifica a imagem a ser usada, as portas a serem publicadas, os volumes a serem montados e as redes a serem conectadas. Em seguida, um simples comando (docker compose up -d ) iniciará tudo de uma vez .
Essa abordagem é útil para o desenvolvimento local ou para ambientes de preparação em que você precisa coordenar vários contêineres do Docker. O formato de arquivo usual é YAML.
Embora o Docker Compose possa funcionar em vários sistemas operacionais, você precisa garantir que ele esteja instalado e seja reconhecido. As instalações modernas do Docker Desktop geralmente o incluem por padrão. Verifique sua versão com:
docker compose version
Docker Compose version v2.33.1-desktop.1Se você vir os detalhes da versão, estará pronto para continuar. Se você não tiver, consulte a documentação do Docker para saber como ativar ou instalar o Docker Compose.
Criando um arquivo docker-compose.yml
Normalmente, o arquivo inclui uma seção de serviços. Veja abaixo um exemplo simples de um arquivo docker-compose.yml que configura um único contêiner NGINX para servir conteúdo estático:
services:
web:
image: nginx:latest
ports:
- "8080:80"
volumes:
- ./html:/usr/share/nginx/htmlAqui está como você deve interpretar o arquivo:
- serviços: Define os serviços (contêineres) que compõem o seu aplicativo.
- web: Esse serviço usa a imagem mais recente do NGINX.
- portos: Mapeia a porta 80 dentro do contêiner para a porta 8080 em seu computador host. Isso permite que você acesse o servidor da Web via http://localhost:8080.
- volumes: Monta o diretório local
htmlno diretório de conteúdo padrão do NGINX dentro do contêiner (/usr/share/nginx/html). Essa configuração permite que o NGINX atenda ao seu conteúdo estático personalizado.
Implantação de serviços com o Docker Compose
No mesmo diretório do arquivo docker-compose.yml, crie um subdiretório chamado html.
Coloque seus arquivos HTML estáticos (por exemplo, index.html) dentro desse diretório html. Nesse caso, criei uma página simples com estilo Bootstrap para demonstração.
Abra um terminal e navegue até o diretório do projeto que contém o arquivo docker-compose.yml.
Execute o seguinte comando para iniciar o serviço:
docker compose up -d
[+] Running 1/1
✔ Container html_content-web-1 Started O sinalizador -d executa o contêiner no modo desanexado, permitindo que ele seja executado em segundo plano.
O Docker Compose examina o arquivo docker-compose.yml no diretório atual. Ele extrai todas as imagens que ainda não estão presentes e, em seguida, inicia cada contêiner.
Abra seu navegador da Web e navegue até http://localhost:8080.
Você deverá ver seu conteúdo estático sendo servido pelo NGINX.
Você pode inspecionar o status dos serviços em execução verificando:
docker compose psSe você precisar desmontar tudo, um único comando pode remover os contêineres:
docker compose downIsso interrompe e remove todos eles de uma vez. Se você quiser replicar todo o ambiente, basta copiar o arquivo do Docker Compose e o código relevante para uma nova máquina e, em seguida, executar os mesmos comandos. Isso garante que você obtenha resultados consistentes com o mínimo de etapas manuais.
Gerenciando contêineres NGINX
Embora a abordagem do Docker Compose seja popular para fluxos de trabalho de vários serviços, às vezes você só precisa gerenciar um único contêiner ou um pequeno cluster. O Docker fornece alguns comandos básicos que ajudam você a ver o que está em execução, pausar ou parar contêineres e removê-los, se necessário.
Eles são essenciais para a manutenção, especialmente se você estiver fazendo experiências com vários contêineres do NGINX ou compilações repetidas.
Visualização de contêineres em execução
Sempre que quiser ver quais contêineres estão em execução, você pode usar:
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2d386c085129 mynginximage "/docker-entrypoint.…" 4 minutes ago Up 4 minutes 0.0.0.0:8080->80/tcp mycustomnginxEsse comando imprime uma tabela de contêineres ativos, cada um com um ID, imagem, nome e muito mais. Se você precisar ver todos os contêineres, inclusive os que pararam, use:
docker ps -aIsso mostra todos os contêineres que existem no seu sistema, mesmo aqueles que foram encerrados. Geralmente, é útil ver quais contêineres ainda estão lá de execuções mais antigas. Você pode ter contêineres com os nomes mynginx, mycustomnginx, ou qualquer outro nome, caso tenha feito experiências com várias imagens.
Parar e remover contêineres
Quando terminar de usar um contêiner, você poderá interrompê-lo pelo nome:
docker stop mynginx
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2d386c085129 mynginximage "/docker-entrypoint.…" 4 minutes ago Up 4 minutes 0.0.0.0:8080->80/tcp mycustomnginxIsso diz ao Docker para enviar um sinal de parada ao contêiner, o que deve fazer com que o NGINX seja desligado de forma limpa. Se quiser remover o recipiente logo em seguida, você pode fazê-lo:
docker rm mynginxSe você preferir um único comando que interrompa e remova de uma só vez, experimente:
docker rm -f mynginxIsso força a remoção, parando o contêiner se ele ainda estiver em execução. Seja cauteloso ao usar essa abordagem em um ambiente de produção, pois ela encerra o contêiner sem dar a ele um desligamento normal. Outro comando de limpeza é docker rmi, que remove as imagens do sistema .
Isso é útil se você não precisar mais de determinadas imagens e quiser liberar espaço. No entanto, o Docker só exclui imagens que não estão sendo usadas por um contêiner em execução.
Conclusão
O NGINX no Docker é uma maneira prática de servir páginas da Web ou rotear o tráfego para outros serviços. Você pode executar a imagem oficial ou criar a sua própria com um simples Dockerfile. O Docker Compose pode coordenar vários contêineres, facilitando o manuseio de configurações complexas.
Com esses métodos, você pode fornecer conteúdo, lidar com encaminhamento e manter um ambiente confiável para projetos da Web.
Se você precisar de uma abordagem mais prática para aprender o Docker, confira nosso Curso de introdução ao Docker para você descobrir sua importância no kit de ferramentas do profissional de dados.
Como faço para executar um contêiner do NGINX usando o Docker?
Como posso servir conteúdo personalizado com o NGINX no Docker?
Como faço para configurar o NGINX como proxy reverso no Docker?
Como posso usar o Docker Compose para implantar o NGINX com outros serviços?
Como faço para parar e remover um contêiner NGINX no Docker?
Tópicos
