Usar a página Aplicações do GKE na consola Google Cloud

Este tutorial descreve como usar a página Aplicações do Google Kubernetes Engine (GKE) na Google Cloud consola.

Quando adota o Kubernetes para muitas aplicações e recursos, pode ser difícil identificar e monitorizar os vários componentes relacionados com uma aplicação. Quando implementa várias aplicações em cada espaço de nomes, pode ser difícil saber que recursos estão relacionados com que aplicação. Além disso, muitas vezes, tem de pesquisar em várias localizações documentação e metadados que descrevam o que são as aplicações, quem são os proprietários e como interagir com os serviços.

O GKE ajuda a resolver estes desafios com a página Applications:

A página Applications é um recurso independente na sua arquitetura que descreve os metadados sobre o seu sistema. Pode usar esta página para organizar visualmente os seus recursos sem alterar a arquitetura. Ao definir valores num ficheiro YAML, pode agrupar todos os recursos da sua aplicação e incluir metadados essenciais para a sua equipa de operações. A criação, a modificação e a eliminação do ficheiro YAML não afetam os recursos existentes, pelo que pode trabalhar imediatamente com recursos sem risco para o seu sistema.

Para demonstrar esta página, este tutorial mostra como implementar o recurso da aplicação Kubernetes numa aplicação e adicionar metadados definidos pelo utilizador para organizar e simplificar a gestão da aplicação no GKE.

Este tutorial destina-se a programadores que criam aplicações para serem executadas no GKE. Parte do princípio de que conhece os conceitos básicos do Kubernetes e tem alguma experiência na escrita de ficheiros YAML de recursos do Kubernetes.

Objetivos

• Apresente o recurso de aplicação do Kubernetes.
• Adicione o recurso de aplicação Kubernetes a uma arquitetura existente.
• Crie e veja informações personalizadas sobre uma aplicação através da Google Cloud consola.

Custos

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

• GKE

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.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

