Estime seus custos do GKE no início do ciclo de desenvolvimento usando o GitHub

Last reviewed 2021-06-30 UTC

Neste tutorial, você verá a prática recomendada de mudar a visibilidade dos custos do Google Kubernetes Engine (GKE) para a equipe de desenvolvimento. Essa prática de mudança para a esquerda gera reconhecimento de custos no início do processo, ajudando a evitar surpresas na sua fatura do Google Cloud.

Este tutorial é destinado a desenvolvedores, operadores e profissionais especializados do FinOps que querem otimizar custos em clusters do GKE e que usam o GitHub na produção. Se você usa o GitLab, consulte Estimar os custos do GKE no início do ciclo de desenvolvimento usando o GitLab.

O tutorial pressupõe que você esteja familiarizado com oDocker ,GitHub Kubernetes ,GKE ,Cloud Build e Linux.

Visão geral

Muitas equipes que estão adotando a nuvem pública não são adotadas no estilo de faturamento de pagamento por utilização. Muitas vezes, eles não entendem completamente o ambiente em que os aplicativos estão sendo executados. Neste caso, o GKE. O modelo operacional FinOps promove essa cultura de responsabilidade financeira. Uma prática recomendada do FinOps é fornecer informações às equipes em tempo real sobre gastos, para que os problemas de custo possam ser tratados assim que surgirem.

Neste documento, mostramos como dar um passo além, estimando o custo antes de se tornar uma despesa na sua fatura. Conforme destacado no site do GitHub (em inglês), "No GitHub, ferramentas de revisão de código leves são integradas a todas as solicitações de envio." Isso permite que você "envolva projetos, proponha novos recursos e discuta detalhes de implementação antes de alterar o código-fonte. O melhor momento para estimar custos é no início do processo durante o desenvolvimento e no momento da revisão do código. Dessa forma, os profissionais podem entender e discutir alternativas para o impacto de custo de novos recursos e correções de bugs antes que se torne um problema. O diagrama a seguir resume essa prática.

Prática recomendada para estimar custos antecipadamente.

Como o diagrama mostra, um desenvolvedor estima os custos do GKE no ambiente local, idealmente no momento da criação. Essa estimativa fornece um bom entendimento do custo mensal da carga de trabalho de produção. Quando a correção de recurso ou bug for concluída, ele proporá uma solicitação de envio que aciona o Cloud Build para verificar a diferença entre o custo antigo e o novo. Se houver aumentos acima de um limite predefinido, eles poderão solicitar uma nova revisão de código. Essa prática ajuda os desenvolvedores a se familiarizarem com a capacidade de carga de trabalho e a corrigir proativamente problemas de aplicativos em vez de adicionar mais recursos sempre que uma instabilidade for encontrada na produção.

Objetivos

  • Crie e envie a imagem do estimador de custo do Kubernetes.
  • Crie um repositório do GitHub.
  • Conectar o Cloud Build ao seu repositório GitHub.
  • Envie o código de exemplo para seu repositório do GitHub.
  • Altere o código e proponha uma solicitação de envio para ver a estimativa de custo em ação.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

  1. No console do Google Cloud, acesse a página do seletor de projetos.

    Acessar o seletor de projetos

  2. Selecione ou crie um projeto do Google Cloud.

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  4. No Console do Google Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

Como preparar o ambiente

  1. No Cloud Shell, clone o repositório gke-shift-left-cost do GitHub:

    git clone https://github.com/GoogleCloudPlatform/gke-shift-left-cost
cd gke-shift-left-cost

    O código nesse repositório está estruturado nas seguintes pastas:

    • Raiz: contém um arquivo Dockerfile usado para criar a imagem do estimador de custo e o arquivo main.go que implementa a lógica de linha de comando para o estimador.
    • api/: contém a API Golang para manipular objetos do Kubernetes e fazer a estimativa de custo.
    • samples/: contém exemplos de manifestos do Kubernetes para que você possa testar o processo antes de implementá-lo na sua organização.

  2. Defina o ID do projeto do Cloud, o usuário e o endereço de e-mail do GitHub e outro usuário do GitHub para atuar como o revisor FinOps:

    export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITHUB_USER=YOUR_GITHUB_USER
