Questa pagina è stata tradotta dall'API Cloud Translation.

Configurazione di cluster con VPC condiviso

Autopilot Standard

Questa guida mostra come creare due cluster Google Kubernetes Engine (GKE), in progetti separati, che utilizzano un VPC condiviso. Per informazioni generali sul networking di GKE, consulta la Panoramica della rete.

Panoramica

Con un VPC condiviso, designi un progetto come al progetto host e puoi collegare altri progetti, denominati progetti di servizio, del progetto host. Nel progetto host crei reti, subnet, intervalli di indirizzi secondari, regole firewall e altre risorse di rete. Poi condividi le subnet selezionate, inclusi gli intervalli secondari, con i progetti di servizio. I componenti in esecuzione in un progetto di servizio possono utilizzare il VPC condiviso per possano comunicare con i componenti in esecuzione negli altri progetti di servizio.

Puoi utilizzare il VPC condiviso Cluster Autopilot e con a livello di zona e regionale di cluster standard.

I cluster standard che utilizzano la VPC condivisa non possono utilizzare reti legacy e devono avere attivato il routing del traffico VPC nativo. I cluster Autopilot abilitano sempre una rete VPC nativa routing del traffico.

Puoi configurare il VPC condiviso quando crei un nuovo cluster. GKE non supporta la conversione di cluster esistenti Modello VPC condiviso.

Con il VPC condiviso si applicano determinati limiti e quote. Ad esempio, esiste una quota per il numero di reti in un progetto ed esiste un limite al numero di progetti di servizio che possono essere collegati a un progetto host. Per maggiori dettagli, consulta Quote e limiti.

Informazioni sugli esempi

Gli esempi in questa guida configurano l'infrastruttura per un'applicazione web a due livelli, come descritto nella Panoramica del VPC condiviso.

Prima di iniziare

Prima di iniziare a configurare un cluster con un VPC condiviso:

Assicurati di avere un'organizzazione Google Cloud.
Assicurati che la tua organizzazione abbia tre progetti Google Cloud.
Assicurati di avere già familiarità con i concetti del VPC condiviso inclusi i vari ruoli IAM (Identity and Access Management) utilizzata dal VPC condiviso. Le attività descritte in questa guida devono essere eseguite da un amministratore VPC condiviso.
Assicurati di avere già familiarità con i vincoli dei criteri dell'organizzazione applicabili dell'organizzazione, della cartella o dei progetti. Un amministratore delle norme dell'organizzazione potrebbe aver definito vincoli che limitano i progetti che possono essere progetti host VPC condivisi o che limitano le subnet che possono essere condivise. Consulta vincoli dei criteri dell'organizzazione per ulteriori informazioni.

Prima di eseguire gli esercizi di questa guida:

Scegli uno dei tuoi progetti come progetto host.
Scegli due progetti come progetti di servizio.

Ogni progetto ha un nome, un ID e un numero. In alcuni casi, il nome e l'ID sono le stesse. Questa guida utilizza i seguenti nomi e segnaposto semplici per fare riferimento ai tuoi progetti:

Nome descrittivo	Segnaposto ID progetto	Segnaposto del progetto numero
Il tuo progetto host	`HOST_PROJECT_ID`	`HOST_PROJECT_NUM`
Il tuo primo progetto di servizio	`SERVICE_PROJECT_1_ID`	`SERVICE_PROJECT_1_NUM`
Il secondo progetto di servizio	`SERVICE_PROJECT_2_ID`	`SERVICE_PROJECT_2_NUM`

Trovare gli ID e i numeri dei progetti

Puoi trovare l'ID e i numeri del progetto utilizzando la CLI gcloud o la console Google Cloud.

Console

Vai alla home page della console Google Cloud.

Vai alla home page
Nel selettore dei progetti, seleziona il progetto che hai scelto come progetto host.
In Informazioni sul progetto puoi vedere il nome, l'ID e il numero del progetto. Prendi nota dell'ID e del numero per riferimento futuro.
Ripeti l'operazione per ognuno dei progetti che hai scelto dei progetti di servizio.

gcloud

Elenca i tuoi progetti con il seguente comando:

gcloud projects list

L'output mostra i nomi, gli ID e i numeri dei progetti. Prendi nota dell'ID e del numero per riferimento futuro:

PROJECT_ID        NAME        PROJECT_NUMBER
host-123          host        1027xxxxxxxx
srv-1-456         srv-1       4964xxxxxxxx
srv-2-789         srv-2       4559xxxxxxxx

Abilitazione dell'API GKE nei tuoi progetti

Prima di continuare con gli esercizi di questa guida, assicurati che l'API GKE sia abilitata in tutti e tre i progetti. L'attivazione dell'API in un progetto crea un account di servizio GKE per il progetto. Per eseguire le restanti attività di questa guida, ogni progetto deve avere un account di servizio GKE.

Puoi abilitare l'API GKE utilizzando la console Google Cloud o Google Cloud CLI.

Console

Vai alla pagina API e servizi nella console Google Cloud.

Vai ad API e servizi
Nel selettore dei progetti, scegli il progetto che hai scelto sarà il progetto host.
Se l'API Kubernetes Engine è nell'elenco delle API, è già abilitata e non devi fare nulla. Se non è nel fai clic su Abilita API e servizi. Cerca Kubernetes Engine API. Fai clic sulla scheda API Kubernetes Engine e poi su Abilita.
Ripeti questi passaggi per ogni progetto scelto come progetto progetto di servizio. Il completamento di ogni operazione potrebbe richiedere del tempo.

gcloud

Abilita l'API GKE per i tre progetti. Ogni operazione può il completamento dell'operazione richiede tempo:

gcloud services enable container.googleapis.com --project HOST_PROJECT_ID
gcloud services enable container.googleapis.com --project SERVICE_PROJECT_1_ID
gcloud services enable container.googleapis.com --project SERVICE_PROJECT_2_ID

Creazione di una rete e due subnet

In questa sezione, imparerai a:

Nel progetto host, crea una rete denominata shared-net.
Crea due subnet denominate tier-1 e tier-2.
Per ogni subnet, crea due intervalli di indirizzi secondari: uno per i servizi e una per i pod.

Console

Vai alla pagina Reti VPC nella console Google Cloud.

