Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Portugal)
Esta página foi traduzida automaticamente. Ler o original em inglês.

Gateway NGINX — encaminhamento de proxy inverso para um upstream, dois destinos

Este exemplo compila uma stack pequena e real — um gateway de proxy inverso NGINX à frente de um backend web — a partir de um único Aggregate escrito pelo programador para dois destinos:

  • Docker Compose para o desenvolvimento local, e
  • manifestos do Kubernetes sintetizados para um cluster.

O mesmo aggregate.yaml conduz ambos. Só muda, de destino para destino, a camada de Recipe selecionada pelo Manifest.

Ficheiros

FicheiroPapel
aggregate.yamlIntenção do programador: um backend web (core/devtool/adminer) e um gateway proxy (core/gateway/nginx) que declara um uso upstream do backend.
manifest-compose.yamlMapeia o tipo do gateway para a Recipe do Compose (compose/nginx) e o backend para a Recipe do Compose do Adminer.
manifest-helm-synth.yamlMapeia o tipo do gateway para a Recipe helm synth (helm/nginx) e o backend para a Recipe helm offline do Adminer.
release-compose.yaml / release-helm-synth.yamlDocumentos do operador para os dois destinos.

O que demonstra

  • Uma única superfície de autoria, muitos destinos. Um único Aggregate é a fonte de verdade sobre o que a stack é. Cada Manifest diz como realizá-la.
  • Encaminhamento upstream através do String Pipe. O gateway declara um uso upstream do backend; os provides.host e provides.port da Recipe do backend são encaminhados para o gateway e renderizados no destino do seu proxy_pass. O compilador encaminha as strings sem as interpretar — assim, a compilação para Compose liga um nome de serviço do compose e a compilação para Kubernetes liga um nome de Service, a partir da mesma aresta.
  • Configuração idiomática do Provider. Nos dois destinos, o gateway escreve, no arranque do contentor, um bloco server mínimo do NGINX cujo proxy_pass reencaminha para o upstream injetado e, em seguida, inicia o nginx em primeiro plano. O destino Kubernetes realiza isto como um Deployment sem estado mais um Service ClusterIP, sem nenhum chart Helm externo.
  • Imagens reproduzíveis. O destino Kubernetes executa a imagem upstream oficial do nginx fixada numa tag explícita, pelo que o Deployment renderizado referencia uma imagem estável.

Gerar o exemplo

É possível compilar este exemplo com os comandos abaixo, ou pedir ao assistente de IA que o compile.

Escreva o exemplo numa nova pasta com o nome dele:

Terminal window
aggrega scaffold --example nginx-gateway

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta:

Terminal window
cd nginx-gateway

Compilação

Este workspace não contém nenhum .aggrega-config.yaml, pelo que as entidades da biblioteca standard são resolvidas a partir do registo do hub, hub.aggrega.ai, e não é necessária nenhuma flag de catálogo; --auto-pull escreve durante a compilação o lockfile que falta a um clone acabado de criar:

Terminal window
# Local development (Docker Compose)
aggrega build --release release-compose.yaml --auto-pull
# Kubernetes (synthesized manifests)
aggrega build --release release-helm-synth.yaml --auto-pull

Os artefactos renderizados ficam em dist/. O destino Kubernetes renderiza manifestos simples offline — não é necessário nenhum pull de chart.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole-lhe este prompt.

Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por iniciativa própria. Se a pasta Workspace ainda não contiver uma pasta `nginx-gateway`, chame uma vez a ferramenta `scaffold` com `example` definido como `nginx-gateway` e sem `dir`: esta escreve o exemplo numa nova pasta `nginx-gateway`. Em seguida, chame a ferramenta `build` uma vez para cada Release, por esta ordem — `release-compose.yaml` e `release-helm-synth.yaml` — de cada vez com `workspace_root` definido como `nginx-gateway`, `release` definido como esse ficheiro, `auto_pull` definido como true e `write` definido como true. Indique-me que ficheiros cada compilação escreveu; encontram-se em `nginx-gateway/dist/`.

Como é o upstream injetado

No Compose, o serviço do gateway executa o NGINX com um bloco server que aponta para o nome de serviço do compose e para a porta do backend:

server { listen 8000; location / { proxy_pass http://web:8080; } }

No Kubernetes, o mesmo encaminhamento chega ao comando do contentor que escreve a configuração do servidor antes de iniciar o nginx, apontando para o Service do backend — o fornecedor helm dá-lhe o nome do backend e da sua chave de serviço default:

server { listen 8080; location / { proxy_pass http://web-default:8080; } }

Ambos derivam da mesma aresta do Aggregate — o host e a porta do backend viajam pelo uso upstream, e cada destino renderiza-os no seu próprio idioma.

Executá-lo (Compose)

Terminal window
aggrega build --release release-compose.yaml --auto-pull
docker compose -f dist/app/compose/docker-compose.yaml up -d

Abra http://localhost:8000 — o NGINX reencaminha o pedido para o backend. Para desmontar, execute docker compose -f dist/app/compose/docker-compose.yaml down.