Implantando NGINX e NGINX Plus com Docker

Editor – Os Dockerfiles NGINX Plus para Alpine Linux e Debian foram atualizados em novembro de 2021 para refletir as versões mais recentes do software. Eles também (junto com as instruções revisadas) usam segredos do Docker para passar informações de licença ao criar uma imagem NGINX Plus.

O Docker é uma plataforma aberta para criar, enviar e executar aplicativos distribuídos como contêineres (pacotes de software leves, autônomos e executáveis que incluem tudo o que é necessário para executar um aplicativo). Os contêineres podem, por sua vez, ser implantados e orquestrados por plataformas de orquestração de contêineres, como o Kubernetes . (Além da tecnologia de contêiner Docker discutida neste blog, a NGINX fornece o F5 NGINX Ingress Controller nas versões baseadas em NGINX Open Source e NGINX Plus; para assinantes do NGINX Plus, o suporte está incluído sem custo extra.)

Como aplicativos de software, o NGINX Open Source e o F5 NGINX Plus são ótimos casos de uso para o Docker, e publicamos uma imagem do NGINX Open Source no Docker Hub , o repositório de imagens do Docker. Esta postagem explica como:

• Implante o NGINX Open Source usando a imagem do Docker Hub
• Gerenciar o NGINX no contêiner (conectar, configurar, registrar, recarregar e reiniciar)
• Implante o NGINX Plus usando uma imagem do Docker que você criar

Introdução

A plataforma aberta Docker inclui o Docker Engine – o tempo de execução de código aberto que cria, executa e orquestra contêineres – e o Docker Hub, um serviço hospedado onde aplicativos Dockerizados são distribuídos, compartilhados e colaborados por toda a comunidade de desenvolvimento ou dentro dos limites de uma organização específica.

Os contêineres Docker permitem que os desenvolvedores concentrem seus esforços no “conteúdo” do aplicativo, separando os aplicativos das restrições de infraestrutura. Os aplicativos Dockerizados são instantaneamente portáteis para qualquer infraestrutura – laptop, servidor bare-metal, VM ou nuvem – tornando-os componentes modulares que podem ser facilmente montados e remontados em aplicativos distribuídos com todos os recursos e continuamente inovados em tempo real.

Para mais informações sobre o Docker, consulte Por que o Docker? ou a documentação completa do Docker .

Usando a imagem do Docker de código aberto NGINX

Você pode criar uma instância do NGINX em um contêiner do Docker usando a imagem NGINX Open Source do Docker Hub.

Vamos começar com um exemplo muito simples. Para iniciar uma instância do NGINX em execução em um contêiner e usando a configuração padrão do NGINX, execute este comando:

# docker run --nome mynginx1 -p 80:80 -d nginx fcd1fb01b14557c7c9d991238f2558ae2704d129cf9fb97bb4fadf673a58580d

Este comando cria um contêiner chamado mynginx1 com base na imagem NGINX. O comando retorna o formato longo do ID do contêiner, que é usado no nome dos arquivos de log; consulte Gerenciando logs .

A opção -p informa ao Docker para mapear a porta exposta no contêiner pela imagem NGINX – porta 80 – para a porta especificada no host do Docker. O primeiro parâmetro especifica a porta no host do Docker, enquanto o segundo parâmetro é mapeado para a porta exposta no contêiner.

A opção -d especifica que o contêiner é executado no modo desanexado, o que significa que ele continua a ser executado até ser interrompido, mas não responde aos comandos executados na linha de comando. Na próxima seção explicaremos como interagir com o contêiner.

Para verificar se o contêiner foi criado e está em execução, e para ver os mapeamentos de portas, executamos docker ps . (Dividimos a saída em várias linhas aqui para facilitar a leitura.)

# docker ps CONTAINER ID IMAGEM COMANDO CRIADO STATUS ... fcd1fb01b145 nginx:latest "nginx -g 'daemon de 16 segundos atrás Ativo 15 segundos ... ... NOMES DE PORTOS ... 0.0.0.0:80->80/tcp mynginx1