Vai alle reti VPC
Nel selettore dei progetti, seleziona il progetto host.
Fai clic su Crea rete VPC.
In Nome, inserisci shared-net.
In Modalità di creazione subnet, seleziona Personalizzata.
Nella casella Nuova subnet, in Nome, inserisci tier-1.
In Regione, seleziona una regione.
In Tipo di stack IP, seleziona IPv4 (stack singolo).
Per Intervallo IPv4, inserisci 10.0.4.0/22.
Fai clic su Crea intervallo IPv4 secondario. Per Nome intervallo subnet, inseriscitier-1-services e per Intervallo IPv4 secondario, inserisci 10.0.32.0/20.
Fai clic su Aggiungi intervallo IP. Per Nome intervallo subnet, inseriscitier-1-pods e per Intervallo IPv4 secondario, inserisci 10.4.0.0/14.
Fai clic su Aggiungi subnet.
In Nome, inserisci tier-2.
In Regione, seleziona la stessa regione che hai selezionato per la precedente una subnet.
Per Intervallo IPv4, inserisci 172.16.4.0/22.
Fai clic su Crea intervallo IPv4 secondario. Per Nome intervallo subnet, inseriscitier-2-services e per Intervallo IPv4 secondario, inserisci 172.16.16.0/20.
Fai clic su Aggiungi intervallo IP. Per Nome intervallo subnet, inseriscitier-2-pods e per Intervallo IPv4 secondario, inserisci 172.20.0.0/14.
Fai clic su Crea.

gcloud

Nel progetto host, crea una rete denominata shared-net:

gcloud compute networks create shared-net \
    --subnet-mode custom \
    --project HOST_PROJECT_ID

Nella nuova rete, crea una subnet denominata tier-1:

gcloud compute networks subnets create tier-1 \
    --project HOST_PROJECT_ID \
    --network shared-net \
    --range 10.0.4.0/22 \
    --region COMPUTE_REGION \
    --secondary-range tier-1-services=10.0.32.0/20,tier-1-pods=10.4.0.0/14

Crea un'altra subnet denominata tier-2:

gcloud compute networks subnets create tier-2 \
    --project HOST_PROJECT_ID \
    --network shared-net \
    --range 172.16.4.0/22 \
    --region COMPUTE_REGION \
    --secondary-range tier-2-services=172.16.16.0/20,tier-2-pods=172.20.0.0/14

Sostituisci COMPUTE_REGION con un Regione di Compute Engine.

Determinazione dei nomi degli account di servizio nei progetti di servizio

Hai due progetti di servizio, ciascuno con diversi account di servizio. Questa sezione riguarda i tuoi account di servizio GKE e i tuoi account di servizio API di Google. Devi conoscere i nomi di questi account di servizio per la sezione successiva.

La tabella seguente elenca i nomi degli account di servizio GKE e Google API nei tuoi due progetti di servizio:

Tipo di account di servizio	Nome account di servizio
GKE	service-`SERVICE_PROJECT_1_NUM`@container-engine-robot.iam.gserviceaccount.com
GKE	service-`SERVICE_PROJECT_2_NUM`@container-engine-robot.iam.gserviceaccount.com
API di Google	`SERVICE_PROJECT_1_NUM`@cloudservices.gserviceaccount.com
API di Google	`SERVICE_PROJECT_2_NUM`@cloudservices.gserviceaccount.com

Abilitazione del VPC condiviso e concessione dei ruoli

Per eseguire le attività descritte in questa sezione, assicurati che la tua organizzazione abbia definito Un amministratore VPC condiviso ruolo.

In questa sezione, dovrai svolgere le seguenti attività:

Nel progetto host, abilita il VPC condiviso.
Collega i tuoi due progetti di servizio al progetto host.
Concedi i ruoli IAM appropriati agli account di servizio appartenente ai tuoi progetti di servizio:
- Nel primo progetto di servizio, concedi a due account di servizio il ruolo Compute Network User nella subnet tier-1 del progetto host.
- Nel secondo progetto di servizio, concedi a due account di servizio il ruolo Compute Network User nella subnet tier-2 del progetto host.

Console

Esegui i seguenti passaggi per abilitare il VPC condiviso, collegare il servizio progetti e concedere ruoli:

Vai alla pagina Rete VPC condivisa nella console Google Cloud.

Vai al VPC condiviso
Nel selettore del progetto, seleziona il progetto host.
Fai clic su Configura un VPC condiviso. Viene visualizzata la schermata Attiva progetto host.
Fai clic su Salva e continua. Viene visualizzata la pagina Seleziona subnet.
In Modalità di condivisione, seleziona Singole subnet.
In Subnet da condividere, seleziona tier-1 e tier-2. Cancella tutto altre caselle di controllo.
Fai clic su Continua. Viene visualizzata la pagina Concedi autorizzazioni.
In Collega progetti di servizio, controlla il tuo primo progetto di servizio. e il secondo progetto di servizio. Deseleziona tutte le altre caselle di controllo in Collega i progetti di servizio.
In Accesso a Kubernetes Engine, seleziona Abilitato.
Fai clic su Salva. Viene visualizzata una nuova pagina.
In Autorizzazioni per singole subnet, seleziona livello 1.
Nel riquadro di destra, elimina tutti gli account di servizio appartenenti al tuo progetto di servizio. Elimina tutti gli account di servizio che contengono SERVICE_PROJECT_2_NUM.
Nel riquadro a destra, cerca i nomi degli account di servizio Kubernetes Engine e delle API di Google appartenenti al tuo primo progetto di servizio. Vuoi visualizzare entrambi i nomi degli account di servizio nell'elenco. Se uno di questi non è presente nell'elenco, inserisci il nome dell'account per i servizi in Aggiungi membri e fai clic su Aggiungi.
Nel riquadro centrale, in Autorizzazioni per singole subnet, seleziona tier-2 e cancellare tier-1.
Nel riquadro a destra, elimina gli account di servizio appartenenti al tuo primo progetto di servizio. Elimina tutti gli account di servizio che contengono SERVICE_PROJECT_1_NUM.
Nel riquadro a destra, cerca i nomi degli oggetti Kubernetes Engine e Google Account di servizio API che appartengono al secondo progetto di servizio. Tu vuoi vedere entrambi i nomi di questi account di servizio nell'elenco. Se uno di questi non è presente nell'elenco, inserisci il nome dell'account per i servizi in Aggiungi membri e fai clic su Aggiungi.

