O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Acelerar o desenvolvimento no Cloud Code para VS Code

Para acelerar o desenvolvimento local no Cloud Code para VS Code, aproveite a sincronização de arquivos e a recarga dinâmica, a implantação automática ao salvar e use módulos para desenvolver partes de um aplicativo separadamente.

Ativar a sincronização de arquivos e a recarga dinâmica

Para melhorar a eficiência do fluxo de trabalho de desenvolvimento local e evitar a necessidade de recriar, reimplantar e reiniciar os pods, o Cloud Code aceita copiar arquivos alterados para um contêiner implantado. Isso significa que, ao fazer mudanças em arquivos estáticos e de código-fonte, é possível ver as alterações em questão de segundos, criando um loop de feedback acelerado.

Em arquivos estáticos, como HTML e CSS, o comportamento de cópia desse arquivo é chamado de sincronização de arquivos.

Para arquivos de código-fonte, esse comportamento é chamado de recarga dinâmica e é compatível com os seguintes tipos de arquivo:

Go: *.go
Java: *.java, *.kt, *.scala, *.groovy, *.clj.
Node.js: *.js, *.mjs, *.coffee, *.litcoffee, *.json

Com a recarga dinâmica configurada, o Cloud Code detecta mudanças nos arquivos compatíveis e sincroniza essas mudanças com o contêiner em execução no cluster. Alterações nos tipos de arquivo que não são compatíveis com recarga dinâmica acionam uma recriação de imagem e uma reinicialização de pod.

A sincronização automática de arquivos e a recarga dinâmica são ativadas por padrão quando você está trabalhando com o Buildpacks como o builder preferido. Para outros builders como o Docker, especifique uma seção sync no arquivo skaffold.yaml para o artefato que você está personalizando.

A configuração de sincronização pode ser uma das seguintes (em ordem de preferência):

auto: o Cloud Code configura a sincronização automaticamente. (apenas para artefatos Jib e Buildpacks.) Esse é o padrão para Buildpacks.
infer: os destinos de cada arquivo mudado são inferidos do builder.
manual: especifique os arquivos no espaço de trabalho local e o destino deles no contêiner em execução.

A seguinte seção sync de amostra em um arquivo skaffold.yaml especifica uma sincronização manual para sincronizar todos os arquivos HTML /static-html com a pasta static em um contêiner:

build:
  artifacts:
    - image: gcr.io/k8s-skaffold/node-example
      context: node
      sync:
        manual:
          - src: 'static-html/*.html'
            dest: static

Para uma análise detalhada sobre a sincronização de arquivos e a especificação de regras de sincronização, consulte o guia do Skyffold sobre sincronização de arquivos.

Adicionar novos recursos no desenvolvimento do Kubernetes

Depois de configurar a sincronização de arquivos e a recarga dinâmica, inicie um ciclo de iteração e adicione mais recursos ao seu projeto. As mudanças são implantadas no cluster do Kubernetes sem interromper e remover a implantação, criar e aplicar uma tag manualmente à imagem ou atualizar o cluster.

Um ciclo de iteração padrão é semelhante a este:

Faça uma mudança no projeto. Por exemplo, se você estiver usando o app Guestbook do Cloud Code Java, adicione um novo endpoint à classe FrontendController da seguinte maneira:
1. Abra o arquivo FrontendController.java em src/main/java/cloudcode/guestbook/frontend e adicione o seguinte:
```
@RequestMapping("/greeting")
@ResponseBody
public String greeting(@RequestParam(value="name", defaultValue="World") String name) {
   return String.format("Hello from Kubernetes with IntelliJ, %s!", name);
}
```
2. Adicione as importações necessárias para as novas anotações, RequestMapping e ResponseBody.
Salve as mudanças (Ctrl/Cmd+S) ou crie o projeto.

É possível visualizar os registros de progresso e implantação na janela do console. Depois que as mudanças forem implantadas, confirme as atualizações.
Para encerrar a sessão de desenvolvimento contínuo, clique no ícone Parar.

O Cloud Code exclui todos os recursos do Kubernetes usados para a sessão de desenvolvimento.

Desenvolver aplicativos de microsserviços usando configurações do `skaffold.yaml`

Ao desenvolver aplicativos de microsserviços, pode ser útil trabalhar em seções separadas de forma independente para simplificar a depuração e a implantação.

É possível desenvolver e depurar partes do seu aplicativo de forma independente dividindo-o em módulos. Por exemplo, a amostra do Bank of Anthos é um aplicativo que contém dez microsserviços. O arquivo skaffold.yaml de exemplo agrupa esses serviços em cinco módulos chamados setup, db, frontend, backend e loadgenerator.

Definir módulos e dependências de configuração

Para definir módulos e dependências de configuração:

Abra o projeto em que você quer definir os módulos.
Abra o arquivo skaffold.yaml.

Se o arquivo skaffold.yaml tiver várias configurações, para fazer uma delas um módulo, especifique a seguinte linha:

