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. O Skaffold pode ser usado 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 trabalhar em alguns dos principais conceitos do Skaffold, usá-lo para automatizar o 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. Acesse o seguinte URL para abrir o editor do Cloud Shell:

https://shell.cloud.google.com

Permitir cookies de terceiros. Clique em "Site indisponível" e selecione "Permitir cookies".

2. Na janela do terminal, clone a origem do aplicativo com o seguinte comando, caso ainda não tenha feito isso:

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

3. Altere 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. Verifique se o projeto do Google Cloud está configurado corretamente executando o seguinte comando:

gcloud config set project {{project-id}}

3. Primeiros passos com o Skaffold

1. Execute o comando a seguir 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. Esse é 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 de estágios do pipeline do Skaffold.

4. Criar

A seção build contém uma configuração que define como o aplicativo deve ser criado. Nesse caso, é possível ver a configuração de processamento das tags git, 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ê vai encontrar a referência ao Dockerfile que será usado para criar as imagens. O Skaffold também oferece suporte a outras ferramentas de build, como Jib, Maven, Gradle, Buildpacks, Bazel e scripts personalizados nativos da nuvem. Leia mais sobre essa configuração na documentação do build do Skaffold (em inglês).

5. Implantar

A seção deploy contém uma configuração que define como o aplicativo deve ser implantado. Neste caso, há um exemplo de implantação padrão que configura o Skaffold para usar a ferramenta Kustomize.

A ferramenta Kustomize oferece funcionalidades 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 normalmente correspondem a um ou mais destinos de implantação: dev, test, staging e production ou similares.

Neste exemplo, você vê 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 para implantação com o Skaffold.

6. Perfis

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

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

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

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 o ambiente do Kubernetes

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

minikube start

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

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

Você verá o processo de criação 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 ser diferente da saída genérica mostrada acima.

Como fazer alterações no aplicativo

Agora que o aplicativo está em execução no seu cluster local do Kubernetes, é possível fazer alterações no código. O Skaffold vai automaticamente recriar e reimplantar o aplicativo no cluster.

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, altere a linha:

time.Sleep(time.Second * 1)

a

time.Sleep(time.Second * 10)

Novamente, o aplicativo será recriado e reimplantado, com a linha de saída a cada 10 segundos.

Como fazer alterações na configuração do Kubernetes

Em seguida, você fará uma alteração na configuração do Kubernetes e, mais uma vez, o Skaffold reimplanta 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

Você verá um dos pods removido de serviço, restando 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 e implantando-a em um cluster.

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

skaffold build --file-output artifacts.json

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

Se você quer usar uma ferramenta como o Cloud Deploy para implantar nos clusters, este arquivo contém as informações de versão. Isso significa que os artefatos não podem ser alterados no caminho para ficar ativo.

2. Execute o seguinte comando para ver 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 preparo

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 estiver concluída, a saída de dois pods será 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 seguinte comando para observar o aplicativo em execução no cluster:

kubectl get all --namespace staging

Você verá dois nomes de pod diferentes, porque o perfil staging do aplicativo especifica que é preciso 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, a saída de três pods será 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ê verá três nomes de pods diferentes, porque o perfil prod do aplicativo especifica que é preciso haver três réplicas na implantação.

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

kubectl get all --namespace prod

A saída vai conter linhas semelhantes às seguintes 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 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 do 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 seguinte comando para encerrar o cluster local:

minikube delete