Esta página foi traduzida pela API Cloud Translation.

Introdução ao Skaffold no Cloud Deploy

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

Como configurar o Skaffold para uso com um pipeline de entrega do Cloud Deploy
Usar o Skaffold e o Cloud Deploy com ferramentas de renderização de terceiros, como Helm e Kustomize
Opcionalmente, use o Skaffold para desenvolvimento local
Opcionalmente, use o Skaffold para integração e implantação contínuas (CI/CD)

Por que usar o Skaffold?

Quer saber por que o Cloud Deploy usa o Skaffold e por que você precisa gerenciar uma configuração do Skaffold? Continue lendo.

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

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

O Skaffold oferece configuração portátil e declarativa usando uma arquitetura conectável, permitindo que você use diferentes ferramentas para a fase de renderização.

Quando uma versão é criada, o Cloud Deploy chama o Skaffold para renderizar seus manifestos. No momento da implantação, o Cloud Deploy chama o Skaffold novamente para aplicar esses manifestos e implantar o aplicativo em cada destino na progressão. Após a implantação, o Skaffold realiza verificações de integridade para monitorar o tempo de execução de destino para uma implantação bem-sucedida.

Skaffold para desenvolvimento contínuo

Quando você usa o Skaffold para desenvolvimento contínuo, as imagens são criadas, testadas e implantadas em um cluster (ou Minikube) conforme você muda o código. As extensões do ambiente de desenvolvimento integrado Cloud Code para VS Code e Cloud Code para IntelliJ integram o Skaffold ao Visual Studio Code e ao JetBrains IDEs, para desenvolvimento contínuo.

Skaffold para entrega contínua

Você também pode usar o Skaffold para entrega contínua, com etapas de criação, implantação, renderização e aplicação. O Cloud Deploy usa os recursos de renderização e aplicação do Skaffold. Para usar o Cloud Deploy, você precisa de pelo menos um arquivo de configuração skaffold.yaml válido.

Com o Skaffold, também é possível fazer a integração com ferramentas de gerenciamento de manifestos de terceiros, como Helm e Kustomize. O uso do Skaffold dessa forma permite que você use os recursos dessas ferramentas para renderizar manifestos. kubectl continua sendo o deployer desses manifestos.

Sou iniciante na implantação no Kubernetes

Com o Skaffold, é possível configurar um conjunto básico de manifestos para todas as implantações. Em seguida, use o mecanismo de renderização do Skaffold, pelo Cloud Deploy, para renderizar e implantar cada manifesto específico de implantação de um desses manifestos de base.

Leia mais sobre como gerenciar manifestos, incluindo exemplos de uso do Skaffold e do Cloud Deploy com ferramentas comuns de modelos de manifestos, como Helm e Kustomize.

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

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

As informações de cabeçalho de que todas as configurações de skaffold.yaml precisam:
```
apiVersion: skaffold/v4beta7
kind: Config
```
Uma estrofe manifests para o GKE, GKE Enterprise ou o Cloud Run que lista todos os manifestos brutos do Kubernetes, a menos que você esteja usando uma ferramenta de gerenciamento de manifestos, como o Helm ou o Kustomize.

Confira um exemplo que usa um manifesto bruto do Kubernetes:
```
manifests:
  rawYaml:
  - deployment.yaml
```
Se você planeja usar um renderizador (como o Helm ou o Kustomize) para renderizar manifestos, consulte Adicionar suporte ao Helm ao skaffold.yaml e Adicionar suporte ao Kustomize ao skaffold.yaml para orientações sobre como configurar o Skaffold para usar essas ferramentas.

Para exemplos do Helm e do Kustomize, consulte Gerenciar manifestos.
Uma estrofe deploy, com deploy.kubectl, para implantação no GKE ou no GKE Enterprise, ou deploy.cloudrun para implantação no Cloud Run.

Para destinos do GKE e do GKE Enterprise:
```
deploy:
  kubectl: {}
```
A estrofe de implantação implanta os manifestos do aplicativo que foram fornecidos na estrofe de manifestos.

Para destinos do Cloud Run:
```
deploy:
  cloudrun: {}
```
A estrofe de implantação implanta os manifestos de aplicativos fornecidos na estrofe de manifestos.

Se você estiver usando alvos personalizados, o skaffold.yaml precisa 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 não já referenciar uma configuração remota do Skaffold.

Crie um arquivo `skaffold.yaml`

O Cloud Deploy usa o Skaffold para renderizar e implantar seus aplicativos.

Para cada versão, é necessário fornecer pelo menos um arquivo skaffold.yaml que identifique os manifestos a serem usados. Consulte a seção anterior para ver orientações sobre o que precisa ser incluído nesse arquivo.

Fazer com que o Cloud Deploy gere o `skaffold.yaml`

Se você não tiver um arquivo skaffold.yaml, mas tiver um único manifesto do Kubernetes ou um arquivo de definição de serviço do Cloud Run, o Cloud Deploy poderá gerar um arquivo skaffold.yaml para você.

O arquivo Skaffold gerado vai ficar disponível no diretório de preparação da origem do Cloud Storage após a conclusão da versão.

O comando a seguir 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 de um YAML de serviço do Cloud Run, use o mesmo comando, mas com --from-run-manifest em vez de --from-k8s-manifest.

O uso de qualquer uma dessas flags com a --skaffold-file ou a --source gera um erro.

Como usar o arquivo `skaffold.yaml` gerado

O skaffold.yaml gerado é adequado para integração, aprendizado e demonstração do Cloud Deploy. Depois de se familiarizar com o Cloud Deploy, para cargas de trabalho de produção, talvez você queira uma configuração do Skaffold que diferencia seus destinos (usando perfis do Skaffold).

