Utilizzo della pagina Applicazioni GKE nella console Google Cloud

Questo tutorial descrive come utilizzare la pagina Applicazioni di Google Kubernetes Engine (GKE) nella console Google Cloud.

Quando adotti Kubernetes per molte applicazioni e risorse, può essere difficile identificare e monitorare i vari componenti correlati a un'applicazione. Quando esegui il deployment di più applicazioni in ogni spazio dei nomi, può essere difficile sapere quali risorse sono correlate a quale applicazione. Inoltre, spesso devi cercare in più posizioni la documentazione e i metadati che descrivono le applicazioni, i relativi proprietari e come interagire con i servizi.

GKE aiuta a risolvere questi problemi con la pagina Applications:

Una visualizzazione parziale della pagina Applicazioni che mostra un elenco di applicazioni insieme a varie proprietà.

La pagina Applicazioni è una risorsa indipendente all'interno dell'architettura che descrive i metadati del sistema. Puoi utilizzare questa pagina per organizzare visivamente le risorse senza modificare l'architettura. Se definisci i valori in un file YAML, puoi raggruppare tutte le risorse dell'applicazione e includere metadati vitali per il tuo team operativo. La creazione, la modifica e l'eliminazione del file YAML non influiscono sulle risorse esistenti, quindi puoi lavorare immediatamente con le risorse senza rischi per il sistema.

Per dimostrare questa pagina, questo tutorial mostra come implementare la risorsa applicazione Kubernetes in un'applicazione e aggiungere metadati definiti dall'utente per organizzare e semplificare la gestione dell'applicazione in GKE.

Questo tutorial è rivolto agli sviluppatori che creano applicazioni da eseguire in GKE. Si presume che tu abbia familiarità con i concetti di base di Kubernetes e che tu abbia una certa esperienza nella scrittura di file YAML delle risorse Kubernetes.

Obiettivi

  • Presenta la risorsa Kubernetes Application.
  • Aggiungi la risorsa Kubernetes Application a un'architettura esistente.
  • Crea e visualizza informazioni personalizzate su un'applicazione tramite la console Google Cloud.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

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

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the Compute Engine and Kubernetes Engine APIs.

    Enable the APIs

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

    Activate Cloud Shell

    Esegui i comandi per questo tutorial in Cloud Shell o nell'editor di Cloud Shell.

preparazione dell'ambiente

  1. In Cloud Shell, imposta le variabili di ambiente per il progetto:

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

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

  2. Crea un cluster GKE:

    gcloud container clusters create sample-cluster

    Per questo tutorial, esegui le applicazioni in un cluster GKE predefinito.

Installazione delle applicazioni di esempio

In questo tutorial simulerai più applicazioni in esecuzione nello stesso ambito utilizzando un'applicazione di esempio Nginx di base e l'applicazione di esempio Bank of Anthos.

  1. In Cloud Shell, installa l'applicazione di esempio Nginx:

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

    Questo comando crea una risorsa StatefulSet denominata web e un servizio chiamato nginx. Nella console Google Cloud, puoi visualizzare queste risorse nelle pagine GKE Workload e Servizi e Ingress.

  2. Clona il repository GitHub contenente l'applicazione di esempio Bank of Anthos:

    git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
cd bank-of-anthos

  3. Genera una chiave SSH e archiviala come secret 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

    L'applicazione di esempio Bank of Anthos richiede una chiave SSH per l'esecuzione.

  4. Esegui il deployment dell'applicazione di esempio nel cluster:

    kubectl apply -f kubernetes-manifests

    Dopo alcuni istanti, puoi visualizzare le risorse dell'applicazione nelle seguenti pagine della console Google Cloud:

    Tieni presente quanto segue:

    • Le risorse per le applicazioni di esempio Nginx e Bank of Anthos sono mescolate.
    • Non sono ancora visualizzate risorse nella pagina Applicazioni. Compila la pagina Applications (Applicazioni) nei passaggi successivi.

