MARA: Agora em execução em uma estação de trabalho perto de você

Quando começamos a trabalhar no projeto NGINX Modern Apps Reference Architecture (MARA), escolhemos a AWS como nosso provedor de IaaS porque já estávamos familiarizados com a plataforma e poderíamos usar nosso orçamento departamental para pagar por ela. Nem todo mundo tem a mesma experiência ou orçamento, é claro, e muitos de vocês nos pediram para fornecer opções para executar o MARA localmente – em um ambiente de laboratório ou mesmo em uma estação de trabalho – com distribuições Kubernetes como K3s , Canonical MicroK8s e minikube .

Ouvimos você e hoje temos o prazer de anunciar que testamos o MARA no MicroK8s e estamos fornecendo instruções para que você mesmo possa implantá-lo!

Por que escolhemos o MicroK8s para nossos testes? Porque ele fornece os recursos de DNS, armazenamento e saída que o MARA precisa, em um modelo fácil de implantar e com baixo consumo de memória. Com o MicroK8s, podemos iterar de forma fácil e repetida por cenários de teste para determinar os requisitos mínimos para implantações que oferecem níveis razoáveis de desempenho.

Nossa expectativa é que esse trabalho facilite nossos testes de outras distribuições do Kubernetes; para obter informações sobre o status atual de várias distribuições, consulte nosso repositório no GitHub . Se você tiver uma distribuição favorita que queira ver na lista, convidamos você a bifurcar, testar e criar solicitações de pull!

Lidando com Restrições de Recursos

As maiores restrições para executar o MARA localmente são memória e CPU. Durante os testes preliminares, descobrimos que a maior parte dos problemas com exaustão de memória diziam respeito ao Elasticsearch. O Kibana é quase inutilizável em configurações com uma quantidade extremamente pequena de memória (menos de 16 GB ). Para resolver esse problema, fornecemos configurações no arquivo de configuração MARA que eliminam as proteções de redundância que uma implantação completa do Elasticsearch normalmente tem. Embora isso aumente o número de modos de falha, é uma compensação necessária em ambientes com recursos limitados.

Restrições na CPU estão diretamente ligadas à quantidade de carga imposta em nosso aplicativo de exemplo Bank of Sirius . A implantação do MARA inclui o Locust para gerar carga no Bank of Sirius, com configurações controladas pelo usuário para o número de usuários e a taxa de geração de novos usuários.

Observe que aumentar a carga no Bank of Sirius também afeta o resto do sistema. Se a contagem de usuários ou a taxa de geração for muito alta, o desempenho do MARA será reduzido a ponto de os componentes provavelmente travarem ou paralisarem. Os valores que causam esse comportamento dependem da CPU disponível, mas você pode esperar uma implantação com pelo menos a capacidade especificada em Requisitos para lidar com a carga criada por até 64 usuários e uma taxa de abrangência de 16 usuários por vez.

Implementando MARA em MicroK8s

Com esse pano de fundo resolvido, você está pronto para montar MARA no MicroK8s!

Requisitos

• acesso root em um sistema (servidor Linux bare-metal, virtualizado ou nuvem) executando Ubuntu 20.04 (Focal) ou posterior, com no mínimo:

  • Disco de 20 GB
  • 16 GB de memória
  • O equivalente a 4 CPUs

• Um ambiente virtual Python 3 no sistema local com todas as bibliotecas e binários necessários pelo MARA. Se o Python 3 ainda não estiver instalado, execute estes comandos:

  $ sudo apt update $ sudo apt install -y python3-venv

• Pelo menos um endereço IPv4 livre para o balanceador de carga MetalLB integrado do MicroK8s para atribuir à saída do NGINX Ingress Controller. Se você estiver acessando o aplicativo Bank of Sirius via localhost, qualquer endereço privado disponível (compatível com RFC 1918 ) será aceitável. Por exemplo, se sua rede for 192.168.100.0/24, você pode usar um endereço como 10.10.10.10.

• Uma conta Pulumi e token de acesso. Se você ainda não os tiver, você os criará na Etapa 1 de Implantar MARA .

  Observe que, embora o Pulumi permita que você armazene o arquivo de estado em um armazenamento de objetos compatível com S3 ou no sistema de arquivos local, o MARA não oferece suporte a isso no momento da redação deste artigo. Essa limitação será removida em uma versão futura do MARA ou Pulumi.

Instalar e configurar o MicroK8s

1. Instalar MicroK8s:

   $ sudo snap install microk8s --classic microk8s (1.23/stable) v1.23.3 da Canonical✓ instalado

