O tutorial do ASP.NET Core Kubernetes será abordado nesta postagem do blog, como uma continuação do Microsserviços ASP.NET Core: Primeiros passos.
Acabei de ver isso e me fez rir MUITO MAIS do que provavelmente deveria. pic.twitter.com/R1wleGZM0B
- Carmen Crincoli - @crincoli.org (@CarmenCrincoli) 6 de agosto de 2019
Na postagem anterior do blog, um microsserviço ASP.NET Core usando o Couchbase foi criado usando o docker-compose para fins de implantação local e desenvolvimento. Uma vez prontos para produção, os serviços são frequentemente implantados em serviços gerenciados do Kubernetes, como AKS, EKS, GKEetc.
Este tutorial do ASP.NET Core Kubernetes contém algumas etapas que são específicas do Azure AKS, mas a maior parte desse material pode ser aplicada a qualquer cluster do Kubernetes.
Visão geral do tutorial do ASP.NET Core Kubernetes
Neste tutorial do ASP.NET Core Kubernetes, examinarei essas etapas:
- Crie uma imagem do Docker e envie-a para o hub do Docker
- Criar um cluster AKS no Azure
- Implantar um microsserviço ASP.NET Core no AKS
- Implante o Couchbase Server nele usando um operador do Kubernetes
Além disso, abordarei alguns tópicos opcionais, mas muito úteis:
- Usar o DNS SRV para permitir que o microsserviço ASP.NET Core localize seu banco de dados
- Configuração do encaminhamento de porta com o kubectl para obter acesso de túnel aos pods do AKS
- Exibindo o painel do Kubernetes no AKS
- Configuração de um serviço de balanceador de carga no Kubernetes para expor o microsserviço ASP.NET Core à Internet
Pré-requisitos para aproveitar ao máximo este tutorial:
- Docker instalado, algum conhecimento básico do Docker e do Docker Hub
- Visual Studio instalado, embora isso não seja estritamente necessário
- Uma conta do Azure (se não tiver uma, você pode Inscreva-se agora e ganhe $200 em crédito gratuitamente). Se quiser usar o EKS, o GKE etc., você ainda poderá seguir este tutorial, mas precisará substituir algumas etapas por conta própria.
- kubectl (para Kubernetes) instalado
Criar imagem do Docker
As implantações do Kubernetes usam imagens de contêineres. Há muitas opções para registros de contêineres privados (como Registro de contêineres do Azure), mas para manter as coisas simples neste tutorial, usarei o velho e simples Docker Hub.
Primeiro, começarei criando uma imagem do Docker a partir do microsserviço ASP.NET Core que criei na postagem anterior do blog. No Visual Studio, isso é tão fácil quanto clicar com o botão direito do mouse no Dockerfile e selecionar "Build Docker Image".
Depois que a imagem for criada, ela aparecerá em seu repositório local de imagens do Docker. Você pode ver esse repositório na linha de comando usando "docker images":
|
1 2 3 4 |
PS C:\Usuários\mgroves> doca imagens REPOSITÓRIO TAG IMAGEM ID CRIADO TAMANHO mattgroves/hellomicroservice mais recente b2387e47a826 3 semanas atrás 213 MB hellomicroservice mais recente b2387e47a826 3 semanas atrás 213 MB |
A próxima etapa é enviar essa imagem para o hub do Docker (revise se você não tiver usado o Docker Hub antes). Enviei minha imagem para o Docker com o comando docker push mattgroves/hellomicroservice comando. Você provavelmente desejará marcar suas imagens com números de versão para garantir que o Kubernetes esteja puxando a versão exata que você deseja implantar.
Se quiser pular esta etapa, você pode usar minha imagem do Docker como exemplo: mattgroves/hellomicroservice.
Escreva arquivos YAML para implantação
Agora que você publicou uma imagem do Docker, podemos começar a escrever os arquivos YAML para uma implantação do Kubernetes. Este tutorial não abordará tudo o que há para saber sobre o Kubernetes, mas indicará seções dignas de nota, tanto quanto possível. Para este tutorial, serão criados três arquivos YAML no total para serem usados junto com os arquivos YAML que acompanham o Couchbase Operator.
Cada um desses arquivos YAML corresponde a um recurso do Kubernetes. O Kubernetes orquestrará o cluster com base nos recursos que você criar no cluster.
O recurso ASP.NET Core Microservice e o recurso Couchbase Cluster resultarão, cada um, em um ou mais "pods" sendo criados no cluster do Kubernetes. Outros tipos de recursos são "segredos" (para gerenciar e armazenar informações confidenciais) e "serviços" (para expor um conjunto de pods) e muitos outros.
Microsserviço ASP.NET Core
Vamos começar criando um arquivo YAML para a própria implantação do microsserviço do ASP.NET Core:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
Versão da API: aplicativos/v1beta1 # para versões anteriores à 1.8.0 use apps/v1beta1 gentil: Implantação metadados: nome: Olá-microsserviço-aplicativo-implantação especificação: seletor: matchLabels: aplicativo: Olá-microsserviço-aplicativo réplicas: 1 # informa à implantação para executar pods # que correspondam ao modelo modelo: # criar pods usando a definição de pod neste modelo metadados: rótulos: aplicativo: Olá-microsserviço-aplicativo especificação: contêineres: - nome: Olá-microsserviço-aplicativo imagem: mattgroves/hellomicroservice imagePullPolicy: Sempre portos: - containerPort: 80 nome: servidor env: - nome: Nome de usuário do Couchbase valueFrom: secretKeyRef: nome: cb-hellomicroservices-autenticação chave: nome de usuário - nome: Senha do Couchbase valueFrom: secretKeyRef: nome: cb-hellomicroservices-autenticação chave: senha - nome: Couchbase__ConnectionString valor: couchbase://cb-hellomicroservices-srv recursos: solicitações: CPU: 100m memória: 128Mi limites: CPU: 250m memória: 256Mi |
Observações sobre o hello-microservice.yaml:
spec.replicas: Isso informa ao Kubernetes quantos pods desse serviço devem ser criados. Para começar, 1 é suficiente, mas, à medida que você for escalando, precisará de mais pods (e provavelmente de um LoadBalancer, que será abordado mais tarde).spec.template.spec.containers.image: Isso informa ao Kubernetes quais imagens usar. No meu caso, mattgroves/hellomicroservice é a que foi criada anteriormente neste tutorial e implantada no Docker hubenv: Definem variáveis de ambiente para cada contêiner. Em vez de codificar essas credenciais na imagem, estou passando um nome de usuário, uma senha e uma ConnectionString para o microsserviço ASP.NET Core, da mesma forma que foi feito na postagem anterior do blog. Mais informações sobre o Couchbase__ConnectionString e o DNS SRV mais adiante.- Você também pode usar "service.namespace" se o cluster do Couchbase estiver em outro namespace.
Cluster do Couchbase
Em seguida, aqui está um arquivo YAML para o banco de dados, que usa o Operador de Kubernetes do Couchbase:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
Versão da API: couchbase.com/v1 gentil: CouchbaseCluster metadados: nome: cb-hellomicroservices especificação: imagem de base: couchbase versão: 6.5.0-beta2 authSecret: cb-hellomicroservices-autenticação exposeAdminConsole: verdadeiro adminConsoleServices: - dados agrupamento: DataServiceMemoryQuota: 256 indexServiceMemoryQuota: 256 searchServiceMemoryQuota: 256 eventingServiceMemoryQuota: 256 analyticsServiceMemoryQuota: 1024 indexStorageSetting: plasma autoFailoverTimeout: 30 autoFailoverMaxCount: 3 autoFailoverOnDataDiskIssues: verdadeiro autoFailoverOnDataDiskIssuesTimePeriod: 30 autoFailoverServerGroup: falso baldes: - nome: hellomicroservice tipo: couchbase memoryQuota: 256 réplicas: 0 ioPrioridade: alta evictionPolicy (política de despejo): fullEviction Resolução de conflitos: seqno enableFlush: falso enableIndexReplica: falso servidores: - tamanho: 1 nome: todos_serviços serviços: - dados - índice - consulta |
Esse arquivo YAML, por si só, não é suficiente para usar o Operator, mas a instalação do Operator virá mais adiante neste tutorial. Observe também que, embora o padrão Operator seja uma maneira cada vez mais comum e eficaz de gerenciar software com estado no Kubernetes, o YAML varia de acordo com o banco de dados que você está usando (ou seja, esse YAML só funcionará para o Couchbase Server).
Observações sobre couchbase-cluster.yaml:
spec.versionespecifica a imagem do contêiner do Couchbase a ser usada. Estou usando a versão beta2. No momento em que escrevo este texto, o operador só funciona com a versão Enterprise. Isso pode mudar em breve.spec.cluster,spec.buckets,servidores de especificações: definem várias configurações para o cluster do Couchbase Server. Favor Consulte a documentação para obter a listagem completa de configurações. Este arquivo de exemplo abrange apenas algumas delas.
"Segredos" do Couchbase
Também criei um recurso "secreto". Os segredos são onde as informações de configuração, como credenciais, senhas, tokens de autorização etc., podem ser armazenadas e gerenciadas com a própria API do Kubernetes.
|
1 2 3 4 5 6 7 8 |
Versão da API: v1 gentil: Secreto metadados: nome: cb-hellomicroservices-autenticação tipo: Opaco dados: nome de usuário: QWRtaW5pc3RyYXRvcg== Administrador # senha: cGFzc3dvcmQ= Senha # |
Esse segredo contém as credenciais que desejo que o Couchbase (bem como o microsserviço ASP.NET Core) use. Os valores são codificados em base64 (valores reais nos comentários). Essas credenciais de exemplo NÃO são suficientes para uma implantação real: altere-as para algo mais difícil de adivinhar.
Observe o metadados.nome é "cb-hellomicroservices-auth". Consulte hello-microservice.yaml e couchbase-cluster.yaml para ver como esses segredos são referenciados.
DNS SRV
Consulte novamente o arquivo hello-microservice.yaml. Sob envObserve o par nome/valor de "Couchbase__ConnectionString" e "couchbase://cb-hellomicroservices-srv". Em vez de fornecer o endereço IP do ASP.NET Core ou os URLs dos nós do Couchbase Server, estou usando uma string de conexão para direcioná-lo a um Entrada SRV do DNS.
Em um cluster do Couchbase, os pods reais que executam o Couchbase têm a possibilidade de alterar seus nomes regularmente. Portanto, é recomendável usar o DNS SRV para localizar o serviço do Couchbase. Felizmente, o Operador Autônomo do Couchbase cria automaticamente uma entrada DNS SRV para nós.
Em breve, poderemos vê-lo no Kubernetes Dashboard, mas, enquanto isso, observe que ele será o nome do cluster do Couchbase mais "-srv". Portanto, no nosso caso, é "cb-hellomicroservices-srv".
Fiz uma pequena alteração no microsserviço ASP.NET Core desde a postagem anterior no blog: Agora estou usando o Couchbase.Extensions.DnsDiscovery biblioteca.
Além de adicionar essa biblioteca do NuGet e usar ConnectionString em vez de Server no arquivo appsettings.json, a única outra alteração que precisa ser feita é AddCouchbaseDnsDiscovery dentro do ConfigureServices método.
|
1 2 |
serviços.AddCouchbase(Configuração.GetSection("Couchbase")); serviços.AddCouchbaseDnsDiscovery(); |
É tão fácil quanto isso. Para saber mais sobre o DNS SRV, consulte Registros SRV na documentação do Kubernetes.
Implantação no AKS
Neste ponto, estamos prontos para implementar o AKS. Para revisar, aqui estão os ingredientes que temos até agora:
- Imagem do Docker do ASP.NET Core no Docker Hub
- Arquivo YAML para a implantação do ASP.NET Core
- Arquivo YAML para a implantação do cluster do Couchbase
- Arquivo YAML para os segredos do Couchbase (referenciado por 2 e 3)
Para implantar no AKS, segui os passos Início rápido: Implantar um cluster do Serviço Kubernetes do Azure usando a CLI do Azure na documentação da Microsoft. Aqui está um breve resumo das etapas que segui:
(Se quiser usar sua linha de comando local, verifique se você tem azure-cli instalado. Caso contrário, você pode usar o Shell de nuvem do Azure).
Primeiro, faça login no Azure: login az. Você será solicitado a inserir suas credenciais no navegador da Web.
Depois de fazer o login, primeiro crie um "grupo de recursos". Esse é um grupo organizacional dentro do Azure. Especifique um data center (eu usei eastus).
az group create --name helloMicroserviceGroup --location eastus
Em seguida, crie um cluster AKS usando o grupo de recursos que você acabou de criar. Há muitas opções para isso. Para manter esse exercício relativamente simples e de baixo custo, optei por criar 3 nós usando o tamanho de VM Standard_B2s. Para implementações de produção do Couchbase, você provavelmente precisará/quererá tamanhos mais potentes.
az aks create --resource-group helloMicroserviceGroup --name helloMicroserviceAks --node-count 3 --node-vm-size Standard_B2s --enable-addons monitoring --generate-ssh-keys
Esta etapa levará algum tempo para ser executada. Espere que o Azure leve cerca de 10 minutos para configurar esse cluster do Kubernetes AKS.
Depois que o cluster for criado, use obter credenciais para permitir que o kubectl saiba qual cluster ele usará.
az aks get-credentials --resource-group helloMicroserviceGroup --name helloMicroserviceAks
Nesse ponto, é hora de criar alguns recursos do Kubernetes. Os primeiros seis arquivos YAML podem ser baixados em "Kubernetes" couchbase.com/downloads.
|
1 2 3 4 5 6 |
kubectl criar -f crd.yaml kubectl criar -f admissão.yaml kubectl criar -f operador-função.yaml kubectl criar -f operador-serviço-conta.yaml kubectl criar -f operador-função-vinculação.yaml kubectl criar -f operador-implantação.yaml |
Em seguida, use os três arquivos YAML que foram criados neste tutorial:
|
1 2 3 |
kubectl criar -f segredo.yaml kubectl criar -f couchbase-agrupamento.yaml kubectl criar -f Olá-microsserviço.yaml |
Para ver o estado de seus pods do Kubernetes, use kubectl get pods. Os pods do Couchbase levarão alguns minutos para ficarem prontos.
Encaminhamento de portas
Na implantação acima, nenhuma das implantações do Kubernetes está realmente exposta fora do Kubernetes. Uma maneira de verificar se o microsserviço está funcionando é usar a função kubectl port-forward comando. Isso criará um "túnel" localhost para o pod fornecido.
Por exemplo, vamos criar um túnel da porta 5000 do host local para o microsserviço ASP.NET Core em execução na porta 80:
kubectl port-forward 5000:80
Neste ponto, você pode acessar o microsserviço usando http://locahost:5000 em seu navegador.
Da mesma forma, você pode configurar um túnel para a interface de usuário integrada do Couchbase Server baseada na Web:
kubectl port-forward cb-hellomicroservices-0000 8091:8091
E agora você pode acessar o cluster do Couchbase usando http://localhost:8091.
O comando port-forward pode ser útil para desenvolvedores e operações, mas continue lendo para ver como expor um serviço do Kubernetes à Internet.
Expor o serviço com o balanceador de carga
Embora o encaminhamento de portas possa nos dar acesso a pods fora do cluster do Kubernetes, o que acontece quando os pods inevitavelmente travam, morrem e renascem com novos endereços IP, nomes de pods etc.? O Kubernetes nos permite criar "serviços" para endereçar um ou mais pods logicamente.
Um serviço pode ser especificado nos arquivos YAML, assim como as implementações.
Um serviço também pode ser criado usando kubectl expose. Por exemplo, posso expor um serviço de balanceador de carga que fornece acesso a quantos pods do ASP.NET Core minha implantação tiver criado:
kubectl expose deployments hello-microservice-app-deployment --port=80 --type=LoadBalancer
Quando o serviço for criado, ele criará um endereço IP externo. Você pode visualizar as informações do serviço com kubectl get services.
|
1 2 3 4 5 6 7 8 |
PS C:\Usuários\mgroves> kubectl obter serviços NOME TIPO CLUSTER-IP EXTERNO-IP PORTO(S) IDADE cb-hellomicroservice ClusterIP Nenhum <nenhum> 8091/TCP,18091/TCP 17d cb-hellomicroservice-srv ClusterIP Nenhum <nenhum> 11210/TCP,11207/TCP 17d cb-hellomicroservice-ui NodePort 10.0.194.12 <nenhum> 8091:30624/TCP,18091:31169/TCP 17d couchbase-operador-admissão ClusterIP 10.0.218.95 <nenhum> 443/TCP 17d kubernetes ClusterIP 10.0.0.1 <nenhum> 443/TCP 17d Olá-microsserviço-aplicativo-implantação Balanceador de carga 10.0.6.87 20.NN.NN.21 80:32710/TCP 13s |
Abra esse endereço IP em um navegador da Web (20.NN.NN.21 no meu exemplo), e ele terá acesso balanceado de carga aos pods em sua implantação. À medida que você aumentar ou diminuir a escala (ou seja, alterar o número de réplicas), o serviço permanecerá o mesmo e continuará a fornecer acesso.
Painel do Kubernetes
O Kubernetes tem seu próprio painel de interface do usuário, que pode ser útil para obter uma visualização do panorama geral sem precisar se lembrar de vários comandos de linhas de comando. Para acessar o Painel do Kubernetes para AKS:
Crie um ClusterRoleBinding para o painel do Kubernetes para permitir o acesso:
kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard
Em seguida, use o aks browse do Azure para iniciar o painel:
az aks browse --resource-group helloMicroserviceGroup --name helloMicroserviceAks
Isso também deve acionar automaticamente seu navegador da Web para abrir o painel:
No painel, você pode visualizar todos os pods, serviços, segredos, nós e muito mais.
Próximas etapas
Se você estiver acompanhando o AKS, não se esqueça de remover o grupo de recursos quando terminar. Caso contrário, ele continuará a ser executado na sua conta do Azure e cobrará pelo tempo de computação. Você pode remover todo o grupo de recursos deste tutorial com um único comando:
az group delete --name helloMicroserviceGroup
Este tutorial do ASP.NET Core Kubernetes abordou uma grande quantidade de assuntos, mas esperamos que seja o suficiente para indicar a direção certa e fazer com que você comece com um exemplo de "Olá, mundo".
Como na última postagem do blog, este tutorial do ASP.NET Core Kubernetes é um produto de algumas transmissões de codificação ao vivo no Twitch. Você pode ver Parte 1 e Parte 2 no YouTube. E, se tiver dúvidas, você pode visitar o transmissão ao vivo no Twitch Na próxima vez e converse!
O Kubernetes é um tópico muito amplo. Há muitas direções que você poderia seguir a partir daqui. Aqui estão alguns links que você pode querer conferir:
-
Este tutorial usa a versão 1.2 do operador do Kubernetes do Couchbase. O YAML para a versão 2.0 (em breve) será diferente.
-
Do meu colega Denis Rosa, Microsserviços no Kubernetes e sua postagem no blog sobre Criação de microsserviços elásticos com Kubernetes e Spring Boot
-
De Kubernetes:
-
Conexão de aplicativos com serviçosque menciona o LoadBalancer
-
Lembrete de que este tutorial do ASP.NET Core Kubernetes é uma continuação da minha postagem anterior, link:https://www.couchbase.com/blog/asp-net-core-microservices-getting-started/
[ASP.NET Core Microservices: Getting Started]. Se você ainda não leu isso, talvez esteja perdendo algum contexto. -
A Twilio também publicou um postagem de blog semelhante há alguns meses, que usa o Registro de Contêineres do Azure.
