Esta página foi traduzida pela API Cloud Translation.

Comece a usar o Skaffold no Cloud Deploy

Este documento descreve como começar a usar o Skaffold como parte do Cloud Deploy, incluindo o seguinte:

Configurar o Skaffold para utilização com um pipeline de entrega do Cloud Deploy
Usar o Skaffold e o Cloud Deploy com ferramentas de renderização de terceiros, como o Helm e o Kustomize
Opcionalmente, usar o Skaffold para o desenvolvimento local
Opcionalmente, usar o Skaffold para integração contínua e implementação contínua (CI/CD)

Porquê o Skaffold?

Quer saber por que motivo o Cloud Deploy usa o Skaffold e por que motivo tem de gerir uma configuração do Skaffold? Ler mais.

Tenho experiência com CI/CD, mas não uso o Skaffold atualmente

O Skaffold é uma ferramenta de linha de comandos de código aberto para melhorar a produtividade dos programadores. Orquestra o desenvolvimento contínuo, a integração contínua (CI) e a entrega contínua (CD).

O Skaffold oferece uma configuração declarativa e portátil, usando uma arquitetura conectável, que lhe permite usar diferentes ferramentas para a fase de renderização.

Quando é criado um lançamento, o Cloud Deploy chama o Skaffold para renderizar os seus manifestos. No momento da implementação, o Cloud Deploy chama novamente o Skaffold para aplicar esses manifestos para implementar a sua aplicação em cada alvo na sua progressão. Após a implementação, o Skaffold realiza verificações de funcionamento para monitorizar o tempo de execução de destino para uma implementação bem-sucedida.

Skaffold para desenvolvimento contínuo

Quando usa o Skaffold para desenvolvimento contínuo, as imagens são criadas, testadas e implementadas num cluster (ou no Minikube) à medida que altera o seu código. As extensões do IDE Cloud Code para VS Code e Cloud Code para IntelliJ integram o Skaffold no Visual Studio Code e nos IDEs JetBrains, para um desenvolvimento contínuo.

Skaffold para entrega contínua

Também pode usar o Skaffold para a entrega contínua, com passos de compilação, implementação, renderização e aplicação. O Cloud Deploy usa as capacidades de renderização e aplicação do Skaffold. Para usar a implementação na nuvem, precisa, pelo menos, de um ficheiro de configuração skaffold.yamlválido.

Através do Skaffold, também pode integrar ferramentas de gestão de manifestos de terceiros, como o Helm e o Kustomize. A utilização do Skaffold desta forma permite-lhe usar as funcionalidades dessas ferramentas para renderizar manifestos. kubectl continua a ser o implementador destes manifestos.

Estou a implementar no Kubernetes pela primeira vez

Com o Skaffold, pode configurar um conjunto base de manifestos para todas as suas implementações. Em seguida, pode usar o motor de renderização do Skaffold, através do Cloud Deploy, para renderizar e, em seguida, implementar cada manifesto específico da implementação a partir de um desses manifestos base.

Leia mais sobre a gestão de manifestos, incluindo exemplos de utilização do Skaffold e do Cloud Deploy com ferramentas de criação de modelos de manifestos comuns, como o Helm e o Kustomize.

O que é necessário para que o Cloud Deploy funcione?

Para usar um pipeline de entrega do Cloud Deploy básico, o skaffold.yaml ficheiro de configuração precisa, pelo menos, da seguinte configuração:

As informações do cabeçalho de que todas as configurações skaffold.yaml precisam:
```
apiVersion: skaffold/v4beta7
kind: Config
```
Uma secção manifests para o GKE, o GKE Enterprise ou o Cloud Run que liste todos os manifestos Kubernetes não processados (a menos que esteja a usar uma ferramenta de gestão de manifestos, como o Helm ou o Kustomize).

Segue-se um exemplo que usa um manifesto do Kubernetes não processado:
```
manifests:
  rawYaml:
  - deployment.yaml
```
Se planeia usar um renderizador (como o Helm ou o Kustomize) para renderizar manifestos, consulte os artigos Adicione compatibilidade com o Helm ao seu skaffold.yaml e Adicione compatibilidade com o Kustomize ao seu skaffold.yaml para obter orientações sobre como configurar o Skaffold para usar estas ferramentas.

Para ver exemplos do Helm e do Kustomize, consulte o artigo Faça a gestão de manifestos
Uma secção deploy, com deploy.kubectl para implementação no GKE ou no GKE Enterprise, ou deploy.cloudrun para implementação no Cloud Run.

