Como usar a página "Aplicativos do GKE" no console do Google 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 Google Cloud.

Custos

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

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

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

Antes de começar

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

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
Ative as APIs Compute Engine and Kubernetes Engine.
Ative as APIs
No Console do Google 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

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.
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.

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 Google Cloud, é possível visualizar esses recursos nas páginas do GKE Cargas de trabalho e Serviços e Entrada.

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

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.

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 Google Cloud:
- Na página Cargas de trabalho
- Na página Serviços e Entrada
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:

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

(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.

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.

Cole as linhas a seguir para definir seu primeiro aplicativo:

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

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

No Cloud Shell, aplique o recurso:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, abra a página Aplicativos.

Acesse Aplicativos

A página Aplicativos exibe os recursos adicionados:

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 Google 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:

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

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.

No Cloud Shell, aplique o recurso:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos

Os componentes de determinado tipo são exibidos:

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:

No Cloud Shell, abra o arquivo frontend.yaml:
```
edit kubernetes-manifests/frontend.yaml
```

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

No Cloud Shell, aplique os recursos:
```
kubectl apply -f kubernetes-manifests/
```
No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos

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

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:

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

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

Crie e edite um arquivo kustomization.yaml:

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

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".

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.
Aplique os recursos usando a sinalização kustomize em vez da sinalização file:
```
./kustomize build kubernetes-manifests/ | kubectl apply -f -
```
No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do 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:

Como adicionar metadados úteis na tela

É possível exibir metadados personalizados de um aplicativo no console do Google 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:

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos
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:

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 Google 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

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, abra a página Aplicativos.

Acesse Aplicativos

O app externo é exibido no campo Software:

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.

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, abra a página Aplicativos.

Acesse Aplicativos

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

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.

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos

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

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:

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do 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:

Forneça credenciais de acesso

Como mencionado anteriormente, é possível expor Secrets do Kubernetes pelo console do Google 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.

No Cloud Shell, crie o secret:
```
kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
```
Observação: esse secret não é usado no aplicativo. Ele é criado para fins de demonstração neste tutorial.

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

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos
Clique em Visualizar dados do secret. O nome de usuário e a senha são exibidos:

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:

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.

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:

No Cloud Shell, implante o recurso do aplicativo:

kubectl apply -f kubernetes-manifests/application.yaml

No console do Google Cloud, abra a página Aplicativos.

Acesse Aplicativos

Um logotipo é exibido na lista de aplicativos:
No console do Google Cloud, acesse a página de detalhes do aplicativo do Banco do Anthos.

Acesse detalhes do Bank of Anthos

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

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

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

Analise outros exemplos de arquivos do application.yaml na pasta do Kubernetes do repositório click-to-deploy do GitHub. Procure outros arquivos application.yaml em chart/<application>/templates/ para os vários apps. Por exemplo, como visto neste arquivo.
Use implantações do Marketplace em soluções "Click-to-deploy" do Google para o GKE.
Confira arquiteturas de referência, diagramas e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.

Como usar a página "Aplicativos do GKE" no console do Google Cloud

Objetivos

Custos

Antes de começar

Como preparar o ambiente

Como instalar os aplicativos da amostra

Como preparar o GKE

Como incluir recursos do aplicativo

Crie o recurso base Aplicativo

Inclua recursos por componente

Filtre recursos com seletores

Aplique rótulos a todos os recursos com o kustomize

Como adicionar metadados úteis na tela

Adicione descrição e documentação

Inclua o tipo de software

Inclua uma versão do aplicativo

Adicione detalhes do responsável pela manutenção

Exponha um endpoint do aplicativo

Forneça credenciais de acesso

Adicione um ícone do aplicativo

Limpeza

Exclua o projeto

A seguir

Aplique rótulos a todos os recursos com o `kustomize`