Como executar um app do Kubernetes

Esta página mostra como iniciar rapidamente com o Cloud Code.

Você configurará um novo aplicativo do Kubernetes usando um modelo inicial "Hello World", criar um cluster, executar seu aplicativo neste cluster, depurar o código em execução, ver registros do seu aplicativo ativo e conectar um terminal para o contêiner em execução.

Antes de começar

Se você quiser usar o Google Cloud, será necessário criar um projeto do Google Cloud e ativar o faturamento.

Observação: para aproveitar ao máximo este guia de início rápido, é recomendável criar um projeto do Google Cloud. Um projeto do Google Cloud permite criar e trabalhar facilmente com um cluster ativo do GKE, aproveitar a oferta de entrega contínua do Cloud Code e usar os recursos de depuração em tempo real.

Como instalar o Cloud Code

1. Instale o Visual Studio Code na sua máquina, caso ainda não tenha feito isso.

2. Para todas as plataformas do Cloud, instale o cliente Docker (autenticado com o registro do Docker) no PATH da sua máquina. A pasta de instalação precisa estar visível em um no seu PATH).

   • Para verificar se o Docker já está instalado, execute docker -v.
   • Se você estiver usando o Windows Home, consulte Instalar o Docker da área de trabalho no Windows Home.
   • Se você estiver usando o WSL, mas não puder instalar o Docker para computadores, use o minikube para desenvolvimento local com o Cloud Code.

   O Cloud Code instala automaticamente o kubectl, o Skaffold e o SDK do Cloud.

3. Instale o Cloud Code usando uma das seguintes opções:

   • Abra o VS Code e instale o Cloud Code
   • Abra o Visual Studio Code na sua máquina. Usando a visualização Extensões no VS Code (o ícone quadrado disponível na barra de tarefas à esquerda), pesquise e clique em Cloud Code e clique em Instalar.

   Após a conclusão da instalação, você verá a página de boas-vindas do Cloud Code e uma coleção de modelos integrados em Apps Starter, que podem ser usados para configurar rapidamente um novo aplicativo.

   

   Além disso, a barra de status do Cloud Code, repleta de ações comuns do Cloud Code, agora está disponível na barra de status do VS Code.

   

Como criar um aplicativo

1. Na paleta de comandos (Cmd/Ctrl+Shift+P), execute Cloud Code: New Application{/1. }, escolha Kubernetes Application e, em seguida, escolha um aplicativo Hello World na linguagem que você preferir.

   Por exemplo, escolher Node.js: Hello World cria um aplicativo Hello World em Node.js.

2. Salve o novo aplicativo.

   Uma notificação confirma que o aplicativo foi criado e que uma nova janela é aberta com o aplicativo.

crie um cluster do GKE;

Para criar um cluster padrão do Google Kubernetes Engine (GKE), siga estas etapas:

1. Para abrir o explorador do Google Kubernetes Engine, clique no ícone Cloud Code - Kubernetes na barra de atividade do VS Code à esquerda.
2. Se você ainda não tiver feito login, para autenticar com o SDK do Cloud, clique em Clique aqui para fazer login no Google Cloud SDK.
3. Para criar um novo cluster do GKE, no cabeçalho do GKE Explorer, clique em + (disponível ao passar o cursor).
4. Verifique se você está criando o cluster no projeto padrão.

5. Preencha os campos no assistente de criação de cluster e clique em Criar cluster.

   Neste exemplo, o ID do projeto é definido usando o botão padrão do ID do projeto, a zona é definida como us-central1-a e o nome do cluster é definido como my-first-cluster.

   A criação do cluster leva alguns minutos. Depois que seu cluster for criado, ele será listado na visualização do GKE Explorer .

   

Como executar o app

Como executar uma simulação da sua configuração

Se você quiser verificar a validade da configuração do aplicativo:

1. Abra o arquivo de configuração que você quer validar no seu ambiente de desenvolvimento integrado. Para o aplicativo Hello World, os arquivos de configuração estão localizados na pasta kubernetes-manifests.

2. Use o Cloud Code: configuração de simulação atual para validação do servidor ou Cloud Code: configuração de simulação atual para validação do lado do cliente do Paleta de comandos (acessível no menu Gerenciar ).

   Isso executa kubectl apply -f dry-run=server (ou kubectl apply -f dry-run=client, para a opção Client) e exibe a validação bem-sucedida (ou uma mensagem de erro, se o arquivo de configuração não for válido) como notificação de toast para começar.

   

Como executar e ver seu app

Agora que está tudo pronto, você pode executar o aplicativo e visualizá-lo. O Cloud Code monitora as alterações no sistema de arquivos para que você possa editar e executar o aplicativo quase em tempo real.

Para executar seu aplicativo, siga estas etapas:

1. Use a barra de status do Cloud Code e selecione Executar no Kubernetes.
2. Confirme se você quer usar o contexto de cluster atual ou mudar para um diferente.

3. Se solicitado, escolha um registro de imagem para enviar as imagens.

   Uma janela de saída é exibida onde você pode acompanhar o andamento do aplicativo em execução. Você também verá uma transmissão ao vivo dos registros dos pods em execução na saída do terminal.