export GITHUB_EMAIL=YOUR_GITHUB_EMAIL_ADDRESS
export GITHUB_FINOPS_REVIEWER_USER=ANOTHER_GITHUB_USER

    Substitua:

    • YOUR_PROJECT_ID: o ID do projeto do Cloud que você está usando neste tutorial.
    • YOUR_GITHUB_USER: o usuário usado para fazer login na conta do GitHub.
    • YOUR_GITHUB_EMAIL_ADDRESS: o e-mail que você usa na sua conta do GitHub.
    • ANOTHER_GITHUB_USER: outro usuário do GitHub para atuar como revisor do FinOps. Observe que neste tutorial é necessário adicionar esse usuário como um colaborador do repositório e, portanto, ele não pode ser você mesmo. Para evitar que fique preso durante as etapas do tutorial, verifique se esse usuário aceita seu convite assim que você o cria.

  3. Defina o projeto do Cloud e ative as APIs necessárias:

    gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com

Como criar e enviar a imagem do estimador de custo do Kubernetes

A ferramenta de estimativa de custo do Kubernetes que acompanha este tutorial é apenas um exemplo do que pode ser feito. Ele oferece a capacidade de estimar custos para objetos DaemonSet, Deployment, StatefulSet, ReplicaSet, HorizontalPodAutoScaler e PersistentVolumeClaim Kubernetes. Também é possível implementar sua própria ferramenta de estimativa de custos ou propor solicitações de envio com as melhorias que quiser.

  1. No Cloud Shell, permita que application-default use suas credenciais:

    gcloud auth application-default login

  2. Crie o binário do estimador de custo do Kubernetes:

    mkdir ./bin
go test ./api
go build -v -o ./bin/k8s-cost-estimator .

  3. Execute uma estimativa de custo em uma pasta de amostra para testar o binário:

    ./bin/k8s-cost-estimator \
    --k8s ./samples/k8s-cost-estimator-local/app-v1  \
    --config ./samples/k8s-cost-estimator-local/example-conf.yaml --v trace

    Na saída, você verá uma tabela Markdown que detalha os custos estimados mensais da pasta ./samples/k8s-cost-estimator-local/app-v1/. Para entender melhor o custo de produção mensal dos aplicativos, os desenvolvedores podem executar essa etapa antes de enviá-la para o repositório remoto.

    INFO[0000] Starting cost estimation (version v0.0.1)...
...

|         KIND          | MIN REQUESTED (USD) | MIN REQ + HPA CPU BUFFER (USD) | MAX REQUESTED (USD) | MIN LIMITED (USD) | MAX LIMITED (USD) |
|-----------------------|---------------------|--------------------------------|---------------------|-------------------|-------------------|
| Deployment            |             $133.31 |                        $198.71 |             $266.54 |           $312.83 |           $579.29 |
| StatefulSet           |              $36.33 |                         $36.33 |              $36.33 |            $72.67 |            $72.67 |
| DaemonSet             |              $29.68 |                         $29.68 |              $29.68 |            $53.19 |            $53.19 |
| PersistentVolumeClaim |              $28.88 |                         $28.88 |              $28.88 |            $33.68 |            $33.68 |
| **TOTAL**             |         **$228.20** |                    **$293.60** |         **$361.43** |       **$472.38** |       **$738.83** |