O campo PORTS na saída informa que a porta 80 no host do Docker é mapeada para a porta 80 no contêiner. Outra maneira de verificar se o NGINX está em execução é fazer uma solicitação HTTP para essa porta. O código para a página de boas-vindas padrão do NGINX aparece:

# enrolar http://localhost<!DOCTYPE html>
<html>
<head>
<title>Bem-vindo ao nginx!</title>
<style>
body {
width: 35em; margem: 0 auto; família-de-fontes: Tahoma, Verdana, Arial, sans-serif; } É necessária configuração adicional.

Trabalhando com o contêiner NGINX Docker

Então agora temos um contêiner NGINX Docker funcional, mas como gerenciamos o conteúdo e a configuração do NGINX? E quanto ao registro?

Uma nota sobre SSH

É comum habilitar o acesso SSH às instâncias do NGINX, mas a imagem do NGINX não tem o OpenSSH instalado, porque os contêineres do Docker geralmente são projetados para uma única finalidade (nesse caso, executar o NGINX). Em vez disso, usaremos outros métodos suportados pelo Docker.

Como alternativa aos comandos a seguir, você pode executar o comando a seguir para abrir um shell interativo para um contêiner NGINX em execução (em vez de iniciar uma sessão SSH). No entanto, recomendamos isso apenas para usuários avançados.

• Em sistemas Alpine Linux:

  # docker exec -it NGINX_container_ID sh

• Em sistemas Debian:

  # docker exec -it NGINX_container_ID bash

Gerenciando arquivos de conteúdo e configuração

Há várias maneiras de gerenciar o conteúdo fornecido pelo NGINX e os arquivos de configuração do NGINX. Aqui abordamos algumas das opções.

Opção 1 – Manter o conteúdo e a configuração no host do Docker

Quando o contêiner é criado, podemos dizer ao Docker para montar um diretório local no host do Docker em um diretório no contêiner. A imagem NGINX usa a configuração padrão do NGINX, que usa /usr/share/nginx/html como o diretório raiz do contêiner e coloca os arquivos de configuração em /etc/nginx . Para um host Docker com conteúdo no diretório local /var/www e arquivos de configuração em /var/nginx/conf , execute este comando (que aparece em várias linhas aqui apenas para legibilidade):

# docker run --name mynginx2 --mount type=bind fonte=/var/www,destino=/usr/share/nginx/html,somente leitura --mount type=bind,fonte=/var/nginx/conf,destino=/etc/nginx/conf,somente leitura -p 80:80 -d nginx

Agora, qualquer alteração feita nos arquivos nos diretórios locais /var/www e /var/nginx/conf no host do Docker é refletida nos diretórios /usr/share/nginx/html e /etc/nginx no contêiner. A opção somente leitura significa que esses diretórios podem ser alterados somente no host do Docker, não de dentro do contêiner.

Opção 2 – Copiar arquivos do host do Docker

Outra opção é fazer com que o Docker copie o conteúdo e os arquivos de configuração de um diretório local no host do Docker durante a criação do contêiner. Depois que um contêiner é criado, os arquivos são mantidos criando um novo contêiner quando os arquivos são alterados ou modificando os arquivos no contêiner. Uma maneira simples de copiar os arquivos é criar um Dockerfile com comandos que são executados durante a geração de uma nova imagem do Docker com base na imagem NGINX do Docker Hub. Para os comandos de cópia de arquivo ( COPY ) no Dockerfile , o caminho do diretório local é relativo ao contexto de compilação onde o Dockerfile está localizado.

Em nosso exemplo, o conteúdo está no diretório content e os arquivos de configuração estão no diretório conf , ambos subdiretórios do diretório onde o Dockerfile está localizado. A imagem NGINX inclui arquivos de configuração padrão do NGINX como /etc/nginx/nginx.conf e /etc/nginx/conf.d/default.conf . Como queremos usar os arquivos de configuração do host, incluímos um comando RUN que exclui os arquivos padrão:

DE nginx
EXECUTAR rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPIAR conteúdo /usr/share/nginx/html
COPIAR conf /etc/nginx