gcloud

Abilita il VPC condiviso nel progetto host. Il comando che utilizzi dipende dal ruolo amministrativo richiesto di cui disponi.

Se disponi del ruolo Amministratore VPC condiviso a livello di organizzazione:
```
gcloud compute shared-vpc enable HOST_PROJECT_ID
```
Se disponi del ruolo Amministratore VPC condiviso a livello di cartella:
```
gcloud beta compute shared-vpc enable HOST_PROJECT_ID
```

Collega il tuo primo progetto di servizio al progetto host:

gcloud compute shared-vpc associated-projects add SERVICE_PROJECT_1_ID \
    --host-project HOST_PROJECT_ID

Collega il secondo progetto di servizio al progetto host:

gcloud compute shared-vpc associated-projects add SERVICE_PROJECT_2_ID \
    --host-project HOST_PROJECT_ID

Recupera il criterio IAM per la subnet tier-1:

gcloud compute networks subnets get-iam-policy tier-1 \
   --project HOST_PROJECT_ID \
   --region COMPUTE_REGION

L'output contiene un campo etag. Prendi nota del valore etag.

Crea un file denominato tier-1-policy.yaml con i seguenti contenuti:

bindings:
- members:
  - serviceAccount:SERVICE_PROJECT_1_NUM@cloudservices.gserviceaccount.com
  - serviceAccount:service-SERVICE_PROJECT_1_NUM@container-engine-robot.iam.gserviceaccount.com
  role: roles/compute.networkUser
etag: ETAG_STRING

Sostituisci ETAG_STRING con il valore etag che di cui hai parlato in precedenza.

Imposta il criterio IAM per la sottorete tier-1:

gcloud compute networks subnets set-iam-policy tier-1 \
    tier-1-policy.yaml \
    --project HOST_PROJECT_ID \
    --region COMPUTE_REGION

Ottieni il criterio IAM per la subnet tier-2:

gcloud compute networks subnets get-iam-policy tier-2 \
    --project HOST_PROJECT_ID \
    --region COMPUTE_REGION

L'output contiene un campo etag. Prendi nota del valore etag.

Crea un file denominato tier-2-policy.yaml con i seguenti contenuti:

bindings:
- members:
  - serviceAccount:SERVICE_PROJECT_2_NUM@cloudservices.gserviceaccount.com
  - serviceAccount:service-SERVICE_PROJECT_2_NUM@container-engine-robot.iam.gserviceaccount.com
  role: roles/compute.networkUser
etag: ETAG_STRING

Sostituisci ETAG_STRING con il valore etag che hai annotato in precedenza.

Imposta il criterio IAM per la sottorete tier-2:

gcloud compute networks subnets set-iam-policy tier-2 \
    tier-2-policy.yaml \
    --project HOST_PROJECT_ID \
    --region COMPUTE_REGION

Gestione delle risorse del firewall

Se vuoi che un cluster GKE in un progetto di servizio crei per gestire le risorse firewall nel progetto host, All'account di servizio GKE deve essere concesso Autorizzazioni IAM utilizzando una delle seguenti strategie:

Concedi all'account di servizio GKE del progetto di servizio Compute Security Admin al progetto host.

Console

Nella console Google Cloud, vai alla pagina IAM.

Vai a IAM
Seleziona il progetto host.
Fai clic su Concedi l'accesso, poi inserisciservice-SERVICE_PROJECT_NUM@container-engine-robot.iam.gserviceaccount.com, l'entità dell'account di servizio GKE del progetto di servizio.
Seleziona il ruolo Compute Security Admin dall'elenco a discesa.
Fai clic su Salva.

gcloud

Concedi all'account di servizio GKE del progetto di servizio il ruolo Compute Security Admin all'interno del progetto host:

gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
    --member=serviceAccount:service-SERVICE_PROJECT_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role=roles/compute.securityAdmin

Sostituisci quanto segue:

HOST_PROJECT_ID: il VPC condiviso ID progetto host
SERVICE_PROJECT_NUM: l'ID del servizio contenente l'account di servizio GKE

Per un approccio più dettagliato, creare un ruolo IAM personalizzato che include solo le seguenti autorizzazioni: compute.networks.updatePolicy, compute.firewalls.list, compute.firewalls.get, compute.firewalls.create compute.firewalls.update e compute.firewalls.delete. Concedi il servizio l'account di servizio GKE del progetto quel ruolo personalizzato per il progetto host.

Console

Crea un ruolo personalizzato all'interno del progetto host contenente le autorizzazioni IAM menzionate in precedenza:

Nella console Google Cloud, vai alla pagina Ruoli.

Vai alla pagina Ruoli
Utilizza l'elenco a discesa nella parte superiore della pagina per selezionare il progetto ospitante.
Fai clic su Crea ruolo.
Inserisci un Titolo, una Descrizione, un ID e una Fase di lancio del ruolo per il ruolo. Non è possibile modificare il nome del ruolo dopo la creazione del ruolo stesso.
Fai clic su Aggiungi autorizzazioni.
Filtra per compute.networks e seleziona il IAM autorizzazioni menzionate in precedenza.
Dopo aver selezionato tutte le autorizzazioni richieste, fai clic su Aggiungi.
Fai clic su Crea.

Concedi all'account di servizio GKE del progetto di servizio il ruolo personalizzato appena creato all'interno del progetto host:

Nella console Google Cloud, vai alla pagina IAM.

Vai a IAM
Seleziona il progetto host.
Fai clic su Concedi accesso, quindi inserisci il principale dell'account di servizio GKE del progetto di servizio, service-SERVICE_PROJECT_NUM@container-engine-robot.iam.gserviceaccount.com.
Filtra per Titolo del ruolo personalizzato appena creato e selezionalo.
Fai clic su Salva.

gcloud

Crea un ruolo personalizzato all'interno del progetto host contenente Autorizzazioni IAM menzionate in precedenza:

gcloud iam roles create ROLE_ID \
    --title="ROLE_TITLE" \
    --description="ROLE_DESCRIPTION" \
    --stage=LAUNCH_STAGE \
    --permissions=compute.networks.updatePolicy,compute.firewalls.list,compute.firewalls.get,compute.firewalls.create,compute.firewalls.update,compute.firewalls.delete \
    --project=HOST_PROJECT_ID

Concedi all'account di servizio GKE del progetto di servizio il nuovo ruolo personalizzato creato all'interno del progetto host:
```
gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
    --member=serviceAccount:service-SERVICE_PROJECT_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role=projects/HOST_PROJECT_ID/roles/ROLE_ID
```
Sostituisci quanto segue:
- ROLE_ID: il nome del ruolo, ad esempio gkeFirewallAdmin
- ROLE_TITLE: un titolo intuitivo per il ruolo, ad esempio come GKE Firewall Admin
- ROLE_DESCRIPTION: una breve descrizione del ruolo, ad esempio GKE service account FW permissions
- LAUNCH_STAGE: la fase di lancio del ruolo nel suo ciclo di vita, ad esempio ALPHA, BETA o GA
- HOST_PROJECT_ID: l'ID progetto host della VPC condivisa
- SERVICE_PROJECT_NUM: l'ID del progetto di servizio contenente l'account di servizio GKE

Se disponi di cluster in più progetti di servizio, devi scegliere uno dei e ripeterlo per il servizio GKE di ogni progetto di servizio .

Riepilogo dei ruoli concessi alle subnet

Ecco un riepilogo dei ruoli concessi alle subnet:

Service account	Ruolo	Subnet
service-`SERVICE_PROJECT_1_NUM`@container-engine-robot.iam.gserviceaccount.com	Compute Network User	fascia-1
`SERVICE_PROJECT_1_NUM`@cloudservices.gserviceaccount.com	Compute Network User	tier-1
service-`SERVICE_PROJECT_2_NUM`@container-engine-robot.iam.gserviceaccount.com	Compute Network User	tier-2
`SERVICE_PROJECT_2_NUM`@cloudservices.gserviceaccount.com	Compute Network User	tier-2

Accesso a Kubernetes Engine

Quando colleghi un progetto di servizio, l'attivazione dell'accesso a Kubernetes Engine concede all'account di servizio GKE del progetto di servizio le autorizzazioni per eseguire operazioni di gestione della rete nel progetto host.

GKE assegna automaticamente il seguente ruolo nel progetto host quando viene attivato l'accesso a Kubernetes Engine:

Membro	Ruolo	Risorsa
service-`SERVICE_PROJECT_NUM`@container-engine-robot.iam.gserviceaccount.com	Utente agente di servizi host	Account di servizio GKE nel progetto host

Tuttavia, per accedere alla rete host, devi aggiungere manualmente l'autorizzazione IAM Compute Network User all'account di servizio GKE del progetto di servizio.

Membro	Ruolo	Risorsa
service-`SERVICE_PROJECT_NUM`@container-engine-robot.iam.gserviceaccount.com	Compute Network User	Subnet specifica o intero progetto host

Se un progetto di servizio è stato collegato senza abilitare l'accesso a Kubernetes Engine, supponendo che l'API Kubernetes Engine sia già stata abilitata sia nel progetto di servizio sia nel progetto host, puoi assegnare manualmente le autorizzazioni all'account di servizio GKE del progetto di servizio aggiungendo le seguenti associazioni di ruoli IAM nel progetto host:

Membro	Ruolo	Risorsa
service-`SERVICE_PROJECT_NUM`@container-engine-robot.iam.gserviceaccount.com	Compute Network User	Subnet specifica o intero progetto host
service-`SERVICE_PROJECT_NUM`@container-engine-robot.iam.gserviceaccount.com	Utente agente di servizio host	Account di servizio GKE nel progetto host

Concessione del ruolo Utente Agente di servizio Host

L'account di servizio GKE di ogni progetto di servizio deve avere un associazione per l'utente agente di servizio host del progetto host. L'account di servizio GKE prende modulo seguente:

service-SERVICE_PROJECT_NUM@container-engine-robot.iam.gserviceaccount.com

dove SERVICE_PROJECT_NUM è il numero del progetto del tuo progetto di servizio.

Questa associazione consente all'account di servizio GKE del progetto di servizio di eseguire operazioni di gestione della rete nel progetto host, come se fosse l'account di servizio GKE del progetto host. Questo ruolo può essere concesso solo all'account di servizio GKE di un progetto di servizio.

Console

Se utilizzi la console Google Cloud, non devi concedere esplicitamente il ruolo Utente agente di servizio host. L'operazione è stata eseguita automaticamente quando hai utilizzato la console Google Cloud per collegare i progetti di servizio del progetto host.

gcloud

Per il tuo primo progetto, concedi il ruolo Utente agente di servizio host al l'account di servizio GKE del progetto. Questo ruolo viene concesso nel tuo progetto host:

gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
    --member serviceAccount:service-SERVICE_PROJECT_1_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role roles/container.hostServiceAgentUser

Per il secondo progetto, concedi il ruolo Utente agente di servizio host all'account di servizio GKE del progetto. Questo ruolo viene concesso nel tuo progetto host:

gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
    --member serviceAccount:service-SERVICE_PROJECT_2_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role roles/container.hostServiceAgentUser

Verificare le subnet e gli intervalli di indirizzi IP secondari utilizzabili

Quando crei un cluster, devi specificare una subnet e gli intervalli di indirizzi IP secondari da utilizzare per i pod e i servizi del cluster. Esistono diversi motivi per cui un intervallo di indirizzi IP potrebbe non essere disponibile. Che tu stia creando il cluster con la console Google Cloud gcloud CLI, devi specificare intervalli di indirizzi IP utilizzabili.

Un intervallo di indirizzi IP è utilizzabile per i servizi del nuovo cluster se non è già in uso. L'intervallo di indirizzi IP specificato per i pod del nuovo cluster può essere un intervallo non utilizzato o un intervallo condiviso con i pod degli altri cluster. che vengono creati e gestiti GKE non può essere utilizzato dal tuo cluster.

Puoi elencare le subnet utilizzabili di un progetto e gli intervalli di indirizzi IP secondari utilizzando con gcloud CLI.

gcloud