2. Defina as permissões necessárias para executar comandos microk8s . Para <nome de usuário>, substitua sua conta que tem raiz privilégio no sistema:

   $ sudo usermod -a -G microk8s <nome de usuário>$ sudo chown -f -R <nome de usuário> ~/.kube
   $ novo grp microk8s

3. Saia da sua conta com privilégios de root e entre novamente para que as novas permissões entrem em vigor.

4. Habilite os complementos MicroK8s para DNS , armazenamento e MetalLB .

   No prompt, especifique um intervalo de endereços IP no formato X . X . X . X ‑ X . X . X . Y para representar:

   • Um intervalo real de endereços IP privados (por exemplo,192.168.100.100-192.168.100.110 , o valor usado abaixo)
   • Um único endereço IP privado (por exemplo,192.168.100.100-192.168.100.100 )

   $ microk8s enable dns storage metallb Habilitando DNS Aplicando manifesto ...
   Reiniciar o DNS do kubelet está habilitado Habilitando a classe de armazenamento padrão ...
   O armazenamento estará disponível em breve Habilitando o MetalLB Insira cada intervalo de endereço IP delimitado por vírgula (por exemplo '10.64.140.43-10.64.140.49,192.168.0.105-192.168.0.111'): 192.168.100.100-192.168.100.110
   Aplicando o manifesto Metallb ...
   MetalLB está habilitado

5. Confirme se o MicroK8s está em execução:

   $ microk8s status microk8s está em execução alta disponibilidade: nenhum nó mestre de armazenamento de dados: 127.0.0.1:19001 nós de espera do datastore: nenhum complementos: habilitado: dns # CoreDNS ha-cluster # Configurar alta disponibilidade no nó atual metallb # Balanceador de carga para o armazenamento do cluster Kubernetes # Classe de armazenamento; aloca armazenamento do diretório do host ...

6. Carregue a configuração do MicroK8s no arquivo onde a maioria dos utilitários espera encontrá-lo ( ~/.kube/config ) e defina as permissões recomendadas no diretório e no arquivo:

   $ microk8s configuração > ~/.kube/config $ sudo chmod 0644 ~/.kube/config

Clone o repositório MARA e configure o cluster MicroK8s

1. Clone o repositório MARA e inicialize o submódulo Bank of Sirius:

   $ git clone https://github.com/nginxinc/kic-reference-architectures.git $ cd kic-reference-architectures/ $ git submodule update --init --recursive --remote

2. Trabalhando no diretório raiz do repositório MARA clonado (você alterou o diretório lá na etapa anterior), configure o ambiente virtual Python para o cluster MicroK8s:

   $ ./bin/setup_venv.sh

   Este comando gera um rastreamento longo. Se houver erros, verifique a seção Problemas conhecidos/Advertências no repositório MARA GitHub para obter sugestões.

3. Ative o ambiente virtual Python. O comando define seu PATH e outras variáveis de ambiente para usar o ambiente virtual:

   $ source ./pulumi/python/venv/bin/activate

4. Confirme se o cluster MicroK8s está configurado corretamente para a implantação MARA:

   $ ./bin/testcap.sh Este script executará testes na instalação atual do Kubernetes usando a configuração e o contexto do Kubernetes atualmente ativos.
   Quaisquer falhas devem ser investigadas, pois indicarão que a instalação não atende ao conjunto mínimo de recursos necessários para executar o MARA. ... ============================================================== | Todos os testes foram aprovados! Este sistema atende aos requisitos básicos | | para implantar MARA. | ==================================================================

Implantar MARA

O script start.sh , usado nesta seção para implantar o MARA, acomoda opções que exigem ações adicionais para que a implantação seja bem-sucedida. Para simplificar, aqui assumimos uma implantação básica que:

• Usa arquivos kubeconfig em vez de uma das outras opções de implantação suportadas. Para obter detalhes sobre as outras opções, consulte o Guia de primeiros passos em nosso repositório GitHub.
• Usa a versão mais recente do NGINX Open Source com a qual testamos o MARA (não necessariamente a versão mais recente).
• Usa o NGINX Ingress Controller baseado no NGINX Open Source. Se você quiser usar o NGINX Ingress Controller baseado no NGINX Plus, deverá usar uma imagem baseada no NGINX Plus do registro do F5 Docker no seu cluster Kubernetes. Veja o primeiro AVISO! na Etapa 3 abaixo para mais informações.
• Usa um único contexto padrão do Kubernetes. Veja o segundo AVISO! no Passo 3.

Implante o MARA no cluster MicroK8s:

1. Execute o script start.sh .

   Se você ainda não configurou sua estação de trabalho para usar o Pulumi, você será direcionado a efetuar login no Pulumi (criando uma conta, se necessário) e então será solicitado o token de API associado à sua conta Pulumi.

   $ ./bin/start.sh Adicionando [/home/ubuntu/kic-reference-architectures/bin/venv/bin] ao PATH Gerencie suas pilhas Pulumi fazendo login.
   Execute `pulumi login --help` para opções alternativas de login.
   Insira seu token de acesso em https://app.pulumi.com/account/tokens
   ou pressione <ENTER> para efetuar login usando seu navegador: <símbolo>
   
   Leia a documentação para mais detalhes.

2. Selecione o tipo de implantação, digitando k no prompt para construir a implantação com arquivos kubeconfig. Ignore os avisos sobre o make e o Docker não estarem instalados – a implantação usa uma imagem do NGINX Ingress Controller de um registro.

   Digite a para AWS, k para kubeconfig? k Chamando o script de inicialização do kubeconfig make não está instalado - ele deve ser instalado se você pretende compilar o NGINX Kubernetes Ingress Controller a partir da origem. docker não está instalado - ele deve ser instalado se você pretende compilar o NGINX Kubernetes Ingress Controller a partir da origem.

3. No prompt, especifique o nome da pilha Pulumi a ser criada (aqui, mara ). Deve ser exclusivo na sua conta Pulumi.

   Insira o nome da pilha Pulumi a ser usada em todos os projetos: mara Fonte do submódulo encontrada Configurando todos os projetos Pulumi para usar a pilha: mara Pilha criada 'mara' AVISO! Atualmente, a implantação via kubeconfig só oferece suporte à extração de imagens do registro! Um JWT é necessário para acessar o repositório NGINX Plus. Isso deve ser colocado em um arquivo no diretório extras na raiz, em um arquivo chamado jwt.token. Veja https://docs.nginx.com/nginx-ingress-controller/installation/using-the-jwt-token-docker-secret/ para mais detalhes e exemplos.
   
   Nenhum JWT encontrado; escrevendo manifesto de espaço reservado AVISO! Ao usar um arquivo kubeconfig, você precisa garantir que seu ambiente esteja configurado para se conectar ao Kubernetes corretamente. Se você tiver vários contextos do Kubernetes (ou contextos personalizados), talvez seja necessário removê-los e substituí-los por um arquivo simples ~/.kube/config. Isso será abordado em uma versão futura.

4. Nos prompts, especifique o caminho completo para o arquivo kubeconfig e o nome do cluster. Aqui estão eles /lar/<nome de usuário>/.kube/config e microk8s-agrupamento.

   Forneça um caminho absoluto para o seu arquivo kubeconfigvalue: /lar/<nome de usuário>/.kube/config
   Forneça o valor do seu clustername
   : microk8s-agrupamento
   Tentando conectar ao cluster kubernetes

5. Especifique o nome de domínio totalmente qualificado (FQDN) para o cluster no próximo prompt. O script usa o FQDN para duas finalidades: configurar o NGINX Ingress Controller e criar o certificado autoassinado (o segundo uso significa que o valor não pode ser um endereço IP). Se você substituir um FQDN diferente por mara.example.com , lembre-se de usá-lo também nas etapas a seguir.

Crie um fqdn para seu deploymentvalue: mara.example.com

6. Especifique a senha do administrador do Grafana:

   Crie uma senha para o usuário administrador do Grafana; essa senha será usada para acessar o painel do Grafana. Deve ser uma sequência alfanumérica sem nenhum caractere especial do shell; ela é apresentada em texto simples devido às limitações atuais dos segredos do Pulumi. Você precisará desta senha para acessar o painel do Grafana.
   valor: <senha>

Um rastreamento do processo de instalação é exibido, exibindo as seguintes informações para cada etapa:

• Um banner descrevendo a ação principal realizada na etapa (por exemplo, o Logstore sinaliza o início da implantação do Elasticsearch)
• Uma lista das tarefas que Pulumi irá realizar
• Um indicador de status em tempo real para cada tarefa Pulumi
• Diagnósticos gerados por Pulumi e MARA, por exemplo, o nome do host e o endereço IP definidos
• O número de recursos afetados
• O tempo decorrido

Quando a etapa final (para o Bank of Sirius) for concluída, o rastreamento relatará o endereço IP atribuído ao NGINX Ingress Controller pelo MetalLB (aqui192.168.100.100 ) e o FQDN que você escolheu para a implantação (aqui mara.example.com ), juntamente com outras informações sobre a implantação.