Criamos nossa própria imagem NGINX executando o seguinte comando no diretório onde o Dockerfile está localizado. Observe o ponto final (“.”) no final do comando. Ele define o diretório atual como o contexto de compilação, que contém o Dockerfile e os diretórios a serem copiados.

# docker build -t mynginx_image1 .

Agora executamos este comando para criar um contêiner chamado mynginx3 com base na imagem mynginx_image1 :

# docker run --nome mynginx3 -p 80:80 -d mynginx_image1

Se quisermos fazer alterações nos arquivos no contêiner, usamos um contêiner auxiliar, conforme descrito na Opção 3.

Opção 3 – Manter arquivos no contêiner

Conforme mencionado em Uma nota sobre SSH , não podemos usar SSH para acessar o contêiner NGINX, então, se quisermos editar o conteúdo ou os arquivos de configuração diretamente, temos que criar um contêiner auxiliar que tenha acesso ao shell. Para que o contêiner auxiliar tenha acesso aos arquivos, precisamos criar uma nova imagem que tenha os volumes de dados do Docker adequados definidos para a imagem. Supondo que queremos copiar arquivos como na Opção 2 e também definir volumes, usamos o seguinte Dockerfile :

DE nginxEXECUTAR rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPIAR conteúdo /usr/share/nginx/html
COPIAR conf /etc/nginx
VOLUME /usr/share/nginx/html
VOLUME /etc/nginx

Em seguida, criamos a nova imagem NGINX executando o seguinte comando (observe novamente o ponto final):

# docker build -t mynginx_image2 .

Agora executamos este comando para criar um contêiner NGINX ( mynginx4 ) com base na imagem mynginx_image2 :

# docker run --name mynginx4 -p 80:80 -d mynginx_image2

Em seguida, executamos o seguinte comando para iniciar um contêiner auxiliar mynginx4_files que tem um shell, permitindo-nos acessar o conteúdo e os diretórios de configuração do contêiner mynginx4 que acabamos de criar:

# docker run -i -t --volumes-from mynginx4 --name mynginx4_files debian /bin/bash root@b1cbbad63dd1:/#

O novo contêiner auxiliar mynginx4_files é executado em primeiro plano com uma entrada padrão persistente (a opção -i ) e um tty (a opção -t ). Todos os volumes definidos em mynginx4 são montados como diretórios locais no contêiner auxiliar.

O argumento debian significa que o contêiner auxiliar usa a imagem Debian do Docker Hub. Como a imagem NGINX também usa o Debian (e todos os nossos exemplos até agora usam a imagem NGINX), é mais eficiente usar o Debian para o contêiner auxiliar, em vez de fazer o Docker carregar outro sistema operacional. O argumento /bin/bash significa que o shell bash é executado no contêiner auxiliar, apresentando um prompt de shell que você pode usar para modificar arquivos conforme necessário.

Para iniciar e parar o contêiner, execute os seguintes comandos:

# docker start meus_arquivos_nginx4 # docker stop meus_arquivos_nginx4

Para sair do shell, mas deixar o contêiner em execução, pressione Ctrl+p seguido de Ctrl+q . Para recuperar o acesso do shell a um contêiner em execução, execute este comando:

# docker anexar mynginx4_files

Para sair do shell e encerrar o contêiner, execute o comando exit .

Gerenciando Log

Você pode configurar o registro padrão ou personalizado.

Usando o registro padrão

A imagem NGINX é configurada para enviar os principais logs de acesso e erro do NGINX para o coletor de logs do Docker por padrão. Isso é feito vinculando-os a stdout e stderr , respectivamente; todas as mensagens de ambos os logs são então gravadas no arquivo /var/lib/docker/containers/ container-ID / container-ID -json.log no host do Docker, onde container-ID é o ID de formato longo retornado quando você cria um contêiner. Para o contêiner inicial que criamos em Usando a imagem do Docker de código aberto do NGINX , por exemplo, é fcd1fb01b14557c7c9d991238f2558ae2704d129cf9fb97bb4fadf673a58580d .

