Noções básicas sobre o Skaffold

1. Objetivos

O Skaffold é uma ferramenta que lida com o fluxo de trabalho para criar, enviar e implantar seu aplicativo. É possível usar o Skaffold para configurar facilmente um espaço de trabalho de desenvolvimento local, simplificar seu loop de desenvolvimento interno e integrar com outras ferramentas, como Kustomize e Helm, para ajudar a gerenciar seus manifestos do Kubernetes.

Neste tutorial, você vai trabalhar com alguns conceitos básicos do Skaffold, usá-lo para automatizar seu loop de desenvolvimento interno e implantar um aplicativo.

Você vai:

• Configurar e ativar o Skaffold para desenvolvimento local
• Criar e executar um aplicativo simples em Go
• Gerenciar a implantação de aplicativos locais com o Skaffold
• Renderizar manifestos e implantar o aplicativo

2. Antes de começar

Preparar seu espaço de trabalho

1. Abra o editor do Cloud Shell acessando o seguinte URL:

https://shell.cloud.google.com

Permita cookies de terceiros. Clique em "O site não está funcionando" e depois em "Permitir cookies".

2. Se ainda não tiver feito isso, na janela de terminal, clone a origem do aplicativo com o seguinte comando:

git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git

3. Mude para o diretório do repositório clonado:

cd software-delivery-workshop/labs/understanding-skaffold/getting-started

4. Execute o comando a seguir para definir o espaço de trabalho do Cloud Shell como o diretório atual:

cloudshell workspace .

Como preparar o projeto

1. Verifique se o projeto do Google Cloud está definido corretamente executando o seguinte comando:

gcloud config set project {{project-id}}

3. Como começar a usar o Skaffold

1. Execute o comando a seguir para criar o arquivo de configuração do Skaffold de nível superior, skaffold.yaml:

cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF

2. Abra o arquivo skaffold.yaml no painel do IDE. Este é o arquivo de configuração de nível superior que define o pipeline do Skaffold.

Observe o formato YAML semelhante ao Kubernetes e as seguintes seções no YAML:

• build
• deploy
• profiles

Essas seções definem como o aplicativo deve ser criado e implantado, além de perfis para cada destino de implantação.

Leia mais sobre a lista completa de estágios do Skaffold na documentação (em inglês) sobre os estágios do pipeline do Skaffold.

4. Criar

A seção build contém a configuração que define como o aplicativo deve ser criado. Nesse caso, você pode ver a configuração de como as tags git devem ser processadas, bem como uma seção artifacts que define as imagens de contêiner que compõem o aplicativo.

Além disso, nesta seção, você pode conferir a referência ao Dockerfile que será usado para criar as imagens. O Skaffold também é compatível com outras ferramentas de build, como Jib, Maven, Gradle, Buildpacks e Bazel nativos da nuvem, além de scripts personalizados. Leia mais sobre essa configuração na documentação do build do Skaffold.

5. Implantar

A seção deploy contém a configuração que define como o aplicativo deve ser implantado. Nesse caso, você pode conferir um exemplo de implantação padrão que configura o Skaffold para usar a ferramenta Kustomize.

A ferramenta Kustomize oferece funcionalidade para gerar manifestos do Kubernetes combinando um conjunto de arquivos YAML de componentes comuns (no diretório base) com uma ou mais "sobreposições" que geralmente correspondem a um ou mais destinos de implantação, normalmente dev, test, staging e production ou semelhantes.

Neste exemplo, você pode ver duas sobreposições para três destinos: dev, staging e prod. A sobreposição dev será usada durante o desenvolvimento local, e as sobreposições staging e prod serão usadas ao implantar com o Skaffold.

6. Perfis

A seção profiles contém a configuração que define configurações de build, teste e implantação para diferentes contextos. Contextos diferentes geralmente são ambientes diferentes no pipeline de implantação do aplicativo, como staging ou prod neste exemplo. Isso significa que você pode gerenciar facilmente manifestos cujo conteúdo precisa ser diferente para diferentes ambientes de destino, sem repetir a configuração padrão.

A configuração na seção profiles pode substituir ou corrigir qualquer item da configuração principal (ou seja, as seções build, test ou deploy, por exemplo).

Por exemplo, abra o arquivo overlays > prod > deployment.yaml. O número de réplicas do aplicativo está configurado como três, substituindo a configuração básica.

Navegar pelo código-fonte do aplicativo.

1. Abra o arquivo app > main.go no painel do IDE. É um aplicativo golang simples que grava uma string em stdout a cada segundo.
2. Observe que o aplicativo também gera o nome do pod do Kubernetes em que está sendo executado.

Como ver o Dockerfile

1. Abra o arquivo app > Dockerfile no painel do IDE. Esse arquivo contém uma sequência de diretivas para criar a imagem do contêiner do aplicativo para o arquivo main.go e é referenciado no arquivo skaffold.yaml de nível superior.