metadata:
  name: MODULE_NAME_1

Por exemplo, no skaffold.yaml do Bank of Anthos, o módulo db define implantações de banco de dados:

apiVersion: skaffold/v3
kind: Config
metadata:
  name: db # module defining database deployments
requires:
- configs:
  - setup
build:
  artifacts:
  - image: accounts-db
    context: src/accounts-db
  - image: ledger-db
    context: src/ledger-db
manifests:
  rawYaml:
  - dev-kubernetes-manifests/accounts-db.yaml
  - dev-kubernetes-manifests/ledger-db.yaml
deploy:
  kubectl: {}

Para configurações que dependem da implantação de outra configuração antes da implantação da configuração atual, adicione a configuração às suas dependências. Para especificar uma dependência de configuração, adicione uma lista configs à seção requires do arquivo skaffold.yaml.

Por exemplo, o arquivo skaffold.yaml do Bank of Anthos inclui a dependência de configuração setup.

Para definir uma dependência, adicione o seguinte ao arquivo skaffold.yaml, em que DEPENDENCY_NAME é o nome da dependência.
```
requires:
    - configs: DEPENDENCY_NAME
```
As configurações listadas dessa forma podem referenciar dependências definidas no mesmo arquivo ou em outros arquivos skaffold.yaml no projeto atual.
Teste suas dependências de configuração criando cada um dos módulos separadamente para garantir que eles sejam implantados com as dependências deles. Para isso, siga as etapas em Criar módulos específicos e as respectivas dependências.

Criar módulos específicos e as dependências deles

Depois de definir os módulos e as dependências deles, especifique quais módulos você quer executar com o Cloud Code no arquivo launch.json.

Se o projeto não tiver um arquivo launch.json definido, ao executar Cloud Code: Run on Kubernetes ou Cloud Code: Debug on Kubernetes, você precisará selecionar os módulos a serem criados:

Abra a paleta de comandos (Ctrl/Cmd+Shift+P) e execute Cloud Code: Run on Kubernetes.
Clique em Select modules.
Escolha os módulos que você quer implantar e clique em OK. Cada módulo é criado com as dependências.
Quando solicitado, escolha um registro de imagem e pressione Enter.

Se o projeto tiver um launch.json, siga estas etapas para escolher os módulos a serem criados:

Abra o arquivo launch.json do projeto.

Edite a configuração de inicialização para adicionar a opção skaffoldFlags com uma lista delimitada por vírgulas de modules para criar. Se skaffoldFlags for omitido, todos os módulos serão criados.

  {
    "name": "Run on Kubernetes",
    "type": "cloudcode.kubernetes",
    "request": "launch",
    "skaffoldConfig": "${workspaceFolder}/skaffold.yaml",
    "skaffoldFlags": {
       "modules": ["MODULE_NAME_2,MODULE_NAME_2"],
    "watch": true,
    "cleanUp": true,
    }
  }

Execute a configuração de inicialização que você editou.

Desenvolvimento contínuo no Kubernetes

Depois de configurar o destino de execução com as opções desejadas, você pode executar o aplicativo regularmente ou iniciar um ciclo de iteração de desenvolvimento no ambiente de desenvolvimento integrado para propagar as mudanças feitas na origem e dependências no aplicativo ativo.

O destino de execução Executar no Kubernetes inicia o ciclo de desenvolvimento no cluster do Kubernetes. Depois de iniciar o ciclo de desenvolvimento, o Cloud Code cria uma imagem para o projeto, marca-a, envia-a para o repositório configurado e usa kubectl para implantar os manifestos do Kubernetes do projeto.

Personalize sua implantação usando as opções de configuração disponíveis.
Se o aplicativo estiver configurado para usar módulos, você poderá selecionar módulos específicos para criar ou implantar.
Abra a paleta de comandos (pressione Ctrl/Cmd+Shift+P) e execute o comando Cloud Code: Run on Kubernetes.
Confirme se você quer usar o contexto do Kubernetes atual para executar o aplicativo (ou alternar para um preferido). Para mais informações sobre como configurar um contexto do Kubernetes, consulte Como configurar.
Se você escolheu um cluster remoto como contexto, quando solicitado, escolha um registro de imagem para enviar as imagens. Se o projeto tiver a API Artifact Registry ativada e pelo menos um repositório do Artifact Registry, é possível navegar e selecionar um repositório existente do Artifact Registry.

O Cloud Code, em seguida, cria os contêineres, os envia para o registro, aplica as configurações do Kubernetes ao cluster e aguarda o lançamento.

A seguir

Use o cluster do minikube integrado do Cloud Code para desenvolvimento local.
Depurar seu aplicativo no Cloud Code
Leia os detalhes sobre o recurso de sincronização de arquivos

Receber suporte

Acesse o GitHub para enviar feedback e informar problemas ou o Stack Overflow (ambos em inglês) para fazer perguntas.

Acelerar o desenvolvimento no Cloud Code para VS Code Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.