Usar resumos de imagens de contentores em manifestos do Kubernetes

Este tutorial mostra aos programadores e operadores que implementam contentores no Kubernetes como usar resumos de imagens de contentores para identificar imagens de contentores. Um resumo da imagem do contentor identifica de forma única e imutável uma imagem do contentor.

A implementação de imagens de contentores através do resumo da imagem oferece várias vantagens em comparação com a utilização de etiquetas de imagens. Para mais informações sobre resumos de imagens, consulte o documento que acompanha este tutorial sobre a utilização de resumos de imagens de contentores antes de continuar.

O argumento image para contentores numa especificação de pod do Kubernetes aceita imagens com resumos. Este argumento aplica-se em todos os locais onde usa uma especificação de pod, como na secção template dos recursos Deployment, StatefulSet, DaemonSet, ReplicaSet, CronJob e Job.

Para implementar uma imagem através do resumo, usa o nome da imagem, seguido de @sha256: e do valor do resumo. Segue-se um exemplo de um recurso de implementação que usa uma imagem com um resumo. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídos entre os nós num cluster.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echoserver
        image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
        ports:
        - containerPort: 8080

Uma desvantagem da utilização de resumos de imagens é que não sabe o valor do resumo até publicar a imagem num registo. À medida que cria novas imagens, o valor de resumo muda e precisa de uma forma de atualizar os manifestos do Kubernetes sempre que implementa.

Este tutorial mostra como pode usar ferramentas como Skaffold, kpt, digester, kustomize, gke-deploy, e ko para usar resumos de imagens nos seus manifestos.

Recomendações

Este documento apresenta várias formas de usar resumos de imagens em implementações do Kubernetes. As ferramentas descritas neste documento são complementares. Por exemplo, pode usar o resultado de uma função kpt com o kustomize para criar variantes para diferentes ambientes. O Skaffold pode criar imagens com o ko e implementar as imagens nos seus clusters do Kubernetes com o kubectl ou o kpt.

O motivo pelo qual as ferramentas são complementares é que realizam edições estruturadas com base no modelo de recursos do Kubernetes (KRM). Este modelo torna as ferramentas conectáveis, e pode desenvolver a sua utilização das ferramentas para criar processos e pipelines que ajudam a implementar as suas apps e serviços.

Para começar, recomendamos a abordagem que funciona melhor com as suas ferramentas e processos existentes:

  • O Skaffold pode adicionar resumos às referências de imagens. Ativa esta função com uma pequena alteração de configuração. A adoção do Skaffold oferece vantagens adicionais, como a abstração da forma como diferentes ferramentas criam e implementam imagens de contentores.

  • Ao usar a ferramenta de análise como um webhook de admissão de mutação nos seus clusters do Kubernetes, pode adicionar resumos a todas as suas implementações com um impacto mínimo nos seus processos atuais de criação e implementação de imagens de contentores. O webhook do digestor também simplifica a adoção da autorização binária, porque só requer que seja adicionada uma etiqueta a um espaço de nomes.

  • O kpt é uma excelente opção se precisar de uma ferramenta flexível para manipular manifestos do Kubernetes. A ferramenta de digestão pode ser usada como uma função KRM do lado do cliente numa pipeline kpt.

  • Se já usa o kustomize para gerir manifestos do Kubernetes em vários ambientes, recomendamos que tire partido dos respetivos transformadores de imagens para implementar imagens por resumo.

  • ko é uma excelente forma de criar e publicar imagens para apps Go e é usada por projetos de código aberto, como o Knative, o Tekton e o sigstore.

Se não usar nenhuma das ferramentas descritas neste documento, recomendamos que comece com o Skaffold e o webhook do digestor. O Skaffold é uma ferramenta comum usada por programadores e equipas de lançamento, e integra-se com as outras ferramentas descritas neste tutorial. Pode tirar partido destas opções de integração à medida que os seus requisitos evoluem. O webhook do Kubernetes do digest complementa o Skaffold ao permitir implementações baseadas em digests para um cluster inteiro.