4. Depois que o aplicativo estiver em execução no Kubernetes, a janela de saída exibirá um endereço IP. Para usar esse endereço IP vinculado para acessar seu aplicativo, pressione Ctrl/Cmd + clique.

   

Dicas de solução de problemas

Se você estiver usando um cluster preexistente, para obter credenciais de cluster e adicionar o cluster a kubectl, execute o seguinte comando:

 gcloud container clusters get-credentials ${CLUSTER} --zone=${ZONE}
 

Como alternativa, defina o cluster como ativo e consiga as credenciais dele usando o GKE Explorer da seguinte maneira:

1. Navegue até o GKE Explorer (como um painel acessível no Kubernetes Explorer, na visualização do Cloud Code).
2. Clique com o botão direito do mouse no cluster e clique em Definir como cluster ativo.

Como depurar o aplicativo

Para depurar o aplicativo, siga estes passos:

1. Use a barra de status do Cloud Code e selecione Depurar no Kubernetes.

2. Se solicitado, confirme se quer usar o contexto atual do cluster ou mudar para um preferencial.

   O Cloud Code usa as configurações cloudcode.kubernetes no seu arquivo .vscode/launch.json para executar o aplicativo e anexar uma sessão do depurador a ele.

   Em seguida, o Cloud Code cria seus contêineres, os envia para o registro, aplica as configurações do Kubernetes ao cluster e retorna o endereço IP que você pode usar para navegar no aplicativo ativo.

3. Antes de a sessão do depurador ser anexada, você precisará confirmar ou inserir o diretório no contêiner remoto em que o programa para depuração é encontrado ou pressionar ESC para pular a depuração do contêiner.

4. Para adicionar um ponto de interrupção à linha no 9, abra src/app.js e clique na margem do editor.

   Os círculos vermelhos vermelhos indicam pontos de interrupção ativos, enquanto os círculos cinza escuros indicam pontos de interrupção desativados. Para um controle mais preciso do ponto de interrupção, use a seção Pontos de interrupção na visualização de depuração do VS Code.

   

   Quando você envia uma nova solicitação para seu aplicativo, o depurador é pausado no primeiro ponto de interrupção ativo.

   No exemplo a seguir, em Local na seção "Variáveis", observe que o valor de res._contentLength; para Hello, world! é 13.

   

5. Edite a string que está sendo enviada na linha 8 para Hello, goodbye! e, em seguida, reinicie a ação Depuração no Kubernetes.

   Depois que o app for recriado e reimplantado, anote o valor atualizado de res._contentLength.

   

Como ver registros

Além de ver uma transmissão ao vivo dos registros de pods em execução na saída de terminal do aplicativo em execução, também é possível ver os registros com o visualizador de registros que vem com o Cloud Code.

Para ver os registros, siga estas etapas:

1. Inicie o visualizador de registros digitando Cloud Code: View Logs usando o Command Palette (acessível com Ctrl/Cmd+Shift+P ou no menu Gerenciar marcado com um ícone de engrenagem .

2. Procure o aplicativo em execução, neste caso, nodejs-hello-world, para visualizar os registros usando o campo de implantação na caixa de pesquisa do Visualizador de registros.

   

Bônus: como abrir um terminal no contêiner

Para abrir um terminal no seu contêiner, siga estas instruções:

1. Navegue até o Kubernetes Explorer.
2. Selecione o cluster e, na seção Pods subjacente, o pod a que você quer se conectar.
3. No pod especificado, expanda a seção Contêineres.

4. Clique com o botão direito do mouse no contêiner em que você quer abrir um terminal e clique em Obter terminal.

   Isso inicia um terminal. Agora você tem acesso a um shell dentro do contêiner em execução.

   

Limpeza

Depois de encerrar o aplicativo, todos os recursos do Kubernetes implantados durante a execução serão excluídos automaticamente.

Para evitar cobranças na sua conta de outros recursos usados neste guia de início rápido, exclua o cluster e o projeto criados.

Se você estiver usando o Google Cloud e quiser excluir apenas o cluster, faça isso:

• No Kubernetes Explorer na visualização do Cloud Code , clique com o botão direito do mouse no cluster que você quer excluir do painel do Google Kubernetes Engine Explorer e, em seguida, clique emExcluir cluster para começar.

Para excluir o projeto (e os recursos associados, incluindo os clusters):

1. Acesse a página Projetos no Console do Cloud:

   Acessar a página "Projetos"

2. Selecione o projeto criado para este guia de início rápido e clique no ícone de lixeira ao lado dele para excluí-lo.

   Isso encerrará o projeto e programará a remoção dele.

A seguir

• Considere importar um aplicativo atual para o VS Code e configurá-lo com o Cloud Code.
• Lide com a configuração mais avançada do Google Cloud e do Kubernetes com o suporte de edição YAML do Cloud Code.
• Descubra o suporte de depuração específico do idioma fornecido pelo Cloud Code.
• Explore os tipos de clusters do Kubernetes com que você pode trabalhar ao desenvolver com o Cloud Code.
• Para entender melhor e gerenciar os recursos do Kubernetes, use o Kubernetes Explorer.
• Personalize sua experiência com o Cloud Code definindo configurações relevantes.