Como usar a página Aplicativos do GKE no Console do Cloud

Este tutorial descreve como usar a página Aplicativos do Google Kubernetes Engine (GKE) no Console do Google Cloud.

Ao adotar o Kubernetes para muitos aplicativos e recursos, pode ser difícil identificar e rastrear os vários componentes relacionados a um aplicativo. Ao implantar vários aplicativos em cada namespace, pode ser difícil saber quais recursos estão relacionados a cada aplicativo. Além disso, você precisa pesquisar em vários locais a documentação e os metadados que descrevem o que são os aplicativos, quem são os proprietários e como interagir com os serviços.

O GKE ajuda com esses desafios na página Aplicativos:

Uma visualização parcial da página Aplicativos que mostra uma lista de aplicativos
e várias propriedades.

A página Aplicativos é um recurso independente na arquitetura que descreve os metadados do sistema. É possível usá-la para organizar visualmente os recursos sem alterar a arquitetura. Ao definir valores em um arquivo YAML, você pode agrupar todos os recursos do aplicativo e incluir metadados essenciais para sua equipe de operações. Criar, modificar e excluir o arquivo YAML não afeta os recursos atuais. Portanto, você pode trabalhar imediatamente com recursos sem colocar o sistema em risco.

Para demonstrar esta página, neste tutorial mostraremos como implementar o recurso de aplicativo do Kubernetes em um aplicativo e adicionar metadados definidos pelo usuário para organizar e simplificar o gerenciamento do aplicativo no GKE.

Este tutorial destina-se a desenvolvedores que criam aplicativos para execução no GKE. Presumimos que você esteja familiarizado com os conceitos básicos do Kubernetes e tenha certa experiência com gravação de arquivos YAML do recurso do Kubernetes.

Objetivos

  • Apresentar o recurso Aplicativo do Kubernetes.
  • Adicionar o recurso Aplicativo do Kubernetes a uma arquitetura existente.
  • Criar e visualizar informações personalizadas sobre um aplicativo pelo Console do Cloud.

Custos

Neste tutorial, usamos 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 ser qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Antes de começar

  1. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  2. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  3. Ative as APIs Compute Engine and Kubernetes Engine.

    Ative as APIs

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

    Ativar o Cloud Shell

    Os comandos deste tutorial são executados no Cloud Shell ou no Editor do Cloud Shell.

Como preparar o ambiente

  1. No Cloud Shell, defina as variáveis de ambiente para o ID do projeto:

    export PROJECT_ID=PROJECT_ID
    gcloud config set core/project $PROJECT_ID
    gcloud config set compute/zone us-central1-c
    

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

  2. Crie um cluster do GKE:

    gcloud container clusters create sample-cluster
    

    Neste tutorial, você executa aplicativos em um cluster padrão do GKE.

Como instalar os aplicativos da amostra

Neste tutorial, você simula vários aplicativos em execução no mesmo namespace usando um aplicativo de amostra básico do Nginx e o aplicativo de amostra do Bank of Anthos.

  1. No Cloud Shell, instale o aplicativo de amostra do Nginx:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/web/web.yaml
    

    Esse comando cria um recurso StatefulSet chamado web e um serviço chamado nginx. No Console do Cloud, é possível visualizar esses recursos nas páginas Cargas de trabalho e Serviços e Entrada do GKE.

  2. Clone o repositório do GitHub que contém o aplicativo de amostra do Bank of Anthos:

    git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
    cd bank-of-anthos
    
  3. Gere uma chave SSH e armazene-a como um secret do Kubernetes:

    openssl genrsa -out jwtRS256.key 4096
    openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
    kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
    

    Para ser executado, o aplicativo de amostra do Bank of Anthos requer uma chave SSH.

  4. Implante o aplicativo de amostra no cluster:

    kubectl apply -f kubernetes-manifests
    

    Após alguns instantes, os recursos do aplicativo serão exibidos nas seguintes páginas do Console do Cloud:

    Observações:

    • Os recursos dos aplicativos de amostra do Nginx e do Bank of Anthos se mesclam.
    • Nenhum recurso ainda é exibido na página Aplicativos. Você preencherá a página Aplicativos nas etapas posteriores.

Como preparar o GKE