Objetivos

  • Use o Skaffold para criar e enviar uma imagem, e para inserir o nome da imagem e o resumo num manifesto do Kubernetes.
  • Use a função do lado do cliente do digest e o webhook de admissão de mutação para adicionar digests a imagens em pods e modelos de pods do Kubernetes.
  • Use definidores do kpt para substituir uma etiqueta de imagem num manifesto do Kubernetes por um resumo da imagem.
  • Use o kustomize para gerar um manifesto do Kubernetes com um resumo da imagem.
  • Use gke-deploy para resolver uma etiqueta de imagem para um resumo num manifesto do Kubernetes.
  • Use ko para criar e enviar uma imagem, e para inserir o nome e o resumo da imagem num manifesto do Kubernetes.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização prevista, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Enable the Artifact Registry API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  4. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  5. No Cloud Shell, defina o projeto predefinido para a CLI Google Cloud:

    gcloud config set project PROJECT_ID

    Substitua PROJECT_ID pelo seu [ID do projeto].

  6. Crie um repositório de imagens de contentores no Artifact Registry:

    gcloud artifacts repositories create REPOSITORY \
    --location=LOCATION \
    --repository-format=docker

    Substitua o seguinte:

  7. Configure a autenticação na localização do Artifact Registry para as ferramentas de CLI usadas neste tutorial:

    gcloud auth configure-docker LOCATION-docker.pkg.dev

    Usar o Skaffold

    O Skaffold é uma ferramenta de linha de comandos para o desenvolvimento e a implementação contínuos de aplicações em clusters do Kubernetes.

    Use o Skaffold para criar uma imagem, enviar a imagem para o Artifact Registry e substituir o valor do marcador de posição image num modelo de manifesto do Kubernetes pelo nome, pela etiqueta e pelo resumo da imagem enviada:

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/skaffold
cd ~/container-image-digests-tutorial/skaffold

    2. Clone o repositório Git do Skaffold:

      git clone https://github.com/GoogleContainerTools/skaffold.git

    3. Aceda ao diretório do exemplo getting-started:

      cd skaffold/examples/getting-started

    4. Consulte a etiqueta Git que corresponde à sua versão do Skaffold:

      git checkout $(skaffold version)

    5. Veja o ficheiro de configuração skaffold.yaml:

      cat skaffold.yaml

      O ficheiro é semelhante ao seguinte:

      apiVersion: skaffold/v4beta6
kind: Config
build:
  artifacts:
  - image: skaffold-example
manifests:
  rawYaml:
  - k8s-pod.yaml

      A secção build.artifacts contém um nome de imagem de marcador de posição. O Skaffold procura este marcador de posição nos ficheiros de manifesto de entrada.

      A secção manifests indica ao Skaffold que deve ler um manifesto de entrada do diretório atual com o nome k8s-pod.yaml.

      Para uma vista geral de todas as opções disponíveis, consulte a skaffold.yaml documentação de referência.

    6. Veja o modelo de manifesto do Kubernetes:

      cat k8s-pod.yaml

      O ficheiro é o seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: getting-started
spec:
  containers:
  - name: getting-started
    image: skaffold-example

      O valor do marcador de posição skaffold-example no campo image corresponde ao valor do campo image no ficheiro skaffold.yaml. O Skaffold substitui este valor do marcador de posição pelo nome completo da imagem e pelo resumo na saída renderizada.

    7. Crie e envie a imagem para o Artifact Registry:

      skaffold build \
    --default-repo=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY \
    --file-output=artifacts.json \
    --interactive=false \
    --push=true \
    --update-check=false

      Este comando usa as seguintes flags:

      • O sinalizador --file-output especifica o ficheiro onde o Skaffold guarda as informações sobre a imagem criada, incluindo o valor de resumo.
      • A flag --push indica ao Skaffold que envie a imagem criada para o registo de imagens de contentores especificado pela flag --default-repo.
      • As flags --interactive e --update-check estão ambas definidas como false. Defina estas flags como false em ambientes não interativos, como pipelines de compilação, mas deixe-as com os valores predefinidos (true para ambas as flags) para o desenvolvimento local.

      Se usar o Cloud Deploy para implementar no GKE, use o ficheiro da flag --file-output como o valor da flag --build-artifacts quando criar uma versão.

    8. Renderize o manifesto do Kubernetes expandido com o nome, a etiqueta e o resumo da imagem do contentor do passo anterior:

      skaffold render \
    --build-artifacts=artifacts.json \
    --digest-source=none \
    --interactive=false \
    --offline=true \
    --output=rendered.yaml \
    --update-check=false

      Este comando usa as seguintes flags:

      • A flag --build-artifacts faz referência ao ficheiro de saída do comando skaffold build no passo anterior.
      • A flag --digest-source=none significa que o Skaffold usa o valor do resumo do ficheiro fornecido na flag --build-artifacts, em vez de resolver o resumo do registo de imagens de contentores.
      • A flag --offline=true significa que pode executar o comando sem precisar de acesso a um cluster do Kubernetes.
      • A flag --output especifica o ficheiro de saída para o manifesto renderizado.

    9. Ver o manifesto renderizado:

      cat rendered.yaml

      O resultado é semelhante ao seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: getting-started