gcloud container subnets list-usable \
    --project SERVICE_PROJECT_ID \
    --network-project HOST_PROJECT_ID

Sostituisci SERVICE_PROJECT_ID con l'ID progetto di del progetto di servizio.

Se ometti l'opzione --project o --network-project, il valore Il comando gcloud CLI utilizza il progetto predefinito configurazione attiva. Poiché il progetto di destinazione e il progetto di rete sono distinti, devi specificare uno o entrambi i valori --project e --network-project.

L'output è simile al seguente:

PROJECT: xpn-host
REGION: REGION_NAME
NETWORK: shared-net
SUBNET: tier-2
RANGE: 172.16.4.0/22

SECONDARY_RANGE_NAME: tier-2-services
IP_CIDR_RANGE: 172.20.0.0/14
STATUS: usable for pods or services

SECONDARY_RANGE_NAME: tier-2-pods
IP_CIDR_RANGE: 172.16.16.0/20
STATUS: usable for pods or services

PROJECT: xpn-host
REGION: REGION_NAME
NETWORK: shared-net
SUBNET: tier-1
RANGE: 10.0.4.0/22

SECONDARY_RANGE_NAME: tier-1-services
IP_CIDR_RANGE: 10.0.32.0/20
STATUS: usable for pods or services

SECONDARY_RANGE_NAME: tier-1-pods
IP_CIDR_RANGE: 10.4.0.0/14
STATUS: usable for pods or services

Il comando list-usable restituisce un elenco vuoto nelle seguenti situazioni:

Quando l'account di servizio Kubernetes Engine del progetto di servizio non ha il ruolo Host Service Agent User per il progetto host.
Quando l'account di servizio Kubernetes Engine nel progetto host non esiste (ad esempio, se lo hai eliminato per errore).
Se l'API Kubernetes Engine non è abilitata nel progetto host, implica che l'account di servizio Kubernetes Engine nel progetto host mancante.

Per ulteriori informazioni, consulta la sezione relativa alla risoluzione dei problemi.

Note sugli intervalli secondari

Puoi creare 30 intervalli secondari in una determinata subnet. Per ogni cluster, e richiedono due intervalli secondari: uno per i pod e uno per i servizi.

Creazione di un cluster nel primo progetto di servizio

Per creare un cluster nel tuo primo progetto di servizio, segui questi passaggi utilizzando gcloud CLI o la console Google Cloud.

Console

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Nel selettore di progetti, seleziona il tuo primo progetto di servizio.
Fai clic su Crea.
Nella sezione Autopilot o Standard, fai clic su Configura.
In Nome, inserisci tier-1-cluster.
Nell'elenco a discesa Regione, seleziona la stessa regione utilizzata. per le subnet.
Nel riquadro di navigazione, fai clic su Networking.
Seleziona Reti condivise con me (dal progetto host).
In Rete, seleziona shared-net.
In Subnet nodo, seleziona tier-1.
Per Intervallo CIDR secondario del pod, seleziona tier-1-pods.
In Intervallo CIDR secondario dei servizi, seleziona tier-1-services.
Fai clic su Crea.
Al termine della creazione, nell'elenco dei cluster, fai clic su tier-1-cluster.
Nella pagina Dettagli cluster, fai clic sulla scheda Nodi.
In Pool di nodi, fai clic sul nome del pool di nodi da ispezionare.
In Gruppi di istanze, fai clic sul nome del gruppo di istanze che vuoi da esaminare. Ad esempio, gke-tier-1-cluster-default-pool-5c5add1f-grp.
Nell'elenco delle istanze, verifica che gli indirizzi IP interni dei tuoi node rientrino nell'intervallo principale della subnet di primo livello: 10.0.4.0/22.

gcloud

Crea un cluster denominato tier-1-cluster nel tuo primo progetto di servizio:

gcloud container clusters create-auto tier-1-cluster \
    --project=SERVICE_PROJECT_1_ID \
    --location=COMPUTE_REGION \
    --network=projects/HOST_PROJECT_ID/global/networks/shared-net \
    --subnetwork=projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/tier-1 \
    --cluster-secondary-range-name=tier-1-pods \
    --services-secondary-range-name=tier-1-services

Al termine della creazione, verifica che i nodi del cluster si trovino nell'intervallo principale della subnet di primo livello: 10.0.4.0/22.

gcloud compute instances list --project SERVICE_PROJECT_1_ID

L'output mostra gli indirizzi IP interni dei nodi:

NAME                    ZONE           ... INTERNAL_IP
gke-tier-1-cluster-...  ZONE_NAME      ... 10.0.4.2
gke-tier-1-cluster-...  ZONE_NAME      ... 10.0.4.3
gke-tier-1-cluster-...  ZONE_NAME      ... 10.0.4.4

Creazione di un cluster nel secondo progetto di servizio

Per creare un cluster nel secondo progetto di servizio, esegui questi passaggi utilizzando gcloud CLI o la console Google Cloud.

Console

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Nel selettore del progetto, seleziona il tuo secondo progetto di servizio.
Fai clic su Crea.
Nella sezione Standard o Autopilot, fai clic su Configura.
In Nome, inserisci tier-2-cluster.
Nell'elenco a discesa Regione, seleziona la stessa regione utilizzata. per le subnet.
Nel riquadro di navigazione, fai clic su Networking.
In corrispondenza di Rete, seleziona shared-net.
In Subnet nodo, seleziona tier-2.
Per Intervallo CIDR secondario del pod, seleziona tier-2-pods.
In Intervallo CIDR secondario dei servizi, seleziona servizi-livello-2.
Fai clic su Crea.
Al termine della creazione, nell'elenco dei cluster, fai clic su tier-2-cluster.
Nella pagina Dettagli cluster, fai clic sulla scheda Nodi.
In Pool di nodi, fai clic sul nome del pool di nodi da ispezionare.
In Gruppi di istanze, fai clic sul nome del gruppo di istanze da esaminare. Ad esempio, gke-tier-2-cluster-default-pool-5c5add1f-grp.
Nell'elenco delle istanze, verifica che gli indirizzi IP interni nodi si trovano nell'intervallo principale della subnet di livello 2: 172.16.4.0/22.

gcloud