Para recuperar o ID do contêiner para um contêiner existente, execute este comando, onde container‑name é o valor definido pelo parâmetro --name quando o contêiner é criado (para o ID do contêiner acima, por exemplo, é mynginx1 ):

# docker inspect --format '{{ .Id }}' nome-do-container

Embora você possa visualizar os logs abrindo o arquivo container-ID -json.log diretamente, geralmente é mais fácil executar este comando:

# registros do docker nome-do-container

Você também pode usar a API do Docker Engine para extrair as mensagens de log, emitindo uma solicitação GET no soquete Docker Unix. Este comando retorna o log de acesso (representado por stdout=1 ) e o log de erros ( stderr=1 ), mas você também pode solicitá-los individualmente:

curl --unix-socket /var/run/docker-sock http://localhost/containers/ nome-do-container /logs?stdout=1&stderr=1

Para saber mais sobre outros parâmetros de consulta, consulte a documentação da API do Docker Engine (pesquise por “Obter logs de contêiner” nessa página).

Usando registro personalizado

Se você quiser implementar outro método de coleta de logs, ou se quiser configurar o log de forma diferente em certos blocos de configuração (como server{} e location{} ), defina um volume do Docker para o diretório ou diretórios nos quais armazenar os arquivos de log no contêiner, crie um contêiner auxiliar para acessar os arquivos de log e use as ferramentas de log que desejar. Para implementar isso, crie uma nova imagem que contenha o volume ou volumes dos arquivos de registro.

Por exemplo, para configurar o NGINX para armazenar arquivos de log em /var/log/nginx/log , podemos começar com o Dockerfile da Opção 3 e simplesmente adicionar uma definição de VOLUME para este diretório:

DE nginxEXECUTAR rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPIAR conteúdo /usr/share/nginx/html
COPIAR conf /etc/nginx
VOLUME /var/log/nginx/log

Podemos então criar uma imagem conforme descrito acima e usá-la para criar um contêiner NGINX e um contêiner auxiliar que tenham acesso ao diretório de registro. O contêiner auxiliar pode ter qualquer ferramenta de registro desejada instalada.

Controlando o NGINX

Como não temos acesso direto à linha de comando do contêiner NGINX, não podemos usar o comando nginx para controlar o NGINX. Felizmente, podemos usar sinais para controlar o NGINX, e o Docker fornece o comando kill para enviar sinais a um contêiner.

Para recarregar a configuração do NGINX, execute este comando:

# docker kill -s HUP nome-do-container

Para reiniciar o NGINX, execute este comando para reiniciar o contêiner:

# docker restart nome-do-container

Implantando o NGINX Plus com o Docker

Até agora discutimos o Docker para NGINX Open Source, mas você também pode usá-lo com o produto comercial, NGINX Plus. A diferença é que primeiro você precisa criar uma imagem NGINX Plus, porque como oferta comercial o NGINX Plus não está disponível no Docker Hub. Felizmente, isso é bem fácil de fazer.

Observação: Nunca carregue suas imagens do NGINX Plus em um repositório público como o Docker Hub. Fazer isso viola seu contrato de licença .

Criando uma imagem Docker do NGINX Plus

Para gerar uma imagem NGINX Plus, primeiro crie um Dockerfile . Os exemplos que fornecemos aqui usam Alpine Linux 3.14 e Debian 11 (Bullseye) como imagens base do Docker. Antes de criar a imagem do Docker do NGINX Plus, você precisa baixar sua versão dos arquivos nginx-repo.crt e nginx-repo.key . Os clientes do NGINX Plus podem encontrá-los no portal do cliente ; se você estiver fazendo um teste gratuito do NGINX Plus, eles foram fornecidos com seu pacote de teste. Copie os arquivos para o diretório onde o Dockerfile está localizado (o contexto de compilação do Docker).

Assim como no NGINX Open Source, por padrão, os logs de acesso e erro do NGINX Plus são vinculados ao coletor de logs do Docker. Nenhum volume é especificado, mas você pode adicioná-los se desejar, ou cada Dockerfile pode ser usado para criar imagens base a partir das quais você pode criar novas imagens com volumes especificados, conforme descrito anteriormente.

