Esta página foi traduzida pela API Cloud Translation.

Acelere o desenvolvimento no Cloud Code para VS Code

Para acelerar o desenvolvimento local no Cloud Code para VS Code, tire partido da sincronização de ficheiros e do recarregamento rápido, da implementação automática ao guardar e use módulos do Skaffold para desenvolver partes de uma aplicação separadamente.

Ative a sincronização de ficheiros e o recarregamento rápido do Skaffold

Para melhorar a eficiência do fluxo de trabalho de desenvolvimento local e evitar ter de recompilar, reimplementar e reiniciar os seus pods, o Skaffold suporta a cópia de ficheiros alterados para um contentor implementado. Isto significa que, quando faz alterações a ficheiros de código estático e de origem, pode ver as alterações a entrar em vigor em segundos, o que cria um ciclo de feedback acelerado.

Para ficheiros estáticos (como ficheiros HTML e CSS), este comportamento de cópia de ficheiros denomina-se sincronização de ficheiros.

Para ficheiros de código fonte, este comportamento é denominado recarga dinâmica e suporta os seguintes tipos de ficheiros:

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

Com o recarregamento dinâmico configurado, o Skaffold deteta alterações aos ficheiros suportados e sincroniza estas alterações com o contentor em execução no cluster. As alterações aos tipos de ficheiros que não suportam o recarregamento a quente acionam uma recompilação de imagens e um reinício do pod.

A sincronização automática de ficheiros e o recarregamento dinâmico estão ativados por predefinição quando trabalha com Buildpacks como o seu criador preferencial. Para outros criadores, como o Docker, pode especificar uma secção sync no ficheiro skaffold.yaml para o artefacto que está a personalizar.

A sua definição de sincronização pode ser uma das seguintes (por ordem de preferência):

auto: o Skaffold configura automaticamente a sincronização. (apenas para artefactos Jib e Buildpacks) Esta é a predefinição para os Buildpacks.
infer: os destinos de cada ficheiro alterado são inferidos a partir do criador.
manual: tem de especificar os ficheiros no seu espaço de trabalho local e o respetivo destino no contentor em execução.

A seguinte secção de exemplo sync num ficheiro skaffold.yaml especifica uma sincronização para sincronizar todos os ficheiros HTML /static-html com a pasta static num contentor:manual

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

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

Adicione novas funcionalidades quando desenvolver no Kubernetes

Depois de configurar a sincronização de ficheiros e o recarregamento rápido, inicie um ciclo de iteração e adicione mais funcionalidades ao seu projeto. As alterações são implementadas no cluster do Kubernetes sem parar nem remover a implementação, criar e etiquetar manualmente a imagem, ou atualizar o cluster.

Um ciclo de iteração padrão assemelha-se ao seguinte:

Faça uma alteração no seu projeto. Por exemplo, se usar a app Java Guestbook do Cloud Code, adicione um novo ponto final à classe FrontendController da seguinte forma:
1. Abra o ficheiro FrontendController.java de 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.
Guarde as alterações (Ctrl/Cmd+S) ou crie o projeto.

Pode ver o progresso e os registos de implementação na janela da consola. Após a implementação das alterações, confirme as atualizações.
Para terminar a sessão de desenvolvimento contínuo, clique no ícone Parar.

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

Desenvolva aplicações de microsserviços com configurações do Skaffold

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

Pode desenvolver e depurar partes da sua aplicação de forma independente dividindo-a em módulos do Skaffold. Por exemplo, o exemplo Bank of Anthos é uma aplicação que contém dez microsserviços. O ficheiro skaffold.yaml de exemplo agrupa estes serviços em cinco módulos do Skaffold denominados setup, db, frontend, backend e loadgenerator.

Defina módulos do Skaffold e dependências de configuração

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

Abra o projeto no qual quer definir os módulos.
Abra o ficheiro skaffold.yaml.

Se o seu ficheiro skaffold.yaml tiver várias configurações, para tornar uma configuração um módulo do Skaffold, especifique a seguinte linha:

metadata:
  name: MODULE_NAME_1

Por exemplo, no Bank of Anthos skaffold.yaml, o módulo db define as implementações da base 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 implementação de outra configuração antes de a configuração atual poder ser implementada, tem de adicionar a configuração às suas dependências. Para especificar uma dependência de configuração, adicione uma lista configs à secção requires do ficheiro skaffold.yaml.

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

Para definir uma dependência, adicione o seguinte ao seu ficheiro skaffold.yaml, onde DEPENDENCY_NAME é o nome da dependência.
```
requires:
    - configs: DEPENDENCY_NAME
```
As configurações apresentadas desta forma podem fazer referência a dependências definidas no mesmo ficheiro ou noutros ficheiros skaffold.yaml no projeto atual.
Teste as dependências da configuração criando cada um dos módulos do Skaffold separadamente para se certificar de que são implementados com as respetivas dependências. Para tal, siga os passos descritos no artigo Crie módulos específicos do Skaffold e as respetivas dependências.

Crie módulos específicos do Skaffold e as respetivas dependências

Depois de definir os módulos e as respetivas dependências, pode especificar os módulos que quer executar com código na nuvem no ficheiro launch.json.

Se o seu projeto não tiver um ficheiro launch.json definido, quando executar Cloud Code: Run on Kubernetes ou Cloud Code: Debug on Kubernetes, é-lhe pedido que selecione os módulos a criar:

Abra a paleta de comandos (Ctrl/Cmd+Shift+P) e, em seguida, execute Cloud Code: Run on Kubernetes.
Clique em Selecionar módulos.
Escolha os módulos que quer implementar e, de seguida, clique em OK. Cada módulo é criado com as respetivas dependências.
Quando lhe for pedido, escolha um registo de imagens e, de seguida, prima Enter.

Se o seu projeto tiver um launch.json, siga estes passos para escolher os módulos do Skaffold a criar:

Abra o ficheiro launch.json do projeto.

Edite a configuração de lançamento para adicionar a opção skaffoldFlags com uma lista separada por vírgulas de modules a criar. Se skaffoldFlags for omitido, todos os módulos sã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 lançamento que editou.

Desenvolvimento contínuo no Kubernetes

Depois de configurar o alvo de execução com as opções pretendidas, pode optar por uma execução normal da aplicação ou iniciar um ciclo de iteração de desenvolvimento no IDE para propagar quaisquer alterações feitas à origem e às dependências para a aplicação em direto.

O destino de execução Run on Kubernetes inicia o ciclo de desenvolvimento no seu cluster do Kubernetes. Depois de iniciar o ciclo de desenvolvimento, o Cloud Code, através do Skaffold, cria uma imagem para o projeto e, em seguida, etiqueta-a, envia-a para o repositório configurado e usa o kubectl para implementar os manifestos do Kubernetes do projeto.

Personalize a implementação através das opções de configuração disponíveis.
Se a sua aplicação estiver configurada para usar módulos do Skaffold, pode selecionar módulos específicos para compilar ou implementar.
Abra a paleta de comandos (prima Ctrl/Cmd+Shift+P) e, de seguida, execute o comando Cloud Code: Run on Kubernetes.
Confirme se quer usar o contexto do Kubernetes atual para executar a app (ou mude para um contexto preferencial). Para mais informações sobre como configurar um contexto do Kubernetes, consulte o artigo Configurar.
Se escolheu um cluster remoto como contexto, quando lhe for pedido, escolha um registo de imagens para enviar as imagens. Se o seu projeto tiver a API Artifact Registry ativada e, pelo menos, um repositório do Artifact Registry, pode procurar e selecionar um repositório do Artifact Registry existente.

O Cloud Code cria os seus contentores, envia-os para o registo, aplica as configurações do Kubernetes ao cluster e aguarda a implementação.

O que se segue?

Use o cluster minikube integrado do Cloud Code para o desenvolvimento local.
Depure a sua aplicação no Cloud Code
Leia os detalhes sobre a funcionalidade de sincronização de ficheiros do Skaffold

Obter apoio técnico

Para enviar feedback, comunicar problemas no GitHub ou fazer uma pergunta no Stack Overflow.

Acelere 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.