Crea un cluster denominato tier-2-cluster nel tuo secondo progetto di servizio:

gcloud container clusters create-auto tier-2-cluster \
    --project=SERVICE_PROJECT_2_ID \
    --location=COMPUTE_REGION \
    --network=projects/HOST_PROJECT_ID/global/networks/shared-net \
    --subnetwork=projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/tier-2 \
    --cluster-secondary-range-name=tier-2-pods \
    --services-secondary-range-name=tier-2-services

Al termine della creazione, verifica che i nodi del cluster siano nell'intervallo principale della subnet di livello 2: 172.16.4.0/22.

gcloud compute instances list --project SERVICE_PROJECT_2_ID

L'output mostra gli indirizzi IP interni dei nodi:

NAME                    ZONE           ... INTERNAL_IP
gke-tier-2-cluster-...  ZONE_NAME      ... 172.16.4.2
gke-tier-2-cluster-...  ZONE_NAME      ... 172.16.4.3
gke-tier-2-cluster-...  ZONE_NAME      ... 172.16.4.4

Creazione di regole firewall

Per consentire il traffico nella rete e tra i cluster all'interno della rete, devi creare dei firewall. Le seguenti sezioni illustrano come creare e aggiorna le regole firewall:

Creazione di una regola firewall per abilitare la connessione SSH a un nodo: Viene illustrato come creare una regola firewall che consenta il traffico dall'esterno di dei cluster tramite SSH.
Aggiornamento della regola firewall per il ping tra nodi: Viene illustrato come aggiornare la regola del firewall per consentire il traffico ICMP tra tra i cluster.

SSH e ICMP vengono utilizzati come esempi. Devi creare regole firewall che abilitano i requisiti di rete specifici della tua applicazione.

Nota: gli amministratori del VPC condiviso sono responsabili della creazione delle regole firewall nel Rete VPC condiviso

Creazione di una regola firewall per abilitare la connessione SSH a un nodo

Nel progetto host, crea una regola firewall per la rete shared-net. Consenti l'ingresso del traffico sulla porta TCP 22, che ti consente di connetterti ai nodi del cluster utilizzando SSH.

Console

Vai alla pagina Firewall nella console Google Cloud.

Vai a Firewall
Nel selettore del progetto, seleziona il progetto host.
Dal menu Rete VPC, fai clic su Crea regola firewall.
In Nome, inserisci my-shared-net-rule.
In corrispondenza di Rete, seleziona shared-net.
In Direzione del traffico, seleziona In entrata.
In Azione in caso di corrispondenza, seleziona Consenti.
In Destinazioni, seleziona Tutte le istanze nella rete.
In Filtro di origine, seleziona Intervalli IP.
In Intervalli IP di origine, inserisci 0.0.0.0/0.
In Protocolli e porte, seleziona Protocolli e porte specificati. Nella casella, inserisci tcp:22.
Fai clic su Crea.

gcloud

Crea una regola firewall per la tua rete condivisa:

gcloud compute firewall-rules create my-shared-net-rule \
    --project HOST_PROJECT_ID \
    --network shared-net \
    --direction INGRESS \
    --allow tcp:22

Connessione a un nodo tramite SSH

Dopo aver creato il firewall che consente il traffico in entrata sulla porta TCP 22, connettersi al nodo tramite SSH.

Console

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Nel selettore del progetto, seleziona il tuo primo progetto di servizio.
Fai clic su tier-1-cluster.
Nella pagina Dettagli cluster, fai clic sulla scheda Nodi.
In Pool di nodi, fai clic sul nome del pool di nodi.
In Gruppi di istanze, fai clic sul nome del gruppo di istanze. Ad esempio, gke-tier-1-cluster-default-pool-faf87d48-grp.
Nell'elenco delle istanze, prendi nota degli indirizzi IP interni dei node. Questi indirizzi sono nell'intervallo 10.0.4.0/22.
Per uno dei tuoi nodi, fai clic su SSH. L'operazione riesce perché SSH utilizza la porta TCP 22, consentita dalla regola del firewall.

gcloud

Elenca i nodi nel tuo primo progetto di servizio:

gcloud compute instances list --project SERVICE_PROJECT_1_ID

L'output include i nomi dei nodi del cluster:

NAME                                           ...
gke-tier-1-cluster-default-pool-faf87d48-3mf8  ...
gke-tier-1-cluster-default-pool-faf87d48-q17k  ...
gke-tier-1-cluster-default-pool-faf87d48-x9rk  ...

Connettiti a uno dei tuoi nodi mediante SSH:

gcloud compute ssh NODE_NAME \
    --project SERVICE_PROJECT_1_ID \
    --zone COMPUTE_ZONE

Sostituisci quanto segue:

NODE_NAME: il nome di uno dei tuoi nodi.
COMPUTE_ZONE: il nome di una zona Compute Engine all'interno della regione.

Aggiornamento della regola firewall per il ping tra nodi

Nella finestra della riga di comando SSH, avvia CoreOS Toolbox:
```
/usr/bin/toolbox
```
Nella shell degli strumenti, esegui il ping di uno degli altri nodi nello stesso cluster. Per esempio:
```
ping 10.0.4.4
```
Il comando ping ha esito positivo perché il tuo nodo e l'altro nodo rientrano entrambi nell'intervallo 10.0.4.0/22.
Ora prova a eseguire un ping su uno dei nodi del cluster nell'altro progetto di servizio. Ad esempio:
```
ping 172.16.4.3
```
Questa volta il comando ping non riesce perché la regola firewall non consentire il traffico ICMP (Internet Control Message Protocol).

Da un normale prompt dei comandi, non dalla shell della cassetta degli attrezzi, aggiorna la regola del firewall per consentire ICMP:

gcloud compute firewall-rules update my-shared-net-rule \
    --project HOST_PROJECT_ID \
    --allow tcp:22,icmp

Nella shell della cassetta degli attrezzi, esegui di nuovo il ping del nodo. Ad esempio:
```
ping 172.16.4.3
```
Questa volta il comando ping ha esito positivo.

Creazione di regole firewall aggiuntive

Puoi creare regole firewall aggiuntive per consentire la comunicazione tra nodi, di pod e servizi nei tuoi cluster.