Preparazione di GKE

Le risorse visualizzate nella pagina Applicazioni sono specificate con il tipo di risorsa Kubernetes Application, una definizione di risorsa personalizzata (CRD) fornita dal progetto open source Kubernetes. Per impostazione predefinita, il CRD Application non è abilitato in Kubernetes. Alcuni servizi in GKE, come Marketplace e il deployment delle applicazioni, installano il CRD dell'applicazione, ma se non utilizzi nessuno di questi servizi, il CRD dell'applicazione non è disponibile per impostazione predefinita.

Per installare il CRD dell'applicazione:

  1. In Cloud Shell, applica l'Application CRD una volta su ogni cluster:

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

  2. (Facoltativo) Al termine del comando, visualizza il CRD dell'applicazione sul cluster:

    kubectl get crd

    Il seguente output è un elenco di CRD installati, tra cui 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

Sono incluse le risorse dell'applicazione

Ora che il CRD dell'applicazione è disponibile nel cluster, il passaggio successivo consiste nel creare ed eseguire il deployment di un'istanza della risorsa Application.

Poiché la risorsa Application è una risorsa Kubernetes, ha una struttura simile alle altre risorse Kubernetes, inclusi i campi e le opzioni per apiVersion, kind, metadata e spec:

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

Nelle sezioni seguenti, lavorerai con vari campi e opzioni disponibili nella risorsa Application.

Crea la risorsa Application di base

Puoi aggiungere la risorsa Application a qualsiasi insieme di risorse esistente. In questo tutorial, inizierai con una risorsa vuota e la completerai in ogni sezione.

  1. In Cloud Shell, crea e modifica un file application.yaml nella directory kubernetes-manifests:

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

    L'editor di Cloud Shell si apre e mostra un file vuoto.

  2. Incolla le seguenti righe per definire la tua prima applicazione:

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

  3. Nella barra dei menu di Cloud Shell, fai clic su Apri terminale.

  4. In Cloud Shell, applica la risorsa:

    kubectl apply -f kubernetes-manifests/application.yaml

  5. Nella console Google Cloud, vai alla pagina Applications (Applicazioni).

    Vai a Applicazioni

    Nella pagina Applicazioni vengono visualizzate le risorse che hai aggiunto:

    L'applicazione Bank of Anthos è inclusa nell'elenco delle applicazioni.

Includi risorse per componente

La pagina Applications (Applicazioni) mostra l'applicazione Bank of Anthos. Quando fai clic su bank-of-anthos nel campo Nome, vedrai le informazioni di base sull'applicazione:

I dettagli dell'applicazione includono cluster, spazio dei nomi e data di creazione.

Puoi aggiungere vari tipi di componenti da visualizzare nella console Google Cloud. Ad esempio, per mostrare i servizi, i deployment e i StatefulSet, modifica la sezione componentKinds della definizione application.yaml, ad esempio come segue:

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

Nei passaggi che seguono, aggiungi questi componenti alla definizione della risorsa Bank of Anthos:

  1. Nella barra dei menu di Cloud Shell, fai clic su Apri editor.

  2. Nell'editor di Cloud Shell, sovrascrivi i contenuti del kubernetes-manifests/application.yaml file incollando quanto segue:

    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

    L'aggiunta della sezione spec aggiunge Service, Deployment e StatefulSet alla definizione dell'applicazione.

  3. In Cloud Shell, applica la risorsa:

    kubectl apply -f kubernetes-manifests/application.yaml

  4. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    Vengono visualizzati i componenti di un determinato tipo:

    L'elenco dei dettagli include tipi di componenti come Servizio e Deployment.

Filtrare le risorse con i selettori