Não especificamos propositalmente uma versão do NGINX Plus nos Dockerfiles de exemplo, para que você não precise editar o arquivo ao atualizar para uma nova versão do NGINX Plus. No entanto, incluímos versões comentadas das instruções relevantes para que você possa descomentá-las caso queira tornar o arquivo específico da versão.

Da mesma forma, incluímos instruções (comentadas) que instalam módulos dinâmicos oficiais para o NGINX Plus .

Por padrão, nenhum arquivo é copiado do host do Docker quando um contêiner é criado. Você pode adicionar definições COPY a cada Dockerfile , ou a imagem criada pode ser usada como base para outra imagem, conforme descrito acima.

Arquivo Docker do NGINX Plus (Debian 11)

Arquivo Docker do NGINX Plus (Alpine Linux 3.14)

Criando a imagem NGINX Plus

Com os arquivos Dockerfile , nginx-repo.crt e nginx-repo.key no mesmo diretório, execute o seguinte comando para criar uma imagem do Docker chamada nginxplus (como antes, observe o ponto final):

# DOCKER_BUILDKIT=1 docker build --no-cache -t nginxplus --secret id=nginx-crt,src= seu_arquivo_cert --secret id=nginx-key,src= seu_arquivo_chave .

O sinalizador DOCKER_BUILDKIT=1 indica que estamos usando o Docker BuildKit para construir a imagem, conforme necessário ao incluir a opção --secret , discutida abaixo.

A opção --no-cache informa ao Docker para construir a imagem do zero e garante a instalação da versão mais recente do NGINX Plus. Se o Dockerfile foi usado anteriormente para criar uma imagem e você não incluir a opção --no-cache , a nova imagem usará a versão do NGINX Plus do cache do Docker. (Conforme observado, propositalmente não especificamos uma versão do NGINX Plus no Dockerfile para que o arquivo não precise ser alterado a cada nova versão do NGINX Plus.) Omita a opção --no-cache se for aceitável usar a versão NGINX Plus da imagem criada anteriormente.

A opção --secret passa o certificado e a chave da sua licença NGINX Plus para o contexto de compilação do Docker sem correr o risco de expor os dados ou de fazer com que eles persistam entre as camadas de compilação do Docker. Os valores dos argumentos id não podem ser alterados sem alterar o Dockerfile base, mas você precisa definir os argumentos src para o caminho para o seu certificado NGINX Plus e arquivos de chave (o mesmo diretório onde você está criando a imagem do Docker se seguiu as instruções anteriores).

Uma saída como a seguinte do comando docker images nginxplus indica que a imagem foi criada com sucesso:

# docker images nginxplus REPOSITÓRIO TAG IMAGEM ID CRIADO TAMANHO VIRTUAL nginxplus mais recente ef2bf65931cf 6 segundos atrás 91,2 MB

Para criar um contêiner chamado mynginxplus com base nesta imagem, execute este comando:

# docker run --name mynginxplus -p 80:80 -d nginxplus

Você pode controlar e gerenciar contêineres NGINX Plus da mesma forma que os contêineres NGINX Open Source .

Resumo

NGINX, NGINX Plus e Docker funcionam muito bem juntos. Quer você use a imagem NGINX Open Source do Docker Hub ou crie sua própria imagem NGINX Plus, você pode facilmente criar novas instâncias do NGINX e do NGINX Plus em contêineres Docker e implantá-los em seu ambiente Kubernetes. Você também pode criar facilmente novas imagens do Docker a partir das imagens base, tornando seus contêineres ainda mais fáceis de controlar e gerenciar. Certifique-se de que todas as instâncias do NGINX Plus em execução nos seus contêineres do Docker estejam cobertas pela sua assinatura. Para mais detalhes, entre em contato com a equipe de vendas da NGINX .

Há muito mais no Docker do que conseguimos abordar neste artigo. Para mais informações, baixe nosso eBook gratuito da O'Reilly – Container Networking: Do Docker ao Kubernetes – ou confira www.docker.com .

Documentação relacionada

Implantando NGINX e NGINX Plus no Docker