Ad esempio, la seguente regola consente al traffico di entrare da qualsiasi nodo, pod Servizio in tier-1-cluster su qualsiasi porta TCP o UDP:

gcloud compute firewall-rules create my-shared-net-rule-2 \
    --project HOST_PROJECT_ID \
    --network shared-net \
    --allow tcp,udp \
    --direction INGRESS \
    --source-ranges 10.0.4.0/22,10.4.0.0/14,10.0.32.0/20

La seguente regola consente l'ingresso del traffico da qualsiasi nodo, pod o servizio in tier-2-cluster su qualsiasi porta TCP o UDP:

gcloud compute firewall-rules create my-shared-net-rule-3 \
    --project HOST_PROJECT_ID \
    --network shared-net \
    --allow tcp,udp \
    --direction INGRESS \
    --source-ranges 172.16.4.0/22,172.20.0.0/14,172.16.16.0/20

Kubernetes cercherà anche di creare e gestire le risorse firewall quando necessario, per la creazione di un servizio di bilanciamento del carico. Se Kubernetes non riesce a modificare le regole del firewall a causa di un problema di autorizzazione, verrà generato un evento Kubernetes per guidarti su come apportare le modifiche.

Se vuoi concedere a Kubernetes l'autorizzazione a modificare le regole del firewall, consulta Gestire le risorse del firewall.

Per i bilanciatori di carico in entrata, se Kubernetes non può modificare le regole del firewall a causa di un'autorizzazione insufficiente, viene emesso un evento firewallXPNError ogni diversi minuti. In GLBC 1.4 e versioni successive, puoi disattivare l'evento firewallXPNError aggiungendo l'annotazione networking.gke.io/suppress-firewall-xpn-error: "true" alla risorsa di ingresso. Puoi sempre rimuovere questa annotazione per riattivare l'audio.

Creazione di un cluster privato in un VPC condiviso

Puoi utilizzare la rete VPC condivisa con cluster privati.

Ciò richiede la concessione delle seguenti autorizzazioni sul progetto host, per all'account utente o all'account di servizio, utilizzato per creare il cluster:

compute.networks.get
compute.networks.updatePeering

Devi anche assicurarti che l'intervallo di indirizzi IP del piano di controllo non si sovrapponga ad altri intervalli riservati nella rete condivisa.

Per i cluster privati creati prima del 15 gennaio 2020, il numero massimo di cluster GKE privati che puoi avere per rete VPC è limitato al numero di connessioni di peering da una singola rete VPC. Nuovi cluster privati riutilizzare le connessioni di peering di rete VPC il che rimuove questa limitazione. Per abilitare il riutilizzo del peering di rete VPC nei cluster privati precedenti, puoi eliminare un cluster e ricrearlo. L'upgrade di un cluster non comporta il riutilizzo di un cluster esistente Connessione in peering di rete VPC.

In questa sezione creerai un cluster nativo di VPC denominato private-cluster-vpc in una rete VPC condivisa predefinita.

Console

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Fai clic su Crea.
Nella sezione Autopilot o Standard, fai clic su Configura.
In Nome, inserisci private-cluster-vpc.
Nel riquadro di navigazione, fai clic su Networking.
Seleziona Cluster privato.
(Facoltativo per Autopilot): imposta Intervallo IP del piano di controllo su 172.16.0.16/28.
Nell'elenco a discesa Rete, seleziona la rete VPC creata in precedenza.
Nell'elenco a discesa Subnet nodo, seleziona la subnet condivisa creati in precedenza.
Configura il cluster in base alle tue esigenze.
Fai clic su Crea.

gcloud

Esegui questo comando per creare un cluster denominato private-cluster-vpc in un VPC condiviso predefinito:

gcloud container clusters create-auto private-cluster-vpc \
    --project=PROJECT_ID \
    --location=COMPUTE_REGION \
    --network=projects/HOST_PROJECT/global/networks/shared-net \
    --subnetwork=SHARED_SUBNETWORK \
    --cluster-secondary-range-name=tier-1-pods \
    --services-secondary-range-name=tier-1-services \
    --enable-private-nodes \
    --master-ipv4-cidr=172.16.0.0/28

Prenotazione di indirizzi IP

Puoi prenotare indirizzi IP interni e esterni per i tuoi cluster VPC condivisi. Assicurati che gli indirizzi IP siano riservati nel progetto di servizio.

Per gli indirizzi IP interni, devi fornire la subnet in cui si trova l'indirizzo IP . Per prenotare un indirizzo IP tra progetti, utilizza l'URL completo della risorsa per identificare la subnet.

Puoi utilizzare il seguente comando in Google Cloud CLI per prenotare un indirizzo IP interno:

gcloud compute addresses create RESERVED_IP_NAME \
    --region=COMPUTE_REGION \
    --subnet=projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNETWORK_NAME \
    --addresses=IP_ADDRESS \
    --project=SERVICE_PROJECT_ID

Per chiamare questo comando, devi avere compute.subnetworks.use aggiunta di un'autorizzazione alla subnet. Puoi concedere all'utente che effettua l'accesso un ruolo compute.networkUser nella sottorete oppure concedere all'utente che effettua l'accesso un ruolo personalizzato con l'autorizzazione compute.subnetworks.use a livello di progetto.

Pulizia

Dopo aver completato gli esercizi in questa guida, svolgi le seguenti attività per rimuovere le risorse ed evitare addebiti indesiderati sul tuo account:

Eliminazione dei cluster

Elimina i due cluster che hai creato.

Console

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Nel selettore del progetto, seleziona il tuo primo progetto di servizio.
Seleziona tier-1-cluster e fai clic su Elimina.
Nel selettore del progetto, seleziona il tuo secondo progetto di servizio.
Seleziona tier-2-cluster e fai clic su Elimina.

gcloud

gcloud container clusters delete tier-1-cluster \
    --project SERVICE_PROJECT_1_ID \
    --zone COMPUTE_ZONE

gcloud container clusters delete tier-2-cluster \
    --project SERVICE_PROJECT_2_ID \
    --zone COMPUTE_ZONE

Disattivazione di un VPC condiviso

Disattiva la VPC condivisa nel progetto host.

Console

Vai alla pagina VPC condiviso nella console Google Cloud.