A questo punto del tutorial, l'elenco dei componenti include tutte le risorse per entrambe le applicazioni di esempio per l'insieme definito di componenti dell'intero spazio dei nomi. Ad esempio, il seguente diagramma mostra il servizio nginx dell'applicazione di esempio Nginx e il deployment transactionhistory dell'applicazione di esempio Bank of Anthos:

L'elenco dei componenti viene generato da tutte le applicazioni nell'espandibilità.

Per assicurarti che vengano visualizzate solo le risorse di un'applicazione, ad esempio per l'applicazione Bank of Anthos, puoi utilizzare i selettori per identificare risorse specifiche. Per capire come funzionano i selettori, aggiungi un'etichetta alla risorsa nel seguente modo:

  1. In Cloud Shell, apri il file frontend.yaml:

    edit kubernetes-manifests/frontend.yaml

  2. Nell'editor di Cloud Shell, incolla la seguente voce label dopo la riga 18:

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

    La sezione metadata ha il seguente aspetto:

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

    Il file application.yaml completato ha il seguente aspetto:

    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. In Cloud Shell, applica le risorse:

    kubectl apply -f kubernetes-manifests/

  4. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    Viene visualizzata l'unica risorsa che corrisponde a un'etichetta specifica:

    L'elenco dei componenti mostra la risorsa Deployment.

Applica le etichette a tutte le risorse con kustomize

L'applicazione manuale delle etichette a ogni risorsa di un'applicazione può essere tediosa. I passaggi riportati di seguito mostrano come utilizzare kustomize per aggiungere in modo efficiente le etichette a tutte le risorse:

  1. In Cloud Shell, scarica kustomize:

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

  2. Crea e modifica un file kustomization.yaml:

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

  3. Nell'editor di Cloud Shell, aggiungi le seguenti righe 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"

    In questa definizione kustomization.yaml, specifica le risorse a cui applicare le modifiche e le modifiche da apportare. In questo caso, specifichi che tutte le risorse devono avere un'etichetta comune di app.kubernetes.io/name: "bank-of-anthos".

  4. In Cloud Shell, elimina le risorse precedenti:

    kubectl delete -f kubernetes-manifests/

    È necessario eliminare le risorse precedenti prima di applicare le nuove risorse specificate in kustomization.yaml.

  5. Applica le risorse utilizzando il flag kustomize anziché il flag file:

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

  6. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    La pagina dei dettagli mostra le risorse per l'applicazione di esempio Bank of Anthos e nessuna risorsa dell'applicazione di esempio Nginx:

    Vengono visualizzati solo i componenti di Bank of Anthos, come StatefulSet.

Aggiunta di metadati utili nella visualizzazione

Puoi visualizzare i metadati personalizzati di un'applicazione nella console Google Cloud. Potresti includere la funzionalità dell'applicazione, chi ne è il proprietario, dove trovare ulteriori informazioni e come accedere. Questo tipo di informazioni è utile per vari casi d'uso, ad esempio se gestisci più applicazioni all'interno della tua organizzazione.

Le sezioni seguenti descrivono alcuni dei metadati che puoi aggiungere.

Aggiungi una descrizione e la documentazione

Puoi aggiungere una descrizione e dei link che verranno visualizzati nel riquadro Informazioni sull'applicazione. Per accedere a questo riquadro dalla pagina Dettagli, fai clic su Mostra riquadro Informazioni.

Per visualizzare le informazioni in questo riquadro, definisci elementi come description e links nella sezione descriptor del file application.yaml.

descriptor:
    description:
    links:
    - description:
      url:

Per aggiornare la sezione descriptor:

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del application.yaml file incollando quanto segue:

    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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

  4. Per esaminare gli aggiornamenti, fai clic su Mostra riquadro informazioni.

    Il riquadro Informazioni sull'applicazione mostra una descrizione e un elenco di documenti:

    I documenti nell'elenco sono formattati come link ipertestuali.

Includi il tipo di software