Os recursos que a página Aplicativos exibe são especificados com o tipo de recurso Aplicativo do Kubernetes, uma definição de recurso personalizada (CRD, na sigla em inglês) fornecida pelo projeto de código aberto do Kubernetes. Por padrão, a CRD do aplicativo não fica ativada no Kubernetes. Alguns serviços no GKE, como o Marketplace e a implantação de aplicativos, instalam a CRD do aplicativo, mas se você não estiver usando nenhum desses serviços, o CRD do aplicativo não ficará disponível por padrão.

Para instalar a CRD do aplicativo, faça o seguinte:

  1. No Cloud Shell, aplique a CRD do aplicativo uma vez em cada cluster:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/application/master/deploy/kube-app-manager-aio.yaml
    
  2. (Opcional) Depois que o comando for concluído, veja a CRD do aplicativo no cluster:

    kubectl get crd
    

    A saída a seguir é uma lista de CRDs instaladas, incluindo applications.app.k8s.io:

    NAME                                    CREATED AT
    applications.app.k8s.io                 2020-07-24T19:32:20Z
    backendconfigs.cloud.google.com         2020-07-24T19:28:40Z
    managedcertificates.networking.gke.io   2020-07-24T19:28:57Z
    scalingpolicies.scalingpolicy.kope.io   2020-07-24T19:28:57Z
    updateinfos.nodemanagement.gke.io       2020-07-24T19:28:57Z
    

Como incluir recursos do aplicativo

Agora que a CRD do aplicativo está disponível no cluster, a próxima etapa é criar e implantar uma instância do recurso Aplicativo.

Como o recurso Aplicativo é um recurso do Kubernetes, ele tem uma estrutura semelhante à de outros recursos do Kubernetes, incluindo campos e opções para apiVersion, kind, metadata e spec:

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: ...
spec:
   ...

Nas seções a seguir, você trabalhará com vários campos e opções disponíveis no recurso Aplicativo.

Crie o recurso base Aplicativo

É possível adicionar o recurso Aplicativo a qualquer conjunto existente de recursos. Neste tutorial, você começa com um recurso vazio e preenche cada seção.

  1. No Cloud Shell, crie e edite um arquivo application.yaml no diretório kubernetes-manifests:

    touch kubernetes-manifests/application.yaml
    edit kubernetes-manifests/application.yaml
    

    O editor do Cloud Shell é aberto e exibe um arquivo em branco.

  2. Cole as linhas a seguir para definir seu primeiro aplicativo:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
    
  3. Na barra de menus do Cloud Shell, clique em Abrir terminal.

  4. No Cloud Shell, aplique o recurso:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  5. No Console do Cloud, acesse a página Aplicativos.

    Acesse Aplicativos

    A página Aplicativos exibe os recursos adicionados:

    O aplicativo Bank of Anthos está incluído na lista de aplicativos.

Inclua recursos por componente

A página Aplicativos mostra o aplicativo Bank of Anthos. Ao clicar em bank-of-anthos no campo Nome, você verá informações básicas sobre o aplicativo:

Os detalhes do aplicativo incluem cluster, namespace e data
de criação.

É possível adicionar vários tipos de componentes para exibir no Console do Cloud. Por exemplo, para mostrar Serviços, Implantações e StatefulSets, edite a seção componentKinds da definição application.yaml, por exemplo, da seguinte maneira:

spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

Nas etapas a seguir, adicione esses componentes à definição de recurso do Bank of Anthos:

  1. Na barra de menus do Cloud Shell, clique em Abrir editor.

  2. No editor do Cloud Shell, substitua o conteúdo do arquivo kubernetes-manifests/application.yaml colando o seguinte:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
    spec:
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    

    A adição da seção spec adiciona Service, Deployment e StatefulSet à definição do aplicativo.

  3. No Cloud Shell, aplique o recurso:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    Os componentes de determinado tipo são exibidos:

    A lista de detalhes inclui tipos de componente, como
Serviço e Implantação.

Filtre recursos com seletores

Neste ponto do tutorial, a lista de componentes inclui todos os recursos para ambos os aplicativos de amostra para o conjunto definido de componentes a partir de todo o namespace. Por exemplo, o diagrama a seguir mostra o serviço nginx do aplicativo de amostra do Nginx e a implantação transactionhistory do aplicativo de amostra do Bank of Anthos:

A lista de componentes é gerada a partir de todos os aplicativos no
namespace.

Para garantir que apenas os recursos de um aplicativo sejam exibidos (por exemplo, para o aplicativo Bank of Anthos), é possível usar seletores para identificar recursos específicos. Para ver como os seletores funcionam, adicione um rótulo ao recurso nas seguintes etapas:

  1. No Cloud Shell, abra o arquivo frontend.yaml:

    edit kubernetes-manifests/frontend.yaml
    
  2. No editor do Cloud Shell, cole a seguinte entrada label após a linha 18:

    labels:
        app.kubernetes.io/name: "bank-of-anthos"
    

    A seção metadata tem a seguinte aparência:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: frontend
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
    

    O arquivo inicial application.yaml tem a seguinte aparência:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
  3. No Cloud Shell, aplique os recursos:

    kubectl apply -f kubernetes-manifests/
    
  4. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    O único recurso que corresponde a um rótulo específico é exibido:

    A lista de componentes mostra o recurso Implantação.

Aplique rótulos a todos os recursos com o kustomize

Aplicar rótulos manualmente a todos os recursos de um aplicativo pode ser uma tarefa chata. As etapas a seguir mostram como usar o kustomize para adicionar rótulos com eficiência a todos os recursos:

  1. No Cloud Shell, faça o download de kustomize:

    curl -s "https://raw.githubusercontent.com/\
    kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
    
  2. Crie e edite um arquivo kustomization.yaml:

    touch kubernetes-manifests/kustomization.yaml
    edit kubernetes-manifests/kustomization.yaml
    
  3. No editor do Cloud Shell, adicione as seguintes linhas a kustomization.yaml:

    apiVersion: kustomize.config.k8s.io/v1beta1
    kind: Kustomization
    
    resources:
    - accounts-db.yaml
    - application.yaml
    - balance-reader.yaml
    - config.yaml
    - contacts.yaml
    - frontend.yaml
    - ledger-db.yaml
    - ledger-writer.yaml
    - loadgenerator.yaml
    - transaction-history.yaml
    - userservice.yaml
    
    commonLabels:
        app.kubernetes.io/name: "bank-of-anthos"
    

    Nesta definição do kustomization.yaml, você especifica a quais recursos aplicar as modificações e quais modificações serão feitas. Nesse caso, você especifica que todos os recursos precisam ter um rótulo comum de app.kubernetes.io/name: "bank-of-anthos".

  4. No Cloud Shell, exclua os recursos antigos:

    kubectl delete -f kubernetes-manifests/
    

    É necessário excluir os recursos antigos antes de aplicar os novos recursos especificados em kustomization.yaml.

  5. Aplique os recursos usando a sinalização kustomize em vez da sinalização file:

    ./kustomize build kubernetes-manifests/ | kubectl apply -f -
    
  6. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    A página de detalhes exibe os recursos do aplicativo de amostra Bank of Anthos e nenhum recurso do aplicativo de amostra Nginx:

    Somente componentes do Bank of Anthos, como StatefulSet, são
exibidos.

Como adicionar metadados úteis na tela

É possível exibir metadados personalizados de um aplicativo no Console do Cloud. Você pode incluir o que o aplicativo faz, quem é o proprietário, onde encontrar mais informações sobre ele e como fazer login. Esse tipo de informação é útil para vários casos de uso, por exemplo, se você opera vários aplicativos na sua organização.

As seções a seguir descrevem alguns dos metadados que você pode adicionar.

Adicione descrição e documentação

É possível adicionar uma descrição e links que aparecem no painel Informações do aplicativo. Para acessar esse painel na página Detalhes, clique em Mostrar painel de informações.

Para exibir informações neste painel, defina elementos como description e links na seção descriptor do arquivo application.yaml.

descriptor:
    description:
    links:
    - description:
      url:

Para atualizar a seção descriptor, faça o seguinte:

  1. No editor do Cloud Shell, substitua o conteúdo do arquivo application.yaml colando o seguinte:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        description: |-
            This application simulates a bank's payment processing network using
            [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and
            simulate transactions between accounts. Bank of Anthos was developed
            to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

  4. Para conferir as atualizações, clique em Mostrar painel de informações.

    O painel Informações do aplicativo mostra uma descrição e uma lista de documentos:

    Os documentos na lista são formatados como hiperlinks.

Inclua o tipo de software

A página Aplicativos inclui um campo (Software) para o tipo de software na lista de aplicativos. É possível personalizar esse campo para ajudar a organizar e categorizar os aplicativos de acordo com suas necessidades. Por exemplo, é possível indicar que o software é interno ou externo. Ou, se você tiver vários aplicativos criados a partir de um tipo base compartilhado, poderá indicar o tipo de base que um app implementa.

Para adicionar uma descrição personalizada ao tipo de software, use o campo type na seção descriptor do arquivo application.yaml:

 descriptor:
    type: External App

É possível exibir o valor de type como um hiperlink no Console do Cloud. Você especifica o URL do hiperlink usando a primeira entrada na seção links. Nas etapas a seguir, você atualiza a seção links da seguinte maneira:

    links:
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
  1. No editor do Cloud Shell, substitua o conteúdo de application.yaml colando:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. No Console do Cloud, acesse a página Aplicativos.

    Acesse Aplicativos

    O app externo é exibido no campo Software:

    O tipo de software "Aplicativo externo" é formatado como um hiperlink.

Inclua uma versão do aplicativo

A página principal Aplicativos inclui um campo para a versão. Na prática, o valor desse campo é atualizado programaticamente para referenciar a versão real implantada.

Para preencher o campo de versão, inclua o campo version em descriptor como no exemplo a seguir:

  descriptor:
    type: External App
    version: "2.3.2"

Nas próximas etapas, você adicionará um campo para a versão do aplicativo.

  1. No editor do Cloud Shell, substitua o conteúdo do arquivo application.yaml colando o seguinte:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. No Console do Cloud, acesse a página Aplicativos.

    Acesse Aplicativos

    O campo Versão do aplicativo Bank of Anthos é mostrado como 2.3.2:

    Os detalhes do aplicativo incluem os campos de tipo de software e versão.

Adicione detalhes do responsável pela manutenção

Nesta etapa, adicione o texto estático personalizado à seção principal da página Aplicativos. Especifique esses detalhes na seção info do arquivo application.yaml da seguinte maneira:

  info:
  - name: LABEL
    value: STRING

Para incluir valores estáticos, forneça detalhes para LABEL e STRING na seção info. Por exemplo, você pode inserir Owner para name e John Smith para value.

  1. No editor do Cloud Shell, substitua o conteúdo de application.yaml colando:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
    
  2. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    A página de detalhes inclui um proprietário para o aplicativo do Bank of Anthos:

    John Smith é listado como proprietário.

Exponha um endpoint do aplicativo

Além dos valores estáticos, é possível expor valores dinâmicos da própria implantação. Nas etapas a seguir, você verá o endereço IP do balanceador de carga para que qualquer pessoa que visualizar a página de detalhes do aplicativo possa acessar o aplicativo diretamente.

Para mostrar esse valor, use a especificação serviceRef. Outras especificações válidas são configMapKeyRef, ingressRef e secretKeyRef.

Na especificação serviceRef, inclua esses valores dinâmicos usando o tipo Reference. Neste tutorial, a especificação para serviceRef é a seguinte:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION

É possível substituir os seguintes valores:

  • LABEL: um rótulo que descreve uma instância de referência específica, por exemplo, App Frontend URL.
  • SERVICE_NAME: o nome que identifica o Service$mdash. Por exemplo, frontend
  • DATA_LOCATION: o local dos dados no Serviço. Por exemplo, status.loadBalancer.ingress[0].ip.

As especificações serviceRef e ingressRef também são compatíveis com o elemento path. Se seu URL exigir detalhes relacionados ao caminho, inclua esses detalhes no campo path:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin

O endereço IP e o caminho do endpoint são concatenados, por exemplo, 35.202.90.0/wp-admin.

Também é possível forçar o uso de HTTP ou HTTPS usando o campo protocol da seguinte maneira:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin
        protocol: HTTPS

Esses detalhes produzem o seguinte URL:

https://35.202.90.0/wp-admin

Nas próximas etapas, use serviceRef para expor o endereço IP do balanceador de carga do serviço para o aplicativo Bank of Anthos:

  1. No editor do Cloud Shell, substitua o conteúdo do arquivo application.yaml pelo seguinte:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
      - name: App Frontend URL
        type: Reference
        valueFrom:
          serviceRef:
            name: frontend
            fieldPath: status.loadBalancer.ingress[0].ip
            protocol: HTTPS
    
  2. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    A página de detalhes inclui um endereço IP do endpoint para o aplicativo Bank of Anthos:

    O endereço IP é rotulado como URL de front-end do aplicativo.

Forneça credenciais de acesso

Como mencionado anteriormente, é possível expor Secrets do Kubernetes pelo Console do Cloud usando o elemento secretKeyRef. Neste tutorial, você fornece um nome de usuário e uma senha ao operador para que ele possa fazer login no aplicativo.

  1. No Cloud Shell, crie o secret:

    kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
    
  2. No editor do Cloud Shell, substitua o conteúdo do arquivo application.yaml colando o seguinte. Essa atualização inclui referências ao nome de usuário e senha na anotação secretKeyRef.

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
      - name: App Frontend URL
        type: Reference
        valueFrom:
          serviceRef:
            name: frontend
            fieldPath: status.loadBalancer.ingress[0].ip
            protocol: HTTPS
      - name: TestUser username
        type: Reference
        valueFrom:
          secretKeyRef:
            name: boa-access
            key: boa-user
    
      - name: TestUser password
        type: Reference
        valueFrom:
          secretKeyRef:
            name: boa-access
            key: boa-pass
    
  3. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

  5. Clique em Visualizar dados do secret. O nome de usuário e a senha são exibidos:

    Os detalhes do aplicativo incluem links para acessar
credenciais.

A capacidade de revelar dados de secret é um recurso útil para suas equipes de operações. No entanto, a capacidade de visualizar esses secrets é regida pelas permissões de acesso do gerenciamento de identidade e acesso (IAM, na sigla em inglês) da página de detalhes do GKE. Qualquer pessoa com permissões para visualizar clusters também pode visualizar secrets. Portanto, é importante considerar com cuidado o que você expõe.

Adicione um ícone do aplicativo

Para que seu aplicativo se destaque, inclua um logotipo que é exibido na lista de aplicativos e na página de detalhes. Para incluir um logotipo, especifique o URI de dados da imagem na anotação kubernetes-engine.cloud.google.com/icon.

A conversão de uma imagem em um URI de dados está fora do escopo deste tutorial. No entanto, uma pesquisa no Google sobre "converter imagem em URI de dados" retorna várias utilidades para ajudar você a produzir a string de dados em uma imagem. Como o URI de dados da imagem usada nesta seção é muito longo, não é possível incluí-lo no tutorial. O URI de dados completo pode ser visto no arquivo application.yaml completo. A string de URI de dados deve começar como data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... e terminar com K5CYII=. Não inclua aspas duplas ou caracteres HTML.

O arquivo application.yaml completo está disponível como um gist para referência.

Para adicionar um ícone, atualize a seção metadata do application.yaml:

  1. Copie o seguinte código:

    annotations:
      kubernetes-engine.cloud.google.com/icon: >-
        data:image/png;base64,DATA_URI
    

    Substitua DATA_URI pela string encontrada no arquivo application.yaml completo referenciado anteriormente.

  2. No editor do Cloud Shell, cole o código que você copiou depois da seção labels na seção metadata de application.yaml.

    Essa seção de application.yaml é semelhante à seguinte, em que DATA_URI representa o valor do URI de dados.

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
      annotations:
        kubernetes-engine.cloud.google.com/icon: >-
          data:image/png;base64,DATA_URI
    spec:
    
  3. No Cloud Shell, implante o recurso do aplicativo:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. No Console do Cloud, acesse a página Aplicativos.

    Acesse Aplicativos

    Um logotipo é exibido na lista de aplicativos:

    Um logotipo é exibido ao lado do nome do aplicativo na lista de
aplicativos.

  5. No Console do Cloud, acesse a página de detalhes do aplicativo Bank of Anthos.

    Acesse detalhes do Bank of Anthos

    Um logotipo é exibido no cabeçalho da página de detalhes:

    Um logotipo é exibido no topo da lista de detalhes
do aplicativo.

Limpeza

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

Exclua o projeto

  1. No Console do 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.

A seguir