Vai a Rete VPC condivisa
Nel selettore del progetto, seleziona il progetto host.
Fai clic su Disabilita VPC condiviso.
Inserisci il HOST_PROJECT_ID nel campo e fai clic su Disattiva.

gcloud

gcloud compute shared-vpc associated-projects remove SERVICE_PROJECT_1_ID \
    --host-project HOST_PROJECT_ID

gcloud compute shared-vpc associated-projects remove SERVICE_PROJECT_2_ID \
    --host-project HOST_PROJECT_ID

gcloud compute shared-vpc disable HOST_PROJECT_ID

Eliminazione delle regole firewall in corso...

Rimuovi le regole firewall che hai creato.

Console

Vai alla pagina Firewall nella console Google Cloud.

Vai a Firewall
Nel selettore del progetto, seleziona il progetto host.
Nell'elenco delle regole, seleziona my-shared-net-rule, my-shared-net-rule-2 e my-shared-net-rule-3.
Fai clic su Elimina.

gcloud

Elimina le regole firewall:

gcloud compute firewall-rules delete \
    my-shared-net-rule \
    my-shared-net-rule-2 \
    my-shared-net-rule-3 \
    --project HOST_PROJECT_ID

Eliminazione della rete condivisa

Elimina la rete condivisa che hai creato.

Console

Vai alla pagina Reti VPC nella console Google Cloud.

Vai a Reti VPC
Nel selettore del progetto, seleziona il progetto host.
Nell'elenco delle reti, seleziona shared-net.
Fai clic su Elimina rete VPC.

gcloud

gcloud compute networks subnets delete tier-1 \
    --project HOST_PROJECT_ID \
    --region COMPUTE_REGION

gcloud compute networks subnets delete tier-2 \
    --project HOST_PROJECT_ID \
    --region COMPUTE_REGION

gcloud compute networks delete shared-net --project HOST_PROJECT_ID

Rimozione del ruolo utente Agente di servizio host

Rimuovi i ruoli Host Service Agent User dai due progetti di servizio.

Console

Vai alla pagina IAM nella console Google Cloud.

Vai a IAM
Nel selettore del progetto, seleziona il progetto host.
Nell'elenco dei membri, seleziona la riga che mostra service-SERVICE_PROJECT_1_NUM@container-engine-robot.iam.gserviceaccount.com è stato concesso il ruolo Utente agente di servizio host Kubernetes Engine.
Seleziona la riga che mostra service-SERVICE_PROJECT_2_NUM@container-engine-robot.iam.gserviceaccount.com dispone del ruolo Utente Agente di servizio host Kubernetes Engine.
Fai clic su Rimuovi accesso.

gcloud

Rimuovi il ruolo Utente agente di servizio host dall'account di servizio GKE del tuo primo progetto di servizio:

gcloud projects remove-iam-policy-binding HOST_PROJECT_ID \
    --member serviceAccount:service-SERVICE_PROJECT_1_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role roles/container.hostServiceAgentUser

Rimuovi il ruolo Utente agente di servizio host dall'account di servizio GKE del secondo progetto di servizio:

gcloud projects remove-iam-policy-binding HOST_PROJECT_ID \
    --member serviceAccount:service-SERVICE_PROJECT_2_NUM@container-engine-robot.iam.gserviceaccount.com \
    --role roles/container.hostServiceAgentUser

Risoluzione dei problemi

Le sezioni seguenti aiutano a risolvere i problemi comuni relativi al VPC condiviso cluster.

Errore: impossibile recuperare i metadati dal progetto di rete

Il seguente messaggio è un errore comune quando si utilizzano i cluster VPC condivisi:

Failed to get metadata from network project. GCE_PERMISSION_DENIED: Google
Compute Engine: Required 'compute.projects.get' permission for
'projects/HOST_PROJECT_ID

Questo errore può verificarsi per i seguenti motivi:

L'API Kubernetes Engine non è stata abilitata nel progetto host.
L'account di servizio GKE del progetto host non esiste. Ad esempio, potrebbe essere stata eliminata.
L'account di servizio GKE del progetto host non dispone del ruolo Agente di servizio Kubernetes Engine (container.serviceAgent) nel progetto host. L'associazione potrebbe essere stata rimossa per errore.
L'account di servizio GKE del progetto di servizio non dispone del ruolo Agente di servizio host nel progetto host.

Per risolvere il problema, determina se la risorsa GKE del progetto host un account di servizio esistente.

Se l'account di servizio non esiste:

Se l'API Kubernetes Engine non è abilitata nel progetto host, abilitala. In questo modo viene creato l'account di servizio GKE del progetto host e viene concesso all'account di servizio GKE del progetto host il ruolo Agente di servizio Kubernetes Engine (container.serviceAgent) nel progetto host.
Se l'API Kubernetes Engine è abilitata nel progetto host, significa che l'account di servizio GKE del progetto host è stato eliminato o che non ha il ruolo Agente di servizio Kubernetes Engine (container.serviceAgent) nel progetto host. Per ripristinare l'account di servizio GKE o la associazione dei ruoli, devi disattivare e riattivare l'API Kubernetes Engine. Per maggiori informazioni, consulta Errore 400/403: autorizzazioni di modifica mancanti nell'account.

Nota: la disattivazione e la successiva riattivazione dell'API Kubernetes Engine nel progetto host non influisce sul funzionamento dei cluster esistenti nei progetti di servizio. Tuttavia, non puoi creare nuovi cluster che utilizzano una rete VPC condivisa in un progetto di servizio o nel progetto host, mentre l'API Kubernetes Engine è disattivata.

Problema: connettività

Se riscontri problemi di connettività tra le VM di Compute Engine che si trovano nella stessa rete Virtual Private Cloud (VPC) sulle reti VPC connesse con il peering di rete VPC, consulta Risoluzione dei problemi di connettività tra istanze di macchine virtuali (VM) con IP interni nel documentazione di Virtual Private Cloud (VPC).

Problema: perdita di pacchetti

Se riscontri problemi di perdita di pacchetti durante l'invio di traffico da un cluster a un indirizzo IP esterno utilizzando Cloud NAT, cluster nativi VPC o agente di mascheramento IP, consulta Risolvere i problemi di perdita di pacchetti Cloud NAT da un cluster.