spec:
  containers:
  - image: LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/skaffold-example:TAG@sha256:DIGEST
    name: getting-started

      Neste resultado, vê os seguintes valores:

      • TAG: a etiqueta que o Skaffold atribuiu à imagem.
      • DIGEST: o valor do resumo de imagens

    Usar digestor

    O Digester adiciona resumos a imagens de contentores e contentores de inicialização em especificações de modelos de pods e pods do Kubernetes. O digestor substitui as referências de imagens de contentores que usam etiquetas:

    spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10

    Com referências que usam o resumo da imagem:

    spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

    O Digester pode ser executado como um webhook de admissão de mutação num cluster do Kubernetes ou como uma função KRM do lado do cliente com as ferramentas de linha de comandos kpt ou kustomize.

    Usar a função KRM do digestor

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/digester-fn
cd ~/container-image-digests-tutorial/digester-fn

    2. Transfira o ficheiro binário do digestor:

      mkdir -p ${HOME}/bin
export PATH=${HOME}/bin:${PATH}
DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name)
curl -L "https://github.com/google/k8s-digester/releases/download/${DIGESTER_VERSION}/digester_$(uname -s)_$(uname -m)" --output ${HOME}/bin/digester
chmod +x ${HOME}/bin/digester

    3. Crie um manifesto do Kubernetes Pod que faça referência à imagem gcr.io/google-containers/echoserver através da etiqueta 1.10:

      cat << EOF > pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - name: echoserver
    image: gcr.io/google-containers/echoserver:1.10
    ports:
    - containerPort: 8080
EOF

    4. Execute a função KRM do digestor usando o kpt com os manifestos no diretório atual (.):

      kpt fn eval . --exec digester

      Quando executa este comando, o kpt faz uma atualização no local dos manifestos no diretório atual. Se quiser que o kpt mostre o manifesto atualizado na consola e deixe o ficheiro de manifesto inalterado, adicione a flag --output unwrap.

    5. Veja o manifesto atualizado:

      cat pod.yaml

      O ficheiro é o seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
    - name: echoserver
      image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
      ports:
        - containerPort: 8080

    Usar o webhook de admissão do digestor

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/digester-webhook
cd ~/container-image-digests-tutorial/digester-webhook

    2. Crie um cluster Kubernetes local com o kind:

      kind create cluster

      O kind é uma ferramenta de linha de comandos para executar clusters Kubernetes locais através do Docker.

    3. Implemente o webhook do digestor:

      DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name)
kustomize build "https://github.com/google/k8s-digester.git/manifests?ref=${DIGESTER_VERSION}" | kubectl apply -f -

    4. Crie um espaço de nomes do Kubernetes denominado digester-demo no cluster do tipo:

      kubectl create namespace digester-demo

    5. Adicione a etiqueta digest-resolution: enabled ao espaço de nomes digester-demo:

      kubectl label namespace digester-demo digest-resolution=enabled

      O webhook do digestor adiciona resumos aos pods em espaços de nomes com esta etiqueta.

    6. Crie um manifesto de implementação do Kubernetes que faça referência à imagem gcr.io/google-containers/echoserver através da etiqueta 1.10:

      cat << EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echoserver
        image: gcr.io/google-containers/echoserver:1.10
        ports:
        - containerPort: 8080