O processo de inicialização foi concluído com sucesso
Próximos passos:
1. Mapeie o endereço IP (192.168.100.100) do seu Ingress Controller com seu FQDN (mara.example.com).
2. Use o programa ./bin/test-forward.sh para estabelecer túneis que você pode usar para se conectar às ferramentas de gerenciamento.
3. Use kubectl, k9s ou o painel do Kubernetes para explorar sua implantação.

Para revisar suas opções de configuração, incluindo as senhas definidas, você pode acessar os segredos do pulumi por meio dos seguintes comandos:

Configuração principal: pulumi config -C /jenkins/workspace/jaytest/bin/../pulumi/python/config

Configuração do Bank of Sirius (aplicativo de exemplo): pulumi config -C /jenkins/workspace/jaytest/bin/../pulumi/python/kubernetes/applications/sirius

IP do balanceador de carga K8: kubectl get services --namespace nginx-ingress

Consulte a documentação no repositório do github para obter mais informações

7. Crie um mapeamento entre o FQDN e o endereço IP relatados na etapa anterior, na ferramenta que você usa para resolver FQDNs (como o arquivo local /etc/hosts ou o servidor DNS).

8. Verifique se uma solicitação para a implantação MARA foi bem-sucedida. Inclua a opção -k para que o curl aceite um certificado autoassinado. Para exibir mais informações sobre o certificado, adicione a opção -v .

   $ curl -k -I https://mara.example.com HTTP/1.1 200 OK Servidor: nginx/1.21.5 Data: Dia , DD Seg AAAA hh:mm:ss TZ Tipo de conteúdo: text/html; charset=utf-8 Comprimento do conteúdo: 7016 Conexão: keep-alive

9. Navegue em um navegador até https://mara.example.com para exibir o site do Bank of Sirius. No momento em que este artigo foi escrito, com muitos navegadores (incluindo Firefox e Safari), você pode clicar com segurança no aviso que aparece sobre o site usando um certificado autoassinado. Recomendamos que você não use o Chrome – devido às recentes mudanças de segurança, é provável que ele proíba você de acessar o site.

10. Execute o script test-forward.sh para configurar o encaminhamento de porta do Kubernetes para que você possa acessar as ferramentas no pacote de gerenciamento MARA – Elasticsearch , Grafana , Kibana , Locust e Prometheus . O script determina os nomes de serviço apropriados e executa comandos kubectl para encaminhá-los para portas locais.

    Observação:  Para que o encaminhamento de porta funcione corretamente, seu navegador deve estar sendo executado no mesmo sistema que o shell de comando onde você executa este comando. Caso contrário (porque você está usando um ambiente de virtualização, por exemplo), o comando parece ter sucesso, mas o encaminhamento de porta não funciona. Para obter mais informações, consulte Acessando as ferramentas de gerenciamento no MARA em nosso repositório do GitHub.

    $ ./bin/test-forward.sh Detalhes das conexões ===================================== Kibana: http://localhost:5601 Grafana: http://localhost:3000 Locust: http://localhost:8089 Prometheus: http://localhost:9090 Elasticsearch: http://localhost:9200 ====================================== Emita Ctrl-C para sair

Resumo

É isso! Com essas instruções, uma implantação MARA funcional estará pronta e funcionando em seu ambiente em cerca de 20 minutos. Neste ponto, você pode interagir com o aplicativo Bank of Sirius como qualquer outro aplicativo Kubernetes. Um bom lugar para começar é usar as ferramentas de observabilidade integradas para testar como o ambiente se comporta à medida que você gera diferentes quantidades de carga com o Locust.

Nosso objetivo é tornar o MARA o mais útil possível para o maior número possível de usuários do Kubernetes. Não gostou das escolhas que fizemos para alguns dos componentes? Recomendamos que você substitua seus componentes e abra uma solicitação de pull se quiser compartilhar. Além disso, compartilhe suas ideias e faça perguntas — inclusive sobre quaisquer suposições questionáveis que fizemos — nas páginas de Problemas e Discussões em nosso repositório.

Postagens relacionadas

Esta postagem faz parte de uma série. À medida que adicionamos recursos ao MARA ao longo do tempo, publicamos os detalhes no blog:

• Uma nova arquitetura de referência de aplicativos modernos de código aberto
• Integrando OpenTelemetry na Arquitetura de Referência de Aplicativos Modernos – Um Relatório de Progresso
• MARA: Agora em execução em uma estação de trabalho perto de você (esta postagem)
• Anunciando a versão 1.0.0 da arquitetura de referência de aplicativos modernos do NGINX