INFO[0002] Finished cost estimation!

  4. Crie a imagem do contêiner do Estimador de custos do Kubernetes:

    docker build . -t us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

  5. Crie o repositório do Docker do Artifact Registry para armazenar a imagem:

    gcloud artifacts repositories create docker-repo \
        --repository-format=docker \
        --location=us-central1 \
        --description="Docker repository"

  6. Registre gcloud como o auxiliar de credencial do arquivo de configuração do Docker. Se solicitado, confirme a atualização do arquivo.

    gcloud auth configure-docker us-central1-docker.pkg.dev

  7. Enviar a imagem para o Artifact Registry

    docker push us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Como criar um novo repositório do GitHub

  1. No Cloud Shell, altere os diretórios para o exemplo do GitHub:

    cd samples/k8s-cost-estimator-github

  2. No GitHub, crie um token de acesso:

    Navegue até a página Tokens de acesso pessoal do GitHub.

    1. No campo Observação, insira uma descrição do token.
    2. Em Selecionar escopos, marque as caixas de seleção repo, admin:public_key e delete_repo.
    3. Clique em Gerar token e copie o valor Seu novo token de acesso pessoal na parte superior da página.

  3. No Cloud Shell, salve o token de acesso pessoal em uma variável.

    GITHUB_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN

    Substitua:

    • YOUR_NEW_PERSONAL_ACCESS_TOKEN: o token de acesso pessoal que você acabou de criar.

  4. Crie um repositório do GitHub. 

    curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/repos \
  -d '{"name":"k8s-cost-estimator-github"}' | jq

    A resposta será semelhante a:

    {
  "id": 36099474,
  "node_id": "MDEwOldfsdjA5OTQ3Njc=",
  "name": "k8s-cost-estimator-github",
  ...
}

  5. Adicione o revisor FinOps como um colaborador no seu repositório:

    curl -X PUT \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github/collaborators/$GITHUB_FINOPS_REVIEWER_USER  | jq -r .html_url

    A resposta será semelhante a:

    https://github.com/your-user/k8s-cost-estimator-github/invitations

  6. Compartilhe o URL de saída com o usuário definido na variável GITHUB_FINOPS_REVIEWER_USER para que ele possa aceitar o convite. Antes de prosseguir para a próxima etapa, acesse o mesmo URL para garantir que o convite foi aceito.

    Verifique se o convite foi aceito.

Como conectar diretamente o Cloud Build ao seu repositório GitHub

Esta seção mostra como instalar oAplicativo Cloud Build GitHub Essa instalação permite que você conecte seu repositório do GitHub ao projeto do CloudCloud para que o Cloud Build possa executar automaticamente a ferramenta estimador do Kubernetespega em cada solicitação de envio.

  1. Acesse a página do Marketplace do GitHub para o aplicativo Cloud Build:

    Abrir a página do aplicativo Cloud Build (em inglês)

  2. Configure o acesso da conta do GitHub ao app:

    1. Se esta for a primeira vez que você configura um app no GitHub, clique em Setup with Google Cloud Build, na parte inferior da página, e em Conceder a esse app acesso à sua conta do GitHub.
    2. Se você já configurou um aplicativo no GitHub, clique em Configurar acesso.

  3. Na página Aplicativos, siga estas etapas:

    1. Na linha do Google Cloud Build, clique em Configurar.
    2. Selecione a opção Somente repositórios selecionados.
    3. Selecione k8s-cost-estimator-github para se conectar ao repositório que você acabou de criar.
    4. Clique em Salvar ou Instalar. O rótulo do botão muda de acordo com o fluxo que você está executando.

  4. Você será redirecionado para o Google Cloud para continuar a instalação. Faça login com sua conta do Google Cloud. Se solicitado, autorize a integração do Cloud Build com o GitHub.

  5. Na página Cloud Build, selecione o projeto. Um assistente será exibido.

  6. Na seção Selecionar repositório do assistente, selecione sua conta do GitHub e o repositório k8s-cost-estimator-github.

  7. Se você concordar com os termos e condições, marque a caixa de seleção e clique em Conectar.

  8. Na seção Criar um acionador, clique em Criar um acionador e siga estas etapas:

    1. Insira o nome de um acionador.
    2. Na seção Evento, selecione Solicitação de envio (somente aplicativo do GitHub).
    3. Na seção Origem:
      • Verifique se o campo Repository está preenchido automaticamente com your-github-user/k8s-cost-estimator-github (app do GitHub).
      • Na lista suspensa Base Branch, selecione .*.
    4. Na seção Tipo de configuração, selecione Arquivo de configuração do Cloud Build (yaml ou json).

    5. Na seção Avançado, adicione as seguintes variáveis de substituição:

      • _GITHUB_TOKEN = YOUR_PERSONAL_ACCESS_TOKEN
      • _GITHUB_FINOPS_REVIEWER_USER = THE_GITHUB_FINOPS_REVIEWER_USER
      • _GITHUB_FINOPS_COST_USD_THRESHOLD = 10

      Substitua:

      • YOUR_PERSONAL_ACCESS_TOKEN: o token de acesso pessoal do GitHub que você criou. Esse token está disponível na variável GITHUB_TOKEN no Cloud Shell.
      • THE_GITHUB_FINOPS_REVIEWER_USER: o usuário que você convidou como um colaborador no seu repositório do GitHub. Esse nome de usuário está disponível na variável GITHUB_FINOPS_REVIEWER_USER no Cloud Shell.

  9. Clique em Criar.