3. Enable the Compute Engine and Kubernetes Engine APIs.

   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 APIs

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

   Activate Cloud Shell

   Executa os comandos deste tutorial no Cloud Shell ou no editor do Cloud Shell.

   Preparar o seu ambiente

   1. No Cloud Shell, defina as variáveis de ambiente para o seu 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 seu Google Cloud projeto.

   2. Crie um cluster do GKE:

      gcloud container clusters create sample-cluster
      

      Para este tutorial, executa aplicações num cluster do GKE predefinido.

   Instalar as aplicações de exemplo

   Neste tutorial, vai simular várias aplicações em execução no mesmo espaço de nomes usando uma aplicação de exemplo básica do Nginx e a aplicação de exemplo do Bank of Anthos.

   1. No Cloud Shell, instale a aplicação de exemplo do Nginx:

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

      Este comando cria um recurso StatefulSet denominado web e um serviço denominado nginx. Na Google Cloud consola, pode ver estes recursos nas páginas do GKE Cargas de trabalho e Serviços e entrada.

   2. Clone o repositório do GitHub que contém a aplicação de exemplo 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 segredo 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
      

      A aplicação de exemplo Bank of Anthos requer uma chave SSH para ser executada.

   4. Implemente a aplicação de exemplo no seu cluster:

      kubectl apply -f kubernetes-manifests
      

      Após alguns momentos, pode ver os recursos da aplicação nas seguintes páginas na Google Cloud consola:

      • A página Cargas de trabalho
      • A página Serviços e entrada

      Tenha em conta o seguinte:

      • Os recursos para as aplicações de exemplo do Nginx e do Bank of Anthos estão misturados.
      • Ainda não são apresentados recursos na página Aplicações. Preenche a página Candidaturas nos passos posteriores.

   Preparar o GKE

   Os recursos apresentados na página Aplicações são especificados com o tipo de recurso da aplicação Kubernetes, uma definição de recurso personalizado (CRD) fornecida pelo projeto Kubernetes de código aberto. Por predefinição, o CRD de aplicações não está ativado no Kubernetes. Alguns serviços no GKE, como o Marketplace e a implementação de aplicações, instalam o CRD de aplicações, mas se não estiver a usar nenhum desses serviços, o CRD de aplicações não está disponível por predefinição.

   Para instalar o CRD da aplicação, faça o seguinte:

   1. No Cloud Shell, aplique o CRD da aplicação uma vez em cada cluster:

      kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/application/master/deploy/kube-app-manager-aio.yaml
      

   2. (Opcional) Após a conclusão do comando, veja o CRD da aplicação no cluster:

      kubectl get crd
      

      A saída seguinte é uma lista de CRDs instalados, 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
      

   Incluindo recursos da aplicação

   Agora que o CRD da aplicação está disponível no cluster, o passo seguinte é criar e implementar uma instância do recurso da aplicação.

   Uma vez que o recurso Application é um recurso do Kubernetes, 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 secções seguintes, vai trabalhar com vários campos e opções disponíveis no recurso Application.

   Crie o recurso de aplicação base

   Pode adicionar o recurso Application a qualquer conjunto de recursos existente. Neste tutorial, começa com um recurso vazio e preenche cada secção.

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

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

      O editor do Cloud Shell é aberto e apresenta um ficheiro em branco.

   2. Cole as seguintes linhas para definir a sua primeira aplicação:

      apiVersion: app.k8s.io/v1beta1
      kind: Application
      metadata:
        name: "bank-of-anthos"
      

   3. Na barra de menu do Cloud Shell, clique em Abrir terminal.

   4. No Cloud Shell, aplique o recurso:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   5. Na Google Cloud consola, aceda à página Aplicações.

      Aceda a Aplicações

      A página Aplicações apresenta os recursos que adicionou:

      

   Inclua recursos por componente

   A página Applications (Aplicações) mostra a aplicação Bank of Anthos. Quando clica em bank-of-anthos no campo Nome, são apresentadas informações básicas sobre a aplicação:

   

   Pode adicionar vários tipos de componentes para apresentação na Google Cloud consola. Por exemplo, para mostrar Services, Deployments e StatefulSets, edite a secção componentKinds da definição application.yaml, por exemplo, da seguinte forma:

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

   Nos passos seguintes, adiciona estes componentes à definição de recursos do Bank of Anthos:

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

   2. No Editor do Cloud Shell, substitua o conteúdo do ficheiro 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 secção spec adiciona Service, Deployment e StatefulSet à definição da sua aplicação.

   3. No Cloud Shell, aplique o recurso:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   4. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      São apresentados os componentes de um determinado tipo:

      

   Filtre recursos com seletores

   Neste ponto do tutorial, a lista de componentes inclui todos os recursos para ambas as aplicações de exemplo para o conjunto definido de componentes de todo o espaço de nomes. Por exemplo, o diagrama seguinte mostra o nginx serviço da aplicação de exemplo Nginx e a transactionhistory implementação da aplicação de exemplo Bank of Anthos:

   

   Para garantir que apenas são apresentados os recursos de uma aplicação, por exemplo, para a aplicação Bank of Anthos, pode usar seletores para identificar recursos específicos. Para ver como funcionam os seletores, adicione uma etiqueta ao seu recurso nos seguintes passos:

   1. No Cloud Shell, abra o ficheiro 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 secção metadata tem o seguinte aspeto:

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

      O ficheiro application.yaml concluído tem o seguinte aspeto:

      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. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      É apresentado o único recurso que corresponde a uma etiqueta específica:

      

   Aplique etiquetas a todos os recursos com kustomize

   Aplicar manualmente etiquetas a todos os recursos numa aplicação pode ser entediante. Os passos seguintes mostram como usar kustomize para adicionar etiquetas de forma eficiente a todos os recursos:

   1. No Cloud Shell, transfira kustomize:

      curl -s "https://raw.githubusercontent.com/\
      kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
      

   2. Crie e edite um ficheiro 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 de kustomization.yaml, especifica a que recursos aplicar as modificações e que modificações fazer. Neste caso, especifica que todos os recursos devem ter uma etiqueta comum de app.kubernetes.io/name: "bank-of-anthos".

   4. No Cloud Shell, elimine os recursos antigos:

      kubectl delete -f kubernetes-manifests/
      

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

   5. Aplique os recursos com a flag kustomize em vez da flag file:

      ./kustomize build kubernetes-manifests/ | kubectl apply -f -
      

   6. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      A página de detalhes apresenta os recursos da aplicação de exemplo Bank of Anthos e nenhum recurso da aplicação de exemplo Nginx:

      

   Adicionar metadados úteis na apresentação

   Pode apresentar metadados personalizados para uma aplicação na consolaGoogle Cloud . Pode incluir o que a aplicação faz, quem é o proprietário, onde encontrar mais informações sobre a mesma e como iniciar sessão. Este tipo de informações é valioso para vários exemplos de utilização, por exemplo, se operar várias aplicações na sua organização.

   As secções seguintes descrevem alguns dos metadados que pode adicionar.

   Adicione uma descrição e documentação

   Pode adicionar uma descrição e links que aparecem no painel Informações da aplicação. Para aceder a este painel a partir da página Detalhes, clique em Mostrar painel de informações.

   Para apresentar informações neste painel, defina elementos como description e links na secção descriptor do seu ficheiro application.yaml.

   descriptor:
       description:
       links:
       - description:
         url:
   

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

   1. No Editor do Cloud Shell, substitua o conteúdo do ficheiro 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, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   3. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

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

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

      

   Inclua o tipo de software

   A página Aplicações inclui um campo (Software) para o tipo de software na lista de aplicações. Pode personalizar este campo para ajudar a organizar e categorizar as suas aplicações de acordo com as suas necessidades. Por exemplo, pode indicar que o software é interno ou externo. Em alternativa, se tiver várias apps criadas a partir de um tipo base partilhado, pode indicar que tipo base uma aplicação implementa.

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

    descriptor:
       type: External App
   

   Pode apresentar o valor de type como uma hiperligação na consolaGoogle Cloud . Especifica o URL da hiperligação através da primeira entrada da secção links. Nos passos seguintes, atualize a secção links da seguinte forma:

       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 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
      
          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, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   3. Na Google Cloud consola, aceda à página Aplicações.

      Aceda a Aplicações

      App externa é apresentado no campo Software:

      

   Inclua uma versão da aplicação

   A página principal Aplicações inclui um campo para a versão. Na prática, o valor deste campo é atualizado programaticamente para fazer referência à versão real implementada.

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

     descriptor:
       type: External App
       version: "2.3.2"
   

   Nos passos seguintes, adiciona um campo para a versão da aplicação.

   1. No Editor do Cloud Shell, substitua o conteúdo do ficheiro 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, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   3. Na Google Cloud consola, aceda à página Aplicações.

      Aceda a Aplicações

      O campo Versão da aplicação Bank of Anthos é apresentado como 2.3.2:

      

   Adicione detalhes do responsável pela manutenção

   Neste passo, adiciona texto estático personalizado à secção principal da página Aplicações. Especifique estes detalhes na secção info do ficheiro application.yaml da seguinte forma:

     info:
     - name: LABEL
       value: STRING

   Para incluir valores estáticos, faculte detalhes para LABEL e STRING na secção info. Por exemplo, pode introduzir Owner para name e John Smith para value.

   1. No editor do Cloud Shell, substitua o conteúdo de 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
      
        info:
        - name: Owner
          value: John Smith
      

   2. No Cloud Shell, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   3. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      A página de detalhes inclui um proprietário para a aplicação Bank of Anthos:

      

   Exponha um ponto final da aplicação

   Além dos valores estáticos, pode expor valores dinâmicos da implementação em si. Nos passos seguintes, apresenta o endereço IP do balanceador de carga para que qualquer pessoa que veja a página de detalhes da aplicação possa aceder à aplicação diretamente.

   Para apresentar este valor, use a especificação serviceRef. Outras especificações válidas incluem configMapKeyRef, ingressRef, e secretKeyRef.

   Na especificação serviceRef, inclui estes valores dinâmicos através do tipo Reference. Para este tutorial, a especificação de serviceRef é a seguinte:

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

   Pode substituir os seguintes valores:

   • LABEL: uma etiqueta que descreve uma instância de referência específica, por exemplo, App Frontend URL
   • SERVICE_NAME: o nome que identifica o serviço, por exemplo, frontend
   • DATA_LOCATION: a localização dos dados no serviço, por exemplo, status.loadBalancer.ingress[0].ip

   As especificações serviceRef e ingressRef também suportam o elemento path. Se o seu URL exigir detalhes relacionados com o 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 ponto final são concatenados, por exemplo, 35.202.90.0/wp-admin.

   Também pode forçar a utilização de HTTP ou HTTPS através do campo protocol da seguinte forma:

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

   Estes detalhes geram o seguinte URL:

   https://35.202.90.0/wp-admin
   

   Nos passos seguintes, vai usar serviceRef para expor o endereço IP do balanceador de carga do serviço para a aplicação Bank of Anthos:

   1. No editor do Cloud Shell, substitua o conteúdo do ficheiro 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, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   3. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      A página de detalhes inclui um endereço IP do ponto final para a aplicação Bank of Anthos:

      

   Forneça credenciais de acesso

   Como mencionado anteriormente, pode expor segredos do Kubernetes através da Google Cloud consola usando o elemento secretKeyRef. Neste tutorial, fornece um nome de utilizador e uma palavra-passe ao operador para que possa iniciar sessão na aplicação.

   1. No Cloud Shell, crie o Secret:

      kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
      

      Nota: este segredo não é usado na aplicação. Cria-o para fins de demonstração neste tutorial.

   2. No editor do Cloud Shell, substitua o conteúdo do ficheiro application.yaml colando o seguinte. Esta atualização inclui referências ao nome de utilizador e à palavra-passe 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, implemente o recurso Application:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   4. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

   5. Clique em Pré-visualizar dados secretos. O nome de utilizador e a palavra-passe são revelados:

      

   A capacidade de revelar dados secretos pode ser uma funcionalidade útil para as suas equipas de operações. No entanto, a capacidade de ver estes segredos é regida pelas autorizações de acesso da Identity and Access Management (IAM) para a página de detalhes do GKE. Qualquer pessoa com autorizações para ver clusters também pode ver segredos, pelo que é importante considerar cuidadosamente o que expõe.

   Adicione um ícone da aplicação

   Para que a sua aplicação se destaque, pode incluir um logótipo que é apresentado na lista de aplicações e na página de detalhes. Para incluir um logótipo, especifica o URI de dados da imagem na anotação kubernetes-engine.cloud.google.com/icon.

   A conversão de uma imagem num URI de dados está fora do âmbito deste tutorial. No entanto, uma pesquisa no Google por "converter imagem em URI de dados" devolve várias utilidades para ajudar a produzir a string de dados a partir de uma imagem. Uma vez que o URI de dados da imagem usada nesta secção é muito longo, não é prático incluí-lo no tutorial. Pode ver o URI de dados completo no ficheiro application.yamlconcluído. A string do URI de dados deve começar da seguinte forma: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... Termina com K5CYII=. Certifique-se de que não inclui aspas à direita nem carateres HTML.

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

   Para adicionar um ícone, atualize a secção metadata de 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 ficheiro application.yaml concluído que é referenciado anteriormente.

   2. No editor do Cloud Shell, cole o código que copiou após a secção labels na secção metadata de application.yaml.

      Essa secçã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, implemente o recurso da aplicação:

      kubectl apply -f kubernetes-manifests/application.yaml
      

   4. Na Google Cloud consola, aceda à página Aplicações.

      Aceda a Aplicações

      É apresentado um logótipo na lista de aplicações:

      

   5. Na Google Cloud consola, aceda à página de detalhes da aplicação Bank of Anthos.

      Aceda aos detalhes do Bank of Anthos

      É apresentado um logótipo no cabeçalho da página de detalhes:

      

   Limpar

   Para evitar incorrer em custos na sua Google Cloud conta pelos recursos usados neste tutorial, pode eliminar o Google Cloud projeto que criou para este tutorial.

   Elimine o projeto

   Atenção: a eliminação de um projeto tem os seguintes efeitos:

   • Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
   • Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

   Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

   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.

   O que se segue?

   • Reveja outros exemplos de ficheiros application.yaml na pasta Kubernetes do click-to-deployrepositório do GitHub. Procure outros ficheiros application.yaml em chart/<application>/templates/ para as várias apps, por exemplo, como se vê neste ficheiro.
   • Use as implementações do Marketplace para as soluções de clicar para implementar da Google para o GKE.
   • Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.