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ê vai implantar um aplicativo ASP.NET Core simples no Kubernetes executado no Kubernetes Engine. Este codelab se baseia no codelab Criar e iniciar um app do ASP.NET Core no Google Cloud Shell. Recomendamos que você faça esse laboratório primeiro.
O objetivo deste codelab é transformar o código (um simples aplicativo "Hello World" do ASP.NET Core) que você desenvolveu em um aplicativo replicado executado no Kubernetes. Você pega o código que desenvolveu na sua máquina, transforma-o em uma imagem de contêiner do Docker e executa essa imagem no Google Kubernetes Engine.
Confira um diagrama das várias partes deste codelab para entender como as peças se encaixam. Use isso como referência à medida que você avança no codelab. Tudo fará sentido quando você chegar ao fim. Você pode ignorar isso por enquanto.
Neste codelab, o uso de um ambiente gerenciado como o Kubernetes Engine, uma versão do Kubernetes hospedada pelo Google em execução no Compute Engine, permite que você se concentre mais na experiência do 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. Você pode usar o Minikube durante este codelab, se quiser.
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 É possível atualizar o local 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. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como
PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto. - Para sua informação, há um terceiro valor, um Número do 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 evitar cobranças além deste tutorial, exclua os recursos criados ou 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, vai ver uma tela intermediária abaixo da dobra com a descrição dele. Se esse for o caso, clique em Continuar e você não a verá novamente. Esta é a aparência dessa tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual contém 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 comando a seguir no Cloud Shell para confirmar se 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 se a ferramenta de linha de comando dotnet já está instalada conferindo a versão dela. Isso vai imprimir a versão da ferramenta de linha de comando dotnet instalada:
dotnet --version
Em seguida, crie uma estrutura para um 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
Quase tudo pronto 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 confirmar que o app está em execução, clique no botão "Visualização da Web", no canto superior direito, e selecione "Visualizar na porta 8080".
A página da Web padrão do ASP.NET Core vai aparecer:
Depois de verificar que o app está em execução, pressione Ctrl+C para desligá-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 abaixo a Dockerfile usando seu editor preferido (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 apps do ASP.NET Core usam para determinar em qual porta escutar.
Salve este Dockerfile. Agora, vamos criar a imagem:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Quando isso for concluído (o download e a extração levam algum tempo), você verá 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 comando a seguir, que executa um contêiner do Docker localmente na porta 8080 na imagem de contêiner que você criou:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
E aproveite novamente 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 que o app está sendo executado localmente em um contêiner do Docker, você pode parar o contêiner em execução com 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 der certo, depois de um tempo, a imagem do contêiner vai aparecer na seção Container Registry. Agora você tem uma imagem Docker disponível para todo o projeto que pode ser acessada e orquestrada pelo Kubernetes, como você verá em alguns minutos.
Se você quiser, navegue pelas imagens do contêiner, já que estão armazenadas no Google Cloud Storage, neste link: https://console.cloud.google.com/storage/browser/. O link resultante completo deve ter este formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/.
6. Criar cluster do Kubernetes
Agora você está pronto para criar seu cluster do GKE. Antes disso, navegue até a seção do Google Kubernetes Engine no console da Web e aguarde a inicialização do sistema (isso leva apenas 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.
Vamos usar a CLI gcloud da sua sessão do Cloud Shell para criar um cluster. Ajuste sua zona para um local próximo a você ( lista de zonas). Esse processo leva alguns minutos:
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 o Google Kubernetes Engine:
Agora é hora de implantar o aplicativo em um contêiner no cluster do Kubernetes. A partir de agora, use a linha de comando kubectl (já configurada no ambiente shell do Cloud Shell). O restante deste codelab exige que a versão do cliente e do servidor kubernetes seja 1.2 ou superior. O 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ê usará um contêiner criado com a imagem do ASP.NET Core armazenada no seu Container Registry particular. Ele vai veicular 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 testar alguns comandos kubectl interessantes. Nenhum deles vai 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>
Agora, você tem o contêiner em exibição sob o controle do Kubernetes, mas 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.
Com o Cloud Shell, podemos expor o pod à Internet pública com o comando kubectl expose, combinado com a flag --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 público do serviço, basta solicitar que o 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 o 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 com este endereço no navegador: http://<EXTERNAL_IP>:8080
Até agora, você ganhou vários recursos ao migrar para contêineres e o Kubernetes. Não é preciso 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. Escalonar 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 dizer 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, você declara quantas instâncias precisam estar em execução o tempo todo. Os loops de reconciliação do Kubernetes garantem que a realidade corresponda ao solicitado e entre em ação, se necessário.
Este diagrama resume o estado do nosso cluster Kubernetes:
Também é possível reduzir escala vertical do serviço com muita facilidade. Veja como reduzir escala vertical de 4 para 2 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. Teste de resiliência
O Kubernetes (ou mais especificamente o ReplicaSet) monitora seus pods e, se algo der errado com um deles e ele ficar inativo, um novo será criado imediatamente. Vamos testar e ver como funciona.
Primeiro, receba 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ê olhar a lista de pods de novo, vai ver um novo pod sendo criado e executado 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 ver como é esse processo.
Primeiro, vamos modificar o aplicativo. Abra o editor de código no Cloud Shell.
Acesse 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 mudanças e volte para o Cloud Shell. Em HelloWorldAspNetCore,, crie a imagem do 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, edite o hello-dotnet deployment e mude a imagem de gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 para gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.
Para isso, use o comando kubectl edit. Isso abre um editor de texto que mostra a configuração YAML completa da implantação. Não é necessário entender a configuração completa do YAML no momento. Basta entender que, quando você atualiza o campo spec.template.spec.containers.image na configuração, a implantação altera 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. No vi, 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 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 as atualizações graduais na documentação do Kubernetes.
Depois que você configura o ambiente (o cluster do GKE/Kubernetes), os recursos de implantação, de escalonamento e de atualização do Kubernetes ajudam você a se concentrar no seu aplicativo em vez de gerenciar a infraestrutura.
12. Cloud Build
Até agora, criamos contêineres com comandos regulares do Docker (docker build ...) e enviamos manualmente a imagem para o Container Registry do Google Cloud Platform. Também é possível adiar as duas etapas para o lado do servidor Cloud Build, que pode criar e enviar a imagem do contêiner sem ter uma 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 estiver ativada. No final, a API vai aparecer ativada da seguinte forma:
Depois que a API Cloud Build for ativada, execute o comando a seguir para criar e enviar a imagem usando o serviço 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. Talvez você receba uma página "Não autorizado", mas não se preocupe com isso. Para acessar o painel, remova "?authuser=3" e 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.
Outra opção é acessar o painel em uma máquina local ou de desenvolvimento. Para isso, siga as instruções e, no console da Web, pressione o botão "Conectar" do cluster que você quer monitorar.
Quando terminar o painel, você pode parar o proxy com Control + C. 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 gerenciados do Kubernetes, todos os registros são encaminhados e armazenados automaticamente no Cloud Logging. Para ver toda a saída de registro dos pods, acesse Stackdriver → Logging → Registros no console do Google Cloud:
No console do Logging, navegue até Contêiner do GKE para ver todos os registros coletados de STDOUT:
Aqui, você pode exportar os registros para o Google BigQuery para uma análise mais detalhada ou configurar alertas com base em registros. Não vamos fazer isso durante o 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 estão executando 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/...
Também é possível excluir todo o projeto, mas você perderá toda a configuração de faturamento feita. Primeiro, é necessário desativar o faturamento do projeto. Além disso, a exclusão de um projeto só interrompe 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.