O app GitHub do Cloud Build agora está configurado, e seu repositório do GitHub está vinculado ao seu projeto do Google Cloud. As solicitações de envio para seu repositório do GitHub agora acionam execuções do Cloud Build, que informam os resultados de volta ao GitHub usando as Verificações do GitHub.

Como enviar o código de exemplo para seu repositório do GitHub

  1. Crie um par de chaves SSH para enviar o código de amostra ao seu repositório do GitHub:

    mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f github-key
eval `ssh-agent` && ssh-add $(pwd)/github-key
curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/keys \
  -d "{\"title\":\"k8s-cost-estimator-key\", \"key\":\"$(cat github-key.pub)\"}" | jq
cd ..

    A resposta será semelhante a:

    {
  "id": 52356205,
  "key": "ssh-rsa AAAAB3NzaC….wJICyt0yvWjGFZGCWBPUw==",
  "url": "https://api.github.com/user/keys/526205",
  "title": "k8s-cost-estimator-key",
  "verified": true,
  "created_at": "2021-04-23T16:22:58Z",
  "read_only": false
}

  2. Envie o conteúdo para o novo repositório do GitHub:

    sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITHUB_USER/$GITHUB_USER/g; s/GITHUB_EMAIL/$GITHUB_EMAIL/g;" templates/cloudbuild.yaml.tpl > cloudbuild.yaml

GITHUB_SSH_URL_REPO=$(curl -X GET \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github | jq -r .ssh_url)
[ -z "$GITHUB_SSH_URL_REPO" ] && echo "GITHUB_SSH_URL_REPO is not exported" || echo "GITHUB_SSH_URL_REPO is $GITHUB_SSH_URL_REPO"

git init
git remote add origin $GITHUB_SSH_URL_REPO
git add -A .
git commit -m "Initial commit"
git checkout -b main
git push -u origin main

Como alterar o código e propor uma solicitação de envio para testar a estimativa de custo

  1. No Cloud Shell, consiga o URL do GitHub para o arquivo wordpress/wordpress_hpa.yaml:

    echo "https://github.com/$GITHUB_USER/k8s-cost-estimator-github/edit/main/wordpress/wordpress_hpa.yaml"

  2. Ctrl + clique (Cmd + clique para usuários do Mac) o URL de saída para navegar até o GitHub e editar o arquivo wordpress/wordpress_hpa.yaml.

  3. No GitHub, altere minReplicas para 5.

  4. Selecione Criar um novo branch para esta confirmação e iniciar uma solicitação de envio e, em seguida, clique em Propor alterações.

  5. Na tela Open a pull request, clique em Create pull request.

    Além de criar uma nova solicitação de envio, esta etapa aciona uma execução do Cloud Build com base no arquivo cloudbuild.yaml criado anteriormente. Essa execução do Cloud Build usa a imagem de contêiner criada em Como criar e enviar a imagem do estimador de custo do Kubernetes e toma a decisão quando um revisor do FinOps é necessário.

  6. Aguarde cerca de um minuto até que o pipeline seja concluído. Quando terminar, um comentário com detalhes de custo será adicionado na solicitação de envio e, como o aumento no custo do código que você está propondo excedeu o limite de US $10, um revisor FinOps também será solicitado.

    A resposta será semelhante a:

    Um detalhamento dos custos é adicionado à solicitação de envio.

Agora você sabe como dar aos seus desenvolvedores visibilidade sobre os gastos no início do ciclo de desenvolvimento. Essa configuração ajuda você e sua organização a evitar surpresas na fatura do Google Cloud.

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste tutorial, exclua o projeto.

Exclua o projeto

  1. No Console do Google Cloud, acesse a página Gerenciar recursos.

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir o repositório do GitHub

Se você não quiser manter seu repositório do GitHub, siga estas etapas:

  1. No Cloud Shell, exclua o repositório do GitHub:

    curl -X DELETE \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github

    Se você perder a conexão com o Cloud Shell, precisará redefinir as variáveis GITHUB_TOKEN e GITHUB_USER.

A seguir