Para alvos do GKE e GKE Enterprise:
```
deploy:
  kubectl: {}
```
A secção deploy implementa os manifestos da aplicação que foram fornecidos na secção manifests.

Para destinos do Cloud Run:
```
deploy:
  cloudrun: {}
```
A secção deploy implementa os manifestos da aplicação fornecidos na secção manifests.

Se estiver a usar alvos personalizados, o seu skaffold.yaml tem de ter o cabeçalho (apiVersion e kind:), além das ações personalizadas que o alvo personalizado vai usar se o tipo de alvo personalizado ainda não fizer referência a uma configuração remota do Skaffold.

Crie um ficheiro `skaffold.yaml`

O Cloud Deploy usa o Skaffold para renderizar e implementar as suas aplicações.

Para cada lançamento, tem de fornecer, pelo menos, um ficheiro skaffold.yaml que identifique os manifestos a usar. Consulte a secção anterior para obter orientações sobre o que deve constar neste ficheiro.

Faça com que o Cloud Deploy gere o seu `skaffold.yaml`

Se não tiver um ficheiro skaffold.yaml, mas tiver um único manifesto do Kubernetes ou um ficheiro de definição do serviço do Cloud Run, o Cloud Deploy pode gerar um ficheiro skaffold.yaml para si.

O ficheiro Skaffold gerado vai estar disponível no diretório de preparação do Cloud Storage após a conclusão do lançamento.

O comando seguinte inclui a flag --from-k8s-manifest, transmitindo o manifesto do Kubernetes. O Cloud Deploy usa as informações no manifesto para gerar o skaffold.yaml, que é usado para a versão.

gcloud deploy releases create  RELEASE_NAME --delivery-pipeline=PIPELINE_NAME --from-k8s-manifest=MANIFEST --region=REGION

Para gerar o skaffold.yaml a partir de um YAML de serviço do Cloud Run, use o mesmo comando, mas com --from-run-manifest em vez de --from-k8s-manifest

A utilização de qualquer uma destas flags com a flag --skaffold-file ou a flag --source gera um erro.

Usar o ficheiro `skaffold.yaml` gerado

O skaffold.yaml gerado é adequado para a integração, a aprendizagem e a demonstração do Cloud Deploy. Depois de se familiarizar com o Cloud Deploy, e para cargas de trabalho de produção, pode querer uma configuração do Skaffold que faça a distinção entre os seus destinos (através de perfis do Skaffold).

Quando usa o ficheiro skaffold.yaml gerado como ponto de partida para criar a sua própria configuração do Skaffold diferenciada, certifique-se de que usa o ficheiro no arquivo de origem de renderização e não no ficheiro renderizado. A origem da renderização está disponível para transferência no separador Artefactos na página Detalhes do lançamento.

Este skaffold.yaml gerado está incluído na origem de renderização armazenada num contentor do Cloud Storage.

Pode ver este ficheiro transferindo o ficheiro .tar.gz e extraindo-o.
O skaffold.yaml renderizado está disponível em Artefactos de destino.

Na secção Artefactos de destino, clique em Ver artefactos.

Usar o Skaffold para o desenvolvimento local

Um dos pontos fortes do Skaffold é que pode usá-lo para desenvolvimento local e para CI/CD. No modo dev, o Skaffold monitoriza os seus ficheiros de origem e, quando deteta uma alteração, recompila as imagens, volta a testar e reimplementa os contentores num cluster do minikube (por exemplo) na sua máquina local.

Quando usa o Skaffold desta forma, pode usar os mesmos comandos localmente que para a implementação remota.

Se usar o Skaffold para o desenvolvimento local, pode definir perfis do Skaffold separados para os seus alvos e uma secção de implementação predefinida para o desenvolvimento local.

Quando para o modo dev, o Skaffold limpa os artefactos implementados do cluster.

Usar o Skaffold para CI/CD

Além de usar o Skaffold para a criação e implementação locais contínuas, pode usar o Skaffold para CI/CD. O Cloud Deploy usa as funcionalidades de CI/CD no Skaffold para renderizar e aplicar os seus manifestos e implementar a sua aplicação nos destinos definidos, dadas as imagens de contentores criadas com uma ferramenta de CI, como o Cloud Build, e um registo de imagens, como o Artifact Registry.

Renderize, implemente e aplique

O Skaffold separa o processo de renderização de manifestos da implementação. O Cloud Deploy chama skaffold render para renderizar os manifestos e skaffold apply para os aplicar ao alvo.

