Esta página foi traduzida pela API Cloud Translation.

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 mostramos 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 doGoogle Cloud .

Custos

Neste documento, você vai 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 um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

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 (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
Verify that billing is enabled for your Google Cloud project.
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
In the Google Cloud console, activate Cloud Shell.

Activate 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 seu projeto 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 Google 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 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:
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 Google Cloud , acesse 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:

É possível adicionar vários tipos de componentes para exibir no console doGoogle 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 Google Cloud console, 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:
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:

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 Google Cloud console, 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:
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 Google Cloud console, 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:
Como adicionar metadados úteis na tela

É possível exibir metadados personalizados de um aplicativo no console doGoogle 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 Google Cloud console, 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:
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 doGoogle 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 Google Cloud , acesse 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.
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 Google Cloud , acesse 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.
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 Google Cloud console, 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:
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 Google Cloud console, 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:
Forneça credenciais de acesso

Como mencionado anteriormente, é possível expor Secrets do Kubernetes pelo console doGoogle 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
  Observação: esse secret não é usado no aplicativo. Ele é criado para fins de demonstração neste tutorial.
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 Google Cloud console, 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:
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 Google Cloud , acesse a página Aplicativos.
  
  Acesse Aplicativos
  
  Um logotipo é exibido na lista de aplicativos:
5. No Google Cloud console, 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:
Limpar

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.

Excluir o projeto
1. In the Google Cloud console, go to the Manage resources page.
  Go to Manage resources
2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.
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, tutoriais 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 Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

Limpar

Excluir o projeto

A seguir

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

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