7. Como desenvolver com o Skaffold

Como configurar seu ambiente do Kubernetes

1. Execute o comando a seguir para garantir que o cluster local do Kubernetes esteja em execução e configurado:

minikube start

Isso pode levar alguns minutos. Você vai ver a seguinte saída se o cluster tiver sido iniciado com sucesso:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

2. Execute o comando a seguir para criar namespaces do Kubernetes para dev, staging e prod:

kubectl apply -f namespaces.yaml

Você verá esta resposta:

namespace/dev created
namespace/staging created
namespace/prod created

Como usar o Skaffold para desenvolvimento local

1. Execute o comando a seguir para criar e implantar o aplicativo em um cluster local do Kubernetes em execução no Cloud Shell:

skaffold dev

Você vai ver o processo de build do contêiner do aplicativo ser executado, o que pode levar um minuto, e depois a saída do aplicativo se repetir a cada segundo:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

O nome exato do pod vai variar de acordo com a saída genérica acima.

Como fazer mudanças no aplicativo

Agora que o aplicativo está sendo executado no cluster local do Kubernetes, você pode fazer mudanças no código, e o Skaffold vai recriar e reimplantar automaticamente o aplicativo no cluster.

1. Abra o arquivo app > main.go no painel do IDE e mude a string de saída:

"Hello world from pod %s!\n"

para:

"Hello Skaffold world from pod %s!\n"

Quando você fizer a mudança, o Skaffold vai reconstruir a imagem e reimplantá-la no cluster, com a mudança na saída visível na janela do terminal.

2. Agora, também no arquivo "app > main.go" no painel do ambiente de desenvolvimento integrado, mude a linha:

time.Sleep(time.Second * 1)

a

time.Sleep(time.Second * 10)

Novamente, o aplicativo será reconstruído e reimplantado, com a linha de saída aparecendo uma vez a cada 10 segundos.

Fazer mudanças na configuração do Kubernetes

Em seguida, você fará uma mudança na configuração do Kubernetes, e o Skaffold vai reimplantar automaticamente mais uma vez.

1. Abra o arquivo base > deployment.yaml no IDE e mude a linha:

replicas: 1

a

replicas: 2

Depois que o aplicativo for reimplantado, você verá dois pods em execução, cada um com um nome diferente.

2. Agora, mude a mesma linha no arquivo base > deployment.yaml de volta para:

replicas: 1

Um dos pods será removido do serviço, deixando apenas um.

3. Por fim, pressione Ctrl-C na janela do terminal para interromper o desenvolvimento local do Skaffold.

Como cortar uma versão

Em seguida, você vai criar uma versão criando uma imagem de lançamento e implantando-a em um cluster.

1. Execute o comando a seguir para criar a versão:

skaffold build --file-output artifacts.json

Esse comando vai criar a imagem final (se necessário) e gerar os detalhes da versão no arquivo artifacts.json.

Se você quiser usar uma ferramenta como o Cloud Deploy para fazer a implantação nos seus clusters, esse arquivo vai conter as informações da versão. Isso significa que os artefatos são imutáveis no caminho para a publicação.

2. Execute o comando a seguir para conferir o conteúdo do arquivo artifacts.json:

cat artifacts.json | jq

O arquivo contém a referência à imagem que será usada na implantação final.

Como implantar no ambiente de preparo

1. Execute o comando a seguir para implantar a versão usando o perfil staging:

skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Quando a implantação for concluída, você verá a saída de dois pods semelhante a esta:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!

2. Pressione Ctrl+C na janela do terminal para interromper a saída do Skaffold.
3. Execute o comando a seguir para observar o aplicativo em execução no cluster:

kubectl get all --namespace staging

Você vai ver dois nomes de pods distintos, porque o perfil staging do aplicativo especifica que deve haver duas réplicas na implantação.

Como implantar a versão na produção

1. Agora execute o comando a seguir para implantar a versão usando o perfil prod:

skaffold deploy --profile prod --build-artifacts artifacts.json --tail

Quando a implantação for concluída, você verá a saída de três pods semelhante a esta:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!

2. Pressione Ctrl+C na janela do terminal para interromper a saída do Skaffold.

Você vai ver três nomes de pod diferentes, porque o perfil prod do aplicativo especifica que deve haver três réplicas na implantação.

3. Execute o comando a seguir para observar o aplicativo em execução no cluster:

kubectl get all --namespace prod

Você vai ver uma saída com linhas semelhantes a estas, que mostram a implantação de produção:

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

Você também vai ver três pods de aplicativos em execução.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. Parabéns!

Parabéns! Você concluiu o laboratório Understanding Skaffold e aprendeu a configurar e usar o Skaffold para desenvolvimento local e implantação de aplicativos.

Qual é a próxima etapa?

Saiba mais sobre o Skaffold:

• Análise detalhada do Skaffold

Limpeza

1. Execute o comando a seguir para desligar o cluster local:

minikube delete