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 o 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 conhecer 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 golang simples
• Gerenciar a implantação de aplicativos locais com o Skaffold
• Renderizar manifestos e implantar o aplicativo

2. Antes de começar

Como preparar seu espaço de trabalho

1. Para abrir o editor do Cloud Shell, acesse o seguinte URL:

https://shell.cloud.google.com

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

2. Se ainda não fez isso, clone a origem do aplicativo na janela do terminal 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 seu projeto

1. Execute o seguinte comando para verificar se o projeto do Google Cloud está configurado corretamente:

gcloud config set project {{project-id}}

3. Primeiros passos com o Skaffold

1. Execute o comando abaixo para criar o arquivo de configuração de nível superior do Skaffold, 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 ambiente de desenvolvimento integrado. 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, assim como os perfis para cada destino de implantação.

Leia mais sobre a lista completa de estágios do Skaffold na documentação sobre os estágios do pipeline do Skaffold.

4. Criar

A seção build contém a configuração que define como o aplicativo precisa ser criado. Nesse caso, você pode conferir a configuração de como as tags git devem ser processadas, bem como uma seção artifacts que define as imagens do 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. Além disso, o Skaffold oferece suporte a outras ferramentas de build, como Jib, Maven, Gradle, Buildpacks nativo da nuvem, Bazel e scripts personalizados. Leia mais sobre essa configuração na documentação do Skaffold Build.

5. Implantar

A seção deploy contém a configuração que define como o aplicativo deve ser implantado. Neste 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 uma ou mais metas de implantação, geralmente desenvolvimento, teste, estágio e produção ou algo semelhante.

Neste exemplo, há duas sobreposições para três destinos: dev, estágio e prod. A sobreposição dev será usada durante o desenvolvimento local, e as sobreposições estágio e prod serão usadas para implantações usando o Skaffold.

6. Perfis

A seção profiles contém configurações de build, teste e implantação para diferentes contextos. Diferentes contextos 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 itens da configuração principal, como as seções build, test ou deploy.

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

Como navegar pelo código-fonte do aplicativo.

1. Abra o arquivo app > main.go a seguir no painel do ambiente de desenvolvimento integrado. Este é 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 visualizar o Dockerfile

1. Abra o arquivo app > Dockerfile no painel do ambiente de desenvolvimento integrado. 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 saída abaixo se o cluster tiver sido iniciado:

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 o aplicativo e implantá-lo em um cluster local do Kubernetes em execução no Cloud Shell:

skaffold dev

O processo de build do contêiner do aplicativo será executado, o que pode levar um minuto, e a saída do aplicativo será repetida a cada segundo:

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

O nome exato do pod vai variar em relação à saída genérica acima.

Fazer mudanças no aplicativo

Agora que o aplicativo está em execução no cluster local do Kubernetes, você pode fazer alterações no código, e o Skaffold vai recriar e reimplantar o aplicativo no cluster automaticamente.

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

"Hello world from pod %s!\n"

para:

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

Depois de fazer a alteração, o Skaffold deve recriar a imagem e reimplantá-la no cluster, com a alteração 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)

O aplicativo vai ser recriado e implantado novamente, e a linha de saída vai aparecer a cada 10 segundos.

Como fazer mudanças na configuração do Kubernetes

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

1. Abra o arquivo base > deployment.yaml no ambiente de desenvolvimento integrado e mude a linha:

replicas: 1

a

replicas: 2

Depois que o aplicativo for reimplantado, dois pods vão aparecer 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, de modo que apenas um deles vai permanecer.

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 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 implantar nos clusters, este arquivo contém as informações de lançamento. Isso significa que os artefatos não podem ser alterados no trajeto ativo.

2. Execute o comando abaixo 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 na fase de testes

1. Execute o seguinte comando 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ê vai notar a saída de dois pods semelhantes 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 seguinte comando para observar o aplicativo em execução no cluster:

kubectl get all --namespace staging

Você vai encontrar 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 seguinte comando 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ê vai notar a saída de três pods semelhantes 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 encontrar três nomes de pods distintos, 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 que contém linhas semelhantes a esta, mostrando 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 encontrar três pods de aplicativo 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.

O que vem em seguida:

Continue aprendendo mais sobre o Skaffold:

• Análise detalhada do Skaffold

Limpeza

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

minikube delete