Ao usar o arquivo skaffold.yaml gerado como ponto de partida para criar sua própria configuração diferenciada do Skaffold, use o arquivo no arquivo de origem de renderização, não o arquivo renderizado. A origem de renderização está disponível para download na guia Artifacts na página **Detalhes do lançamento **.

Esse skaffold.yaml gerado é incluído na origem de renderização armazenada em um bucket do Cloud Storage.

Para conferir esse arquivo, faça o download e extraia o arquivo .tar.gz.
O skaffold.yaml renderizado está disponível em Artefatos de destino.

Na seção Artefatos de destino, clique em Conferir artefatos.

Como usar o Skaffold para desenvolvimento local

Uma das vantagens do Skaffold é que ele pode ser usado para desenvolvimento local e para CI/CD. No modo dev, o Skaffold monitora seus arquivos de origem e, quando detecta uma mudança, reconstrói as imagens, testa novamente e implanta os contêineres em um cluster minikube (por exemplo) na máquina local.

Ao usar o Skaffold dessa maneira, você pode usar os mesmos comandos localmente, como na implantação remota.

Se você usa o Skaffold para desenvolvimento local, pode definir perfis separados do Skaffold para seus destinos e uma estrofe de implantação padrão para desenvolvimento local.

Quando você interrompe o modo dev, o Skaffold limpa os artefatos implantados do cluster.

Como usar o Skaffold para CI/CD

Além de usar o Skaffold para build e implantação locais contínuos, você pode usar o Skaffold para CI/CD. O Cloud Deploy usa os recursos de CI/CD do Skaffold para renderizar e aplicar seus manifestos e implantar o aplicativo para os destinos definidos, considerando imagens de contêiner criadas usando uma ferramenta de CI, como o Cloud Build, e um registro de imagem, como o Artifact Registry.

Renderizar, implantar e aplicar

O Skaffold separa o processo de renderização do manifesto da implantação. O Cloud Deploy chama skaffold render para renderizar os manifestos e skaffold apply para aplicá-los ao destino.

Essa separação entre renderização e aplicação permite capturar o estado declarativo completo do aplicativo na configuração, para que ele possa ser aplicado com segurança e de forma repetível (por exemplo, para rollbacks). Essa técnica também facilita as aprovações. Como os manifestos são renderizados para todos os destinos antes do primeiro lançamento, é possível conferir o YAML renderizado que será aplicado a cada destino.

O Cloud Deploy não oferece suporte ao uso de outros implantadores para implantar seu aplicativo. No entanto, é possível usar ferramentas como o Helm ou o Kustomize para renderização.

Para saber mais sobre como o Cloud Deploy implanta usando kubectl como o implantador, consulte Arquitetura do serviço do Cloud Deploy.

Sobre os perfis do Skaffold

É possível criar perfis separados do Skaffold, identificados em skaffold.yaml, em uma estrofe profiles:.

Ao usar perfis do Skaffold com o Cloud Deploy, você pode criar perfis separados para todos ou alguns dos destinos. Por exemplo, perfis diferentes 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 manifesto entre seus destinos, por exemplo, usando diferentes arquivos kustomization.yaml do Kustomize por destino.

Adicionar suporte ao Kustomize ao `skaffold.yaml`

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

Inclua um arquivo kustomization.yaml entre os arquivos de configuração.

É possível armazenar seus arquivos de configuração em um diretório local ou em um bucket do Cloud Storage.

No arquivo skaffold.yaml, crie uma estrofe deploy para cada perfil.

Você também pode ter uma estrofe deploy fora de qualquer perfil definido, se não estiver usando perfis ou para uma configuração de implantação padrão não vinculada a um perfil.

Confira a seguir um exemplo de configuração do Skaffold que mostra estrofes deploy por perfil e usa um app de exemplo fictício chamado 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 mostrada aqui tem perfis separados para destinos test, staging e prod. Ele também mostra um perfil para desenvolvimento local. Em cada perfil, há uma estrofe deploy.kustomize com um caminho que aponta para o local da kustomização a ser usada para esse destino.

Adicionar suporte ao Helm ao `skaffold.yaml`

É possível usar o Helm para renderizar seus manifestos. O Cloud Deploy não usa o Helm para implantar seus aplicativos e oferece suporte apenas ao kubectl como implantador.

Para usar o Helm, você precisa de um ou mais gráficos do Helm armazenados em qualquer local que possa ser referenciado no skaffold.yaml. Esse local pode estar em um sistema de arquivos, um repositório, possivelmente com o skaffold.yaml ou um repositório da Open Container Initiative (OCI).

Para usar um gráfico do Helm, adicione uma estrofe helm ao arquivo 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 referência skaffold.yaml mostra o que é necessário nesta seção helm.

Recursos do Skaffold sem suporte

Os recursos a seguir do Skaffold não podem ser usados no Cloud Deploy:

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

Não é possível usar --module= para selecionar módulos específicos para build, render, apply e assim por diante. Os módulos estáticos são compatíveis.
No Helm, a capacidade de criar um namespace se ele não existir.

A seguir

Acesse o site da Skaffold para saber como ele funciona e o que ele pode fazer por você.
Pratique o uso do Cloud Deploy com perfis do Skaffold e do Kustomize.
Saiba como o Cloud Deploy seleciona a versão do Skaffold a ser usada, quando a versão do Skaffold muda e como determinar qual versão está em uso.
Saiba como usar os perfis do Skaffold com ferramentas avançadas de gerenciamento de manifestos, como Helm, Kustomize e kpt.