EOF

    7. Aplique o manifesto no espaço de nomes digester-demo:

      kubectl apply --filename deployment.yaml --namespace digester-demo \
    --output jsonpath='{.spec.template.spec.containers[].image}{"\n"}'

      A flag --output indica ao kubectl que deve enviar o nome da imagem para a consola, seguido de um caráter de nova linha. O resultado é o seguinte:

      gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

      Este resultado mostra que o webhook do digestor adicionou o resumo da imagem à especificação do modelo de pod no recurso de implementação.

    8. Elimine o cluster do tipo para libertar recursos na sua sessão do Cloud Shell:

      kind delete cluster

    Usar definidores do kpt

    O kpt é uma ferramenta de linha de comandos para gerir, manipular, personalizar e aplicar manifestos de recursos do Kubernetes.

    Pode usar as funções create-setters e apply-setters KRM do catálogo de funções do kpt para atualizar os resumos de imagens nos seus manifestos do Kubernetes quando cria novas imagens.

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/kpt
cd ~/container-image-digests-tutorial/kpt

    2. Crie um pacote kpt no diretório atual:

      kpt pkg init --description "Container image digest tutorial"

    3. Crie um manifesto do Kubernetes Pod que faça referência à imagem gcr.io/google-containers/echoserver através da etiqueta 1.10:

      cat << EOF > pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - name: echoserver
    image: gcr.io/google-containers/echoserver:1.10
    ports:
    - containerPort: 8080
EOF

    4. Use o kpt para criar um setter denominado echoimage para o campo do manifesto, onde o valor existente é gcr.io/google-containers/echoserver:1.10:

      kpt fn eval . \
    --image gcr.io/kpt-fn/create-setters@sha256:0220cc87f29ff9abfa3a3b5643aa50f18d355d5e9dc9e1f518119633ddc4895c \
    -- "echoimage=gcr.io/google-containers/echoserver:1.10"

    5. Veja o manifesto:

      cat pod.yaml

      O ficheiro é o seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - name: echoserver
    image: gcr.io/google-containers/echoserver:1.10 # kpt-set: ${echoimage}
    ports:
    - containerPort: 8080

    6. Obtenha o valor de resumo da imagem do contentor:

      DIGEST=$(gcloud container images describe \
    gcr.io/google-containers/echoserver:1.10 \
    --format='value(image_summary.digest)')

    7. Defina o novo valor do campo:

      kpt fn eval . \
    --image gcr.io/kpt-fn/apply-setters@sha256:4d4295727183396f0c3c6a75d2560254c2f9041a39e95dc1e5beffeb49cc1a12 \
    -- "echoimage=gcr.io/google-containers/echoserver:1.10@$DIGEST"

      Quando executa este comando, o kpt faz uma substituição no local do valor do campo image no manifesto.

    8. Veja o manifesto atualizado:

      cat pod.yaml

      O ficheiro é o seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - name: echoserver
    image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 # kpt-set: ${echoimage}
    ports:
    - containerPort: 8080

    Usar transformadores de imagens do kustomize

    O kustomize é uma ferramenta de linha de comandos que lhe permite personalizar manifestos do Kubernetes através de sobreposições, patches e transformadores.

    Pode usar o transformador de imagens do kustomize para atualizar o nome, a etiqueta e o resumo da imagem no manifesto existente.

    O fragmento kustomization.yaml seguinte mostra como configurar o transformador de imagens para usar o valor do transformador digest para imagens em que o valor da especificação do bloco image corresponde ao valor do transformador name:

    images:
- name: gcr.io/google-containers/echoserver
  digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

    Para usar um transformador de imagens kustomize com um resumo de imagem, faça o seguinte:

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/kustomize
cd ~/container-image-digests-tutorial/kustomize

    2. Crie um ficheiro kustomization.yaml:

      kustomize init

    3. Crie um manifesto do Kubernetes com uma especificação de pod que faça referência à imagem gcr.io/google-containers/echoserver através da etiqueta 1.10:

      cat << EOF > pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - name: echoserver
    image: gcr.io/google-containers/echoserver:1.10
    ports:
    - containerPort: 8080