La pagina Applicazioni include un campo (Software) per il tipo di software nell'elenco delle applicazioni. Puoi personalizzare questo campo per organizzare e classificare le applicazioni in base alle tue esigenze. Ad esempio, potresti indicare se il software è interno o esterno. In alternativa, se hai più app create da un tipo di base condiviso, puoi indicare il tipo di base implementato da un'applicazione.

Per aggiungere una descrizione personalizzata al tipo di software, utilizza il campo type nella sezione descriptor del file application.yaml:

 descriptor:
    type: External App

Puoi visualizzare il valore di type come link ipertestuale nella console Google Cloud. Specifica l'URL del link ipertestuale utilizzando la prima voce della sezione links. Nei passaggi seguenti, aggiorna la sezione links come segue:

    links:
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti di application.yaml incollando quanto segue:

    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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console Google Cloud, vai alla pagina Applications (Applicazioni).

    Vai a Applicazioni

    App esterna viene visualizzato nel campo Software:

    Il tipo di software App esterna è formattato come link ipertestuale.

Includi una versione dell'applicazione

La pagina principale Applicazioni include un campo per la versione. In pratica, il valore di questo campo viene aggiornato in modo programmatico per fare riferimento alla versione effettiva di cui è stato eseguito il deployment.

Per compilare il campo della versione, includi il campo version in descriptor come nell'esempio seguente:

  descriptor:
    type: External App
    version: "2.3.2"

Nei passaggi successivi, aggiungi un campo per la versione dell'applicazione.

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del application.yaml file incollando quanto segue:

    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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console Google Cloud, vai alla pagina Applications (Applicazioni).

    Vai a Applicazioni

    Il campo Versione per l'applicazione Bank of Anthos è visualizzato come 2.3.2:

    I dettagli dell'applicazione includono i campi del tipo e della versione del software.

Aggiungere i dettagli del gestore

In questo passaggio, aggiungi un testo statico personalizzato alla sezione principale della pagina Applicazioni. Specifica questi dettagli nella sezione info del application.yaml file come segue:

  info:
  - name: LABEL
    value: STRING

Per includere valori statici, fornisci i dettagli per LABEL e STRING nella sezione info. Ad esempio, potresti inserire Owner per name e John Smith per value.

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti di application.yaml incollando quanto segue:

    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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    La pagina dei dettagli include un proprietario per l'applicazione Bank of Anthos:

    John Smith deve essere indicato come proprietario.

Esporre un endpoint dell'applicazione

Oltre ai valori statici, puoi esporre valori dinamici direttamente dal deployment. Nei passaggi che seguono, mostri l'indirizzo IP del bilanciatore del carico in modo che chiunque visualizzi la pagina dei dettagli dell'applicazione possa accedere direttamente all'applicazione.

Per visualizzare questo valore, utilizza la specifica serviceRef. Altre specifiche valide includono configMapKeyRef, ingressRef e secretKeyRef.

Nella specifica serviceRef, includi questi valori dinamici utilizzando il tipo Reference. Per questo tutorial, la specifica per serviceRef è la seguente:

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

Puoi sostituire i seguenti valori:

  • LABEL: un'etichetta che descrive un'istanza di riferimento specifica, ad esempio App Frontend URL
  • SERVICE_NAME: il nome che identifica il servizio, ad esempio frontend
  • DATA_LOCATION: la posizione dei dati nel Servizio, ad esempio status.loadBalancer.ingress[0].ip

Le specifiche serviceRef e ingressRef supportano anche l'elemento path. Se l'URL richiede dettagli relativi al percorso, includili nel campo path:

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

L'indirizzo IP e il percorso dell'endpoint vengono concatenati, ad esempio 35.202.90.0/wp-admin.

Puoi anche forzare l'utilizzo di HTTP o HTTPS utilizzando il campo protocol come segue:

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

Questi dettagli producono il seguente URL:

https://35.202.90.0/wp-admin