Esta separação entre a renderização e a aplicação permite-lhe capturar o estado declarativo completo da sua aplicação na configuração, para que possa ser aplicado de forma segura e repetível (por exemplo, para reversões). Esta técnica também facilita as aprovações. Uma vez que os manifestos são renderizados para todos os alvos antes da primeira implementação, pode ver o YAML renderizado que vai ser aplicado a cada alvo.

O Cloud Deploy não suporta a utilização de outros implementadores para implementar a sua aplicação. No entanto, pode usar ferramentas como o Helm ou o Kustomize para a renderização.

Para saber como o Cloud Deploy implementa usando o kubectl como implementador, consulte a arquitetura do serviço Cloud Deploy.

Acerca dos perfis do Skaffold

Pode criar perfis do Skaffold separados, identificados em skaffold.yaml, numa secção profiles:.

Quando usa perfis do Skaffold com o Cloud Deploy, pode criar perfis separados para todos ou alguns dos seus destinos. Por exemplo, diferentes perfis para dev, staging e prod.

Os perfis não são necessários para usar o Skaffold no Cloud Deploy, mas são úteis para definir personalizações de manifestos entre os seus destinos, por exemplo, usando diferentes ficheiros kustomization.yaml do Kustomize por destino.

Adicione suporte do Kustomize ao seu `skaffold.yaml`

A integração da configuração do Kustomize com a configuração do Cloud Deploy/Skaffold consiste no seguinte:

Inclua um ficheiro kustomization.yaml entre os seus ficheiros de configuração.

Pode armazenar os ficheiros de configuração num diretório local ou num contentor do Cloud Storage.

No ficheiro skaffold.yaml, crie uma secção deploy para cada perfil.

Também pode ter uma secção deploy fora de quaisquer perfis definidos, se não estiver a usar perfis ou para uma configuração de implementação predefinida não associada a um perfil.

Segue-se um exemplo de configuração do Skaffold que mostra deployestâncias por perfil e usa uma app de exemplo fictícia denominada my-app:

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
    - image: my-app-web-profiles
      context: my-app-web-profiles
    - image: my-app-application-profiles
      context: my-app-application-profiles
  googleCloudBuild:
    projectId: ${PROJECT_ID}
profiles:
- name: local
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/local
- name: test
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/test
- name: staging
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/staging
- name: prod
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/prod
deploy:
  kubectl: {}

A configuração do Skaffold apresentada aqui tem perfis separados para os destinos test, staging e prod. Também mostra um perfil para desenvolvimento local. Em cada perfil, existe uma secção deploy.kustomize com um caminho que aponta para a localização da personalização a usar para esse destino.

Adicione suporte do Helm ao seu `skaffold.yaml`

Pode usar o Helm para renderizar os seus manifestos. O Cloud Deploy não usa o Helm para implementar as suas aplicações e suporta apenas o kubectl como implementador.

Para usar o Helm, precisa do seu gráfico ou gráficos do Helm, armazenados em qualquer localização que possa referenciar a partir do seu skaffold.yaml. Esta localização pode estar num sistema de ficheiros, num repositório, possivelmente juntamente com o seu skaffold.yaml ou num repositório da Open Container Initiative (OCI).

Para usar um gráfico Helm, adicione uma secção helm ao ficheiro skaffold.yaml.

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
  - image: skaffold-helm-image
manifests:
  helm:
    releases:
    - name: skaffold-helm-image
      chartPath: charts
deploy:
  kubectl: {}

A skaffold.yaml referência mostra o que é necessário nesta helm secção.

Funcionalidades do Skaffold não suportadas

Não é possível usar as seguintes funcionalidades do Skaffold no Cloud Deploy:

Hooks do ciclo de vida
Módulos de andaimes dinâmicos

A utilização de --module= para selecionar módulos específicos para build, render, apply, etc., não é suportada. Os módulos estáticos são suportados.
No Helm, a capacidade de criar um espaço de nomes se não existir.

O que se segue?

Visite o site do Skaffold para saber como funciona e o que pode fazer por si.
Pratique com o Cloud Deploy com perfis do Kustomize e do Skaffold.
Saiba como o Cloud Deploy seleciona a versão do Skaffold a usar, quando a versão do Skaffold muda e como determinar que versão está a ser usada.
Saiba como usar perfis do Skaffold com ferramentas avançadas de gestão de manifestos, como o Helm, o Kustomize e o kpt.