EOF

    4. Adicione o manifesto como um recurso no ficheiro kustomization.yaml:

      kustomize edit add resource pod.yaml

    5. Use um transformador de imagens para atualizar o resumo da imagem:

      kustomize edit set image \
    gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

    6. Veja o transformador de imagens no ficheiro kustomization.yaml:

      cat kustomization.yaml

      O ficheiro é o seguinte:

      apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- pod.yaml
images:
- digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
  name: gcr.io/google-containers/echoserver

    7. Veja o manifesto resultante:

      kustomize build .

      O resultado é o seguinte:

      apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
    name: echoserver
    ports:
    - containerPort: 8080

    8. Para executar o transformador kustomize e aplicar o manifesto resultante a um cluster do Kubernetes num único passo, pode usar o comando kubectl apply com a flag --kustomize:

      kubectl apply --kustomize .

      Se quiser aplicar a saída mais tarde, pode redirecionar a saída do comando kustomize build para um ficheiro.

    A usar gke-deploy

    gke-deploy é uma ferramenta de linha de comandos que usa com o Google Kubernetes Engine (GKE). gke-deploy envolve a ferramenta de linha de comandos kubectl e pode modificar os recursos que cria seguindo as práticas recomendadas da Google.

    Se usar os subcomandos gke-deployprepare ou run, gke-deployresolve as etiquetas de imagem em resumos e guarda os manifestos expandidos com os resumos de imagens no ficheiro output/expanded/aggregated-resources.yaml por predefinição.

    Pode usar gke-deploy run para substituir a etiqueta de imagem por um resumo e aplicar o manifesto expandido ao cluster do GKE. Embora este comando seja conveniente, tem uma desvantagem: a etiqueta de imagem é substituída no momento da implementação. A imagem associada à etiqueta pode ter sido alterada no período entre a decisão de implementação e a implementação, o que resultou na implementação de uma imagem inesperada. Para implementações de produção, recomendamos passos separados para gerar e aplicar manifestos.

    Para substituir uma etiqueta de imagem num manifesto de implementação do Kubernetes pelo resumo da imagem, faça o seguinte:

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/gke-deploy
cd ~/container-image-digests-tutorial/gke-deploy

    2. Instalar gke-deploy:

      go install github.com/GoogleCloudPlatform/cloud-builders/gke-deploy@latest

    3. Crie um manifesto de implementação do Kubernetes que faça referência à imagem gcr.io/google-containers/echoserver através da etiqueta 1.10:

      cat << EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echoserver
        image: gcr.io/google-containers/echoserver:1.10
        ports:
        - containerPort: 8080
EOF

    4. Gere um manifesto expandido com base no manifesto deployment.yaml:

      gke-deploy prepare \
    --filename deployment.yaml \
    --image gcr.io/google-containers/echoserver:1.10 \
    --version 1.10

    5. Veja o manifesto expandido:

      cat output/expanded/aggregated-resources.yaml

      O resultado é o seguinte:

      apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/managed-by: gcp-cloud-build-deploy
    app.kubernetes.io/version: "1.10"
  name: echo-deployment
  namespace: default
spec:
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
        app.kubernetes.io/managed-by: gcp-cloud-build-deploy
        app.kubernetes.io/version: "1.10"
    spec:
      containers:
      - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
        name: echoserver
        ports:
        - containerPort: 8080

      No manifesto expandido, a etiqueta de imagem é substituída pelo resumo.

      O argumento --version que usou com o comando gke-deploy define o valor da etiqueta app.kubernetes.io/version na implementação e nos metadados do modelo de agrupamento do manifesto expandido.

      Para saber como usar o gke-deploy com o Cloud Build, consulte a documentação do Cloud Build para o gke-deploy.

    A usar ko

    O ko é uma ferramenta de linha de comandos e uma biblioteca para criar Go imagens de contentores e implementá-las em clusters do Kubernetes. O ko cria imagens sem usar o daemon do Docker, pelo que pode usá-lo em ambientes onde não pode instalar o Docker.

    O subcomando ko build cria imagens e publica-as num registo de imagens de contentores ou carrega-as no seu daemon Docker local.

    O subcomando ko resolve faz o seguinte:

    • Identifica as imagens a criar encontrando marcadores de posição nos campos image dos manifestos do Kubernetes que fornece através do argumento --filename.
    • Cria e publica as suas imagens.
    • Substitui os marcadores de posição de valores image pelos nomes e resumos das imagens criadas.
    • Imprime os manifestos expandidos.

    Os subcomandos ko apply, create, e run executam os mesmos passos que resolve e, em seguida, executam kubectl apply, create ou run com os manifestos expandidos.

    Para criar uma imagem a partir do código fonte Go e adicionar o resumo da imagem a um manifesto de implementação do Kubernetes, faça o seguinte

    1. No Cloud Shell, crie e aceda a um diretório para armazenar os ficheiros que criar nesta secção:

      mkdir -p ~/container-image-digests-tutorial/ko