Nei passaggi seguenti, utilizzi serviceRef per esporre l'indirizzo IP del bilanciatore del carico del servizio per l'applicazione Bank of Anthos:

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del application.yaml file con quanto segue:

    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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    La pagina dei dettagli include un indirizzo IP dell'endpoint per l'applicazione Bank of Anthos:

    L'indirizzo IP è contrassegnato come URL frontend dell'app.

Fornisci le credenziali di accesso

Come accennato in precedenza, puoi esporre i secret Kubernetes tramite la console Google Cloud utilizzando l'elemento secretKeyRef. In questo tutorial fornisci all'operatore un nome utente e una password per consentirgli di accedere all'applicazione.

  1. In Cloud Shell, crea il segreto:

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

  2. Nell'editor di Cloud Shell, sovrascrivi i contenuti del application.yaml file incollando quanto segue. Questo aggiornamento include riferimenti al nome utente e alla password nell'annotazione 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. In Cloud Shell, esegui il deployment della risorsa Application:

    kubectl apply -f kubernetes-manifests/application.yaml

  4. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

  5. Fai clic su Visualizza l'anteprima dei dati secret. Il nome utente e la password vengono visualizzati:

    I dettagli dell'applicazione includono i link per accedere alle credenziali.

La possibilità di rivelare i dati dei secret può essere una funzionalità utile per i team operativi. Tuttavia, la possibilità di visualizzare questi secret è regolata dalle autorizzazioni di accesso di Identity and Access Management (IAM) per la pagina dei dettagli di GKE. Chiunque abbia le autorizzazioni per visualizzare i cluster può anche visualizzare i secret, quindi è importante valutare attentamente cosa esporre.

Aggiungere un'icona dell'applicazione

Per mettere in evidenza la tua applicazione, puoi includere un logo che venga visualizzato nell'elenco delle applicazioni e nella pagina dei dettagli. Per includere un logo, specifica l'URI di dati dell'immagine nell'annotazione kubernetes-engine.cloud.google.com/icon.

La conversione di un'immagine in un URI dati non rientra nell'ambito di questo tutorial. Tuttavia, una ricerca su Google per "converti immagine in uri dati" restituisce vari strumenti utili per produrre la stringa di dati da un'immagine. Poiché l'URI data dell'immagine utilizzata in questa sezione è molto lungo, non è pratico includerlo nel tutorial. L'URI dei dati completi è visibile nel file application.yaml completato. La stringa URI dati deve iniziare come segue: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... e termina con K5CYII=. Assicurati di non includere virgolette finali o caratteri HTML.

Il file completo application.yaml è disponibile come gist per riferimento futuro.

Per aggiungere un'icona, aggiorna la sezione metadata di application.yaml:

  1. Copia il seguente codice:

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

    Sostituisci DATA_URI con la stringa trovata nel file application.yaml completato a cui si fa riferimento in precedenza.

  2. Nell'editor di Cloud Shell, incolla il codice che hai copiato dopo la sezione labels nella sezione metadata di application.yaml.

    Questa sezione di application.yaml ha un aspetto simile al seguente, dove DATA_URI rappresenta il valore dell'URI dati.

    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. In Cloud Shell, esegui il deployment della risorsa dell'applicazione:

    kubectl apply -f kubernetes-manifests/application.yaml

  4. Nella console Google Cloud, vai alla pagina Applications (Applicazioni).

    Vai a Applicazioni

    Nell'elenco delle applicazioni viene visualizzato un logo:

    Un logo viene visualizzato accanto al nome dell'applicazione nell'elenco delle applicazioni.

  5. Nella console Google Cloud, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    Un logo viene visualizzato nell'intestazione della pagina dei dettagli:

    Un logo viene visualizzato nella parte superiore dell'elenco dei dettagli dell'applicazione.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eliminare il Google Cloud progetto che hai creato per questo tutorial.

Elimina il progetto

  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.

Passaggi successivi