1. Visão geral
O ASP.NET Core é um novo framework de código aberto e multiplataforma para criação de aplicativos modernos baseados em nuvem e conectados à Internet usando a linguagem de programação C#.
O Kubernetes é um projeto de código aberto que pode ser executado em diversos ambientes, de laptops a clusters com vários nós de alta disponibilidade, de nuvens públicas a implantações locais e de máquinas virtuais a bare metal.
Neste laboratório, você implantará um aplicativo simples do ASP.NET Core no Kubernetes em execução no Kubernetes Engine. Este codelab tem como base o Criar e iniciar o app ASP.NET Core no Google Cloud Shell. É recomendável fazer isso antes de começar este.
O objetivo deste codelab é transformar seu código (um simples app Hello World ASP.NET Core) em um aplicativo replicado executado no Kubernetes. Você pega o código que desenvolveu em sua máquina, o transforma em uma imagem de contêiner do Docker e, em seguida, executa essa imagem no Google Kubernetes Engine.
Veja um diagrama das várias partes deste codelab para ajudar você a entender como as peças se encaixam. Use-o como referência ao longo do codelab. tudo deverá fazer sentido quando você chegar ao fim (mas sinta-se à vontade para ignorar isso por enquanto).
Para os fins deste codelab, o uso de um ambiente gerenciado como o Kubernetes Engine (uma versão hospedada pelo Google do Kubernetes em execução no Compute Engine) permite que você se concentre mais em testar o Kubernetes, em vez de configurar a infraestrutura subjacente.
Se você estiver interessado em executar o Kubernetes no computador, como um laptop de desenvolvimento, conheça o Minikube. Ele oferece uma configuração simples de um cluster do Kubernetes de nó único para desenvolvimento e teste. Se quiser, use o Minikube para fazer este codelab.
O que você vai aprender
- Como empacotar um aplicativo simples do ASP.NET Core como um contêiner do Docker
- Como criar um cluster do Kubernetes no Google Kubernetes Engine (GKE).
- Como implantar o aplicativo do ASP.NET Core em um pod
- Como permitir tráfego externo no pod
- Como escalonar verticalmente o serviço e fazer um upgrade
- Como executar o painel gráfico do Kubernetes
O que é necessário
Como você usará este tutorial?
Como você classificaria sua experiência com o Google Cloud Platform?
2. Configuração e requisitos
Configuração de ambiente autoguiada
- Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.
- O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google Você pode atualizar a qualquer momento.
- O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser alterado após a definição. O console do Cloud gera automaticamente uma string exclusiva. normalmente você não se importa com o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, que normalmente é identificado como
PROJECT_ID. Se você não gostar do ID gerado, poderá gerar outro ID aleatório. Como alternativa, você pode tentar o seu próprio e ver se ele está disponível. Ela não pode ser alterada após essa etapa e permanecerá durante a duração do projeto. - Para sua informação, há um terceiro valor, um Número de projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.
- Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não será muito cara, se tiver algum custo. Para encerrar os recursos e não gerar faturamento além deste tutorial, exclua os recursos criados ou exclua o projeto inteiro. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.
Inicie o Cloud Shell
Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se você nunca iniciou o Cloud Shell antes, uma tela intermediária (abaixo da dobra) será exibida com a descrição dele. Se esse for o caso, clique em Continuar (e você não verá mais esse aviso). Esta é a aparência dessa tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual tem todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Praticamente todo o seu trabalho neste codelab pode ser feito em um navegador ou no seu Chromebook.
Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto já estará configurado com seu ID do projeto.
- Execute o seguinte comando no Cloud Shell para confirmar que você está autenticado:
gcloud auth list
Resposta ao comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Execute o seguinte comando no Cloud Shell para confirmar que o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
3. Crie um aplicativo do ASP.NET Core no Cloud Shell
No prompt do Cloud Shell, verifique a versão da ferramenta de linha de comando dotnet para confirmar se ela já está instalada. Isso deve imprimir a versão da ferramenta de linha de comando dotnet instalada:
dotnet --version
Em seguida, crie uma nova estrutura para o app da Web ASP.NET Core.
dotnet new mvc -o HelloWorldAspNetCore
Esse comando cria um projeto e restaura as dependências dele. Você verá uma mensagem semelhante ao exemplo abaixo.
Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.
Restore succeeded.
4. Execute o aplicativo do ASP.NET Core
Estamos quase prontos para executar o app. Navegue até a pasta do app.
cd HelloWorldAspNetCore
Por fim, execute o app.
dotnet run --urls=http://localhost:8080
O aplicativo começará a ouvir na porta 8080.
Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.
Para verificar se o app está em execução, clique no botão de visualização da Web, no canto superior direito, e selecione "Visualizar na porta 8080".
Você verá a página da Web padrão do ASP.NET Core:
Depois de verificar se o app está em execução, pressione Ctrl+C para encerrá-lo.
5. Empacote o aplicativo do ASP.NET Core como um contêiner do Docker
Em seguida, prepare o app para ser executado como um contêiner. O primeiro passo é definir o contêiner e o conteúdo dele.
No diretório base do app, crie um Dockerfile para definir a imagem Docker.
touch Dockerfile
Adicione o código a seguir a Dockerfile usando seu editor favorito (vim, nano,emacs ou o editor de código do Cloud Shell).
# Use Microsoft's official build .NET image. # https://hub.docker.com/_/microsoft-dotnet-core-sdk/ FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build WORKDIR /app # Install production dependencies. # Copy csproj and restore as distinct layers. COPY *.csproj ./ RUN dotnet restore # Copy local code to the container image. COPY . ./ WORKDIR /app # Build a release artifact. RUN dotnet publish -c Release -o out # Use Microsoft's official runtime .NET image. # https://hub.docker.com/_/microsoft-dotnet-core-aspnet/ FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime WORKDIR /app COPY --from=build /app/out ./ # Make sure the app binds to port 8080 ENV ASPNETCORE_URLS http://*:8080 # Run the web service on container startup. ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]
Uma importante configuração incluída no seu Dockerfile é a porta em que o aplicativo escuta o tráfego de entrada (8080). Isso é feito configurando a variável de ambiente ASPNETCORE_URLS, que os aplicativos do ASP.NET Core usam para determinar qual porta detectar.
Salvar esta Dockerfile. Agora, vamos criar a imagem:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Depois que o processo for concluído (o download e a extração levar um tempo), você vai perceber que a imagem foi criada e salva localmente:
docker images REPOSITORY TAG gcr.io/yourproject-XXXX/hello-dotnet v1
Teste a imagem localmente com o seguinte comando, que vai executar um contêiner do Docker localmente na porta 8080 usando a imagem de contêiner recém-criada:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
E mais uma vez, aproveite o recurso de visualização da Web do Cloud Shell :
A página da Web padrão do ASP.NET Core vai aparecer em uma nova guia.
Depois de verificar se o app está funcionando bem localmente em um contêiner do Docker, interrompa o contêiner em execução usando Ctrl-> C.
Agora que a imagem funciona como esperado, envie-a para o Google Container Registry. Ele é um repositório privado para imagens do Docker que todos os projetos do Google Cloud podem acessar, além de estar disponível também fora do Google Cloud Platform.
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Se tudo correr bem e depois de um tempo, você verá a imagem do contêiner listada na seção do Container Registry. Agora, você tem uma imagem Docker para todo o projeto disponível que o Kubernetes pode acessar e orquestrar, como você verá em alguns minutos.
Se quiser, navegue pelas imagens de contêiner armazenadas no Google Cloud Storage neste link: https://console.cloud.google.com/storage/browser/ (o link resultante completo deve estar neste formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. criar o cluster do Kubernetes.
Agora você já pode criar o cluster do GKE, mas, antes disso, acesse a seção "Google Kubernetes Engine" no console da Web e aguarde a inicialização do sistema. Leva só alguns segundos.
Um cluster consiste em um servidor de API mestre do Kubernetes administrado pelo Google e um conjunto de nós de trabalho. Os nós de trabalho são máquinas virtuais do Compute Engine.
Use a CLI gcloud da sessão do Cloud Shell para criar um cluster. Ajuste sua zona para um local próximo a você ( a lista de zonas). Esse processo levará alguns minutos para ser concluído:
gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b
No final, você verá o cluster criado.
Creating cluster hello-dotnet-cluster...done. Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster]. kubeconfig entry generated for hello-dotnet-cluster. NAME ZONE MASTER_VERSION hello-dotnet-cluster europe-west1-b 1.10.7-gke.6
Agora você tem um cluster do Kubernetes totalmente funcional com a tecnologia do Google Kubernetes Engine:
Agora é hora de implantar o aplicativo em um contêiner no cluster do Kubernetes. De agora em diante, você usará a linha de comando kubectl, que já está configurada no ambiente do Cloud Shell. O restante deste codelab exige que o cliente e o servidor do Kubernetes sejam a 1.2 ou mais recente. kubectl version vai mostrar a versão atual do comando.
7. Criar implantação
Um pod do Kubernetes é um grupo de contêineres agrupados para fins de administração e comunicação em rede. Ele pode ter um único contêiner ou vários. Aqui você simplesmente usará um contêiner criado com sua imagem do ASP.NET Core armazenada no seu Container Registry particular. Ele suprirá conteúdo na porta 8080.
Crie um arquivo hello-dotnet.yaml usando seu editor favorito (vim, nano,emacs ou o editor de código do Cloud Shell) e defina a implantação do Kubernetes para o pod:
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: hello-dotnet
name: hello-dotnet
namespace: default
spec:
replicas: 1
selector:
matchLabels:
run: hello-dotnet
template:
metadata:
labels:
run: hello-dotnet
spec:
containers:
- name: hello-dotnet
image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8080
Implante no namespace padrão com kubectl:
kubectl apply -f hello-dotnet.yaml
deployment.apps/hello-dotnet created
Como você pode ver, criamos um objeto de implantação. Implantações são a maneira recomendada de criar e escalonar pods. Aqui, uma nova implantação gerencia uma réplica de pod único que executa a imagem hello-dotnet:v1.
Para ver a implantação que você acabou de criar, execute:
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 1 1 1 1 37s
Para ver o pod criado pela implantação, execute este comando:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-ztzrb 1/1 Running 0 57s
Agora é um bom momento para executar alguns comandos kubectl interessantes (nenhum deles mudará o estado do cluster. A documentação completa está disponível aqui):
kubectl get pods kubectl cluster-info kubectl config view kubectl get events kubectl logs <pod-name>
Neste ponto, o contêiner já deve estar em execução sob o controle do Kubernetes, mas você ainda precisa torná-lo acessível ao mundo exterior.
8. permitir o tráfego externo
Por padrão, o pod é acessível somente do seu IP interno dentro do cluster. Para tornar o contêiner hello-dotnet acessível de fora da rede virtual do Kubernetes, é necessário expor o pod como um serviço do Kubernetes.
No Cloud Shell, é possível expor o pod à Internet pública com o comando kubectl expose combinado com a sinalização --type="LoadBalancer". A sinalização é obrigatória para a criação de um IP acessível externamente:
kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080
O sinalizador usado neste comando especifica se você usará o balanceador de carga fornecido pela infraestrutura subjacente (nesse caso, o balanceador de carga do Compute Engine). Você expôs a implantação, não o pod diretamente. Isso fará com que o serviço resultante faça o balanceamento de carga do tráfego em todos os pods gerenciados pela implantação (nesse caso, apenas um pod, mas você adicionará mais réplicas posteriormente).
O mestre do Kubernetes cria o balanceador de carga e as regras de encaminhamento do Compute Engine relacionadas, pools de destino e regras de firewall para tornar o serviço totalmente acessível de fora do Google Cloud Platform.
Para encontrar o endereço IP publicamente acessível do serviço, basta solicitar que kubectl liste todos os serviços de cluster:
kubectl get services
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-dotnet 10.3.253.62 104.155.20.69 8080/TCP 1m kubernetes 10.3.240.1 <none> 443/TCP 5m
Há dois endereços IP listados para seu serviço, ambos usando a porta 8080. Um é o IP interno que é visível apenas dentro da sua rede virtual na nuvem. Outro é o IP com balanceamento de carga externo. Neste exemplo, o endereço IP externo é 104.155.20.69.
Agora, você deve conseguir acessar o serviço ao apontar seu navegador para este endereço: http://<EXTERNAL_IP>:8080
Até aqui, você ganhou pelo menos vários recursos com a migração para contêineres e o Kubernetes. Não é necessário especificar em qual host executar a carga de trabalho, e você também se beneficia do monitoramento e da reinicialização do serviço. Vamos ver o que mais a nova infraestrutura do Kubernetes pode oferecer.
9. Escalone seu serviço
Um dos poderosos recursos oferecidos pelo Kubernetes é a facilidade de escalonar seu aplicativo. Suponha que, de repente, você precise de mais capacidade para seu aplicativo. basta pedir ao controlador de replicação para gerenciar um novo número de réplicas do pod:
kubectl scale deployment hello-dotnet --replicas=4
kubectl get deployment NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 4 4 4 3 16m
kubectl get pods NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m hello-dotnet-714049816-sh812 1/1 Running 0 1m hello-dotnet-714049816-ztzrb 1/1 Running 0 16m
Observe a abordagem declarativa aqui. Em vez de iniciar ou interromper novas instâncias, declare quantas instâncias precisam estar em execução ao mesmo tempo. Os loops de reconciliação do Kubernetes simplesmente garantem que a realidade corresponda ao que você solicitou e tomam medidas, se necessário.
Este diagrama resume o estado do nosso cluster Kubernetes:
Também é possível reduzir o escalonamento vertical do serviço com muita facilidade. Confira como reduzir o escalonamento vertical de quatro para dois pods.
kubectl scale deployment hello-dotnet --replicas=2
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
10. Resiliência do teste
O Kubernetes (ou mais especificamente o ReplicaSet) monitora os pods e, se algo der errado com o pod, ele cria um novo imediatamente. Vamos testar isso e ver como funciona.
Primeiro, acesse a lista de pods:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
Exclua um dos pods transmitindo o nome dele:
kubectl delete pod hello-dotnet-714049816-g4azy
Se você analisar a lista de pods outra vez, vai perceber que um novo pod está sendo criado e executado de novo imediatamente:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-abczy 1/1 ContainerCreating 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
11. implementar uma atualização no serviço
Em algum momento, o aplicativo implantado na produção exigirá correções de bugs ou recursos adicionais. Vamos conferir como é esse processo.
Primeiro, vamos modificar o aplicativo. Abra o editor de código no Cloud Shell.
Navegue até Index.cshtml em HelloWorldAspNetCore > Views > Home e atualize uma das mensagens do carrossel.
Encontre a seguinte linha:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core
E modifique a mensagem para:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud
Salve as alterações e volte ao Cloud Shell. Dentro de HelloWorldAspNetCore,, crie a imagem Docker:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
E envie para o Container Registry:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2
Agora já está tudo pronto para o Kubernetes atualizar o controlador de replicação para a nova versão do aplicativo. Para mudar o rótulo da imagem do contêiner em execução, é necessário editar o hello-dotnet deployment atual e mudar a imagem de gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 para gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.
Para fazer isso, use o comando kubectl edit. Isso abrirá um editor de texto que exibe a configuração yaml completa da implantação. Não é preciso entender a configuração YAML completa agora. Apenas entenda que, ao atualizar o campo spec.template.spec.containers.image na configuração, você instrui a implantação a atualizar os pods para usar a nova imagem.
kubectl edit deployment hello-dotnet
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
deployment.kubernetes.io/revision: "1"
creationTimestamp: 2017-01-06T10:05:28Z
generation: 3
labels:
run: hello-dotnet
name: hello-dotnet
namespace: default
resourceVersion: "151017"
selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
replicas: 4
selector:
matchLabels:
run: hello-dotnet
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
run: hello-dotnet
spec:
containers:
- image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
imagePullPolicy: IfNotPresent
name: hello-dotnet
ports:
- containerPort: 8080
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
dnsPolicy: ClusterFirst
restartPolicy: Always
securityContext: {}
terminationGracePeriodSeconds: 30
Depois de fazer a mudança, salve e feche o arquivo. Isso usa vi. Portanto, pressione "Esc", digite :wq e pressione a tecla "Enter".
deployment "hello-dotnet" edited
Isso atualiza a implantação com a nova imagem, fazendo com que novos pods sejam criados com ela e os pods antigos sejam excluídos.
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-dotnet 4 5 4 3 1h
Enquanto isso acontece, os usuários dos serviços não sofrerão nenhuma interrupção. Depois de um tempo, eles começarão a acessar a nova versão do aplicativo.
Encontre mais detalhes sobre atualizações graduais na documentação do Kubernetes.
Esperamos que, com esses recursos de implantação, escalonamento e atualização, você concorde que, depois de configurar seu ambiente (seu cluster do GKE/Kubernetes aqui), o Kubernetes vai ajudar você a se concentrar no seu aplicativo em vez de gerenciar a infraestrutura.
12. Cloud Build
Até agora, criamos contêineres com comandos comuns do Docker (docker build ...) e, em seguida, enviamos a imagem manualmente para o Container Registry do Google Cloud Platform. Também é possível adiar as duas etapas para o Cloud Build no lado do servidor, que pode criar e enviar a imagem do contêiner sem a instalação local do Docker.
Primeiro, ative a API Cloud Build em Gerenciador de APIs > Biblioteca. Pesquise Cloud Build e clique em API Cloud Build:
Clique em Ativar API, se ainda não tiver feito isso. No final, você verá a API ativada desta forma:
Depois que a API Cloud Build estiver ativada, será possível executar o seguinte comando para criar e enviar sua imagem a partir do serviço do Container Builder:
$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3
A imagem é armazenada automaticamente no Container Registry.
13. Executar o painel gráfico do Kubernetes
Nas versões recentes do Kubernetes, uma interface gráfica do usuário da Web (painel) foi introduzida. Essa interface do usuário permite que você inicie rapidamente e habilita algumas das funcionalidades encontradas na CLI, como uma maneira mais acessível e detectável de interagir com o sistema.
Para configurar o acesso ao painel do cluster do Kubernetes, digite estes comandos na janela do Cloud Shell :
gcloud container clusters get-credentials hello-dotnet-cluster \
--zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}
kubectl proxy --port 8081
Em seguida, use o recurso de visualização do Cloud Shell novamente para acessar a porta 8081:
Isso enviará você ao ponto de extremidade da API. Você pode receber uma mensagem de erro "Não autorizado" mas não se preocupe com isso. Para acessar o painel, remova "?authuser=3" e a substitua por "/ui".
Aproveite o painel gráfico do Kubernetes e use-o para implantar aplicativos em contêiner, bem como para monitorar e gerenciar seus clusters.
Como alternativa, você pode acessar o painel em uma máquina local ou de desenvolvimento usando instruções semelhantes fornecidas ao pressionar o botão "Conectar" no console da Web para o cluster que você quer monitorar.
Quando o painel estiver pronto, pressione Control + C para interromper o proxy. Para saber mais sobre o painel do Kubernetes, faça o tour do painel.
14. Logging
Use o comando kubectl logs para recuperar os registros de um contêiner em execução no Kubernetes. Quando você usa o Google Kubernetes Engine para executar clusters do Kubernetes gerenciados, todos os registros são encaminhados e armazenados automaticamente no Google Cloud Logging. Para conferir toda a saída de registro dos pods, acesse Stackdriver → Logging → Registros no console do Google Cloud:
No console de geração de registros, acesse o Contêiner do GKE para ver todos os registros coletados do STDOUT:
Depois disso, você tem a opção de exportar os registros para o Google BigQuery, fazer mais análises ou configurar alertas com base em registros. Não vamos fazer isso no laboratório de hoje.
15. Parabéns!
Isso conclui este codelab simples de introdução ao ASP.NET Core e ao Kubernetes. Nós abordamos apenas uma pequena parte dessa tecnologia e incentivamos você a explorar ainda mais com seus próprios pods, controladores de replicação e serviços. Verifique também as sondas de atividade (verificações de integridade) e considere a possibilidade de usar a API Kubernetes diretamente.
Limpar
Pronto! É hora de limpar alguns dos recursos utilizados para economizar custos e ser um bom cidadão da nuvem.
Exclua a implantação (que também exclui os pods em execução) e o serviço (que também exclui o balanceador de carga externo):
Primeiro, exclua o serviço e a implantação, o que também exclui o balanceador de carga externo:
kubectl delete service,deployment hello-dotnet
service "hello-dotnet" deleted deployment "hello-dotnet" deleted
Em seguida, exclua o cluster:
gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b
The following clusters will be deleted. - [hello-dotnet-cluster] in [europe-west1-b] Do you want to continue (Y/n)? Y Deleting cluster hello-dotnet-cluster...done. Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].
Isso exclui todas as instâncias do Google Compute Engine que executam o cluster.
Por fim, exclua o bucket de armazenamento do registro do Docker que hospeda suas imagens:
gsutil ls
gs://artifacts.<PROJECT_ID>.appspot.com/
gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...
Obviamente, também é possível excluir todo o projeto, mas você perderá qualquer configuração de faturamento que tenha feito. É necessário desativar o faturamento do projeto primeiro. Além disso, a exclusão de um projeto só interromperá todo o faturamento após o término do ciclo de faturamento atual.
O que vimos
- Como empacotar um aplicativo simples do ASP.NET Core como um contêiner do Docker
- Como criar um cluster do Kubernetes no Google Kubernetes Engine.
- Como implantar o aplicativo do ASP.NET Core em um pod
- Como permitir tráfego externo no pod
- Como escalonar verticalmente o serviço e fazer um upgrade
- Como executar o painel gráfico do Kubernetes
Próximas etapas
- Saiba mais sobre os Kubernetes ( http://kubernetes.io/).
- Saiba mais sobre o Windows no Google Cloud Platform.
- Saiba mais sobre .NET no Google Cloud Platform.
- Saiba mais sobre SQL Server no Google Cloud Platform.
- Saiba mais sobre o Cloud Tools for Visual Studio.
- Saiba mais sobre o Cloud Tools for PowerShell.
Licença
Este conteúdo está sob a licença Atribuição 2.0 Genérica da Creative Commons.