cd ~/container-image-digests-tutorial/ko

    2. Transfira o ficheiro ko e adicione-o ao seu PATH:

      mkdir -p ${HOME}/bin
export PATH=${HOME}/bin:${PATH}
KO_VERSION=$(curl -sL https://api.github.com/repos/ko-build/ko/releases/latest | jq -r .tag_name | cut -c2-)
curl -L "https://github.com/ko-build/ko/releases/download/v${KO_VERSION}/ko_${KO_VERSION}_$(uname -s)_$(uname -m).tar.gz" | tar -zxC ${HOME}/bin ko

    3. Crie uma app Go com o nome do módulo example.com/hello-world num novo diretório denominado app:

      mkdir -p app/cmd/ko-example

cd app

go mod init example.com/hello-world

cat << EOF > cmd/ko-example/main.go
package main

import "fmt"

func main() {
    fmt.Println("hello world")
}
EOF

    4. Defina o repositório de imagens que o ko usa para publicar imagens:

      export KO_DOCKER_REPO=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY

      Este exemplo usa o Artifact Registry, mas pode usar ko com um registo de imagens de contentores diferente.

    5. Para criar e publicar uma imagem para a sua app, siga um dos seguintes passos:

      • Crie e publique uma imagem para a sua app indicando o caminho para o seu Go pacote principal:

        ko build --base-import-paths ./cmd/ko-example

        O argumento opcional --base-import-paths significa que ko usa o nome abreviado do diretório do pacote principal como o nome da imagem.

        O comando ko imprime o nome e o resumo da imagem para stdout no seguinte formato:

        LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST

        Neste resultado, DIGEST é o valor do resumo da imagem.

      • Use ko para substituir um marcador de posição do manifesto pelo nome e o resumo da imagem que cria e publica:

        1. Crie um manifesto de pod do Kubernetes. O manifesto usa o marcador de posição ko://IMPORT_PATH_OF_YOUR_MAIN_PACKAGE como o valor do campo image:

          cat << EOF > ko-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: ko-example
spec:
  containers:
  - name: hello-world
    image: ko://example.com/hello-world/cmd/ko-example
EOF

        2. Crie e publique uma imagem para a sua app e substitua o marcador de posição do manifesto pelo nome e resumo da imagem:

          ko resolve --base-import-paths --filename ko-pod.yaml

          ko imprime o manifesto com o nome da imagem e o resumo para stdout:

          apiVersion: v1
kind: Pod
metadata:
  name: ko-example
spec:
  containers:
  - name: hello-world
    image: LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST

          Neste resultado, DIGEST é o valor do resumo da imagem.

    Limpar

    A forma mais fácil de eliminar a faturação é eliminar o Google Cloud projeto que criou para o tutorial. Em alternativa, pode eliminar os recursos individuais.

    Elimine o projeto

    1. In the Google Cloud console, go to the Manage resources page.

      Go to Manage resources

    2. In the project list, select the project that you want to delete, and then click Delete.
    3. In the dialog, type the project ID, and then click Shut down to delete the project.

    Elimine os recursos

    Se quiser manter o Google Cloud projeto que usou neste tutorial, elimine os recursos individuais:

    1. No Cloud Shell, elimine os ficheiros que criou neste tutorial:

      cd
rm -rf ~/container-image-digests-tutorial

    2. Elimine o repositório de imagens de contentores no Artifact Registry:

      gcloud artifacts repositories delete REPOSITORY \
    --location=LOCATION --async --quiet

    O que se segue?