Il prodotto descritto in questa documentazione, Anthos Clusters on AWS (generazione precedente), è ora in modalità di manutenzione. Tutte le nuove installazioni devono utilizzare l'attuale prodotto di generazione, Cluster Anthos on AWS.

Questa pagina è stata tradotta dall'API Cloud Translation.

Integrazione con l'infrastruttura esistente

In questo argomento, configuri un Virtual Private Cloud (VPC) AWS esistente con subnet pubbliche e private ed esegui anthos-gke per completare l'installazione di un servizio di gestione.

Prima di iniziare

Per completare i seguenti passaggi, hai bisogno di:

Autorizzazioni AWS IAM come descritto in Requisiti.
Un VPC AWS esistente con:
- Almeno una subnet pubblica.
- Almeno una subnet privata.
- Un gateway internet con una route alla subnet pubblica.
- Un gateway NAT con una route alla subnet privata.
- Nomi host DNS attivati.
- Nessun valore personalizzato di domain-name nei set di opzioni DHCP. Per ulteriori informazioni, consulta la sezione Risoluzione dei problemi. GKE su AWS non supporta valori diversi dai nomi di dominio EC2 predefiniti.
Per ulteriori informazioni sulla configurazione del VPC di AWS, consulta VPC con subnet pubbliche e private.
Gli ID delle subnet pubbliche e private del VPC esistente. Ad esempio, subnet-1234567890abcdefg.
Per le versioni del cluster 1.20 o precedenti, un gruppo di sicurezza AWS che consente l'accesso SSH (porta 22) in entrata dai gruppi di sicurezza o dagli intervalli IP in cui gestirai l'installazione di GKE su AWS.
Per le versioni del cluster 1.21 o successive, un gruppo di sicurezza AWS che consente le connessioni in uscita di Konnectivity (porta 8132) dagli intervalli IP VPC che ospitano i node pool GKE su AWS.

Creazione dell'area di lavoro

Crea un file denominato anthos-gke.yaml in un editor di testo. Incolla i seguenti contenuti nel file.
```
 apiVersion: multicloud.cluster.gke.io/v1
 kind: AWSManagementService
 metadata:
   name: management
 spec:
   version: aws-1.14.1-gke.0
   region: AWS_REGION
   authentication:
     awsIAM:
       adminIdentityARNs:
       - ADMIN_AWS_IAM_ARN
   kmsKeyARN: KMS_KEY_ARN
   databaseEncryption:
     kmsKeyARN: DATABASE_KMS_KEY_ARN
   securityGroupIDs:
   - SECURITY_GROUP_IDS
   googleCloud:
     projectID: GCP_PROJECT_ID
     serviceAccountKeys:
       managementService: MANAGEMENT_KEY_PATH
       connectAgent: HUB_KEY_PATH
       node: NODE_KEY_PATH
   existingVPC:
     subnetID: VPC_SUBNET_ID
     allowedSSHSecurityGroupIDs:
     - SSH_SECURITY_GROUP
   # Optional fields
   rootVolume:
     sizeGiB: ROOT_VOLUME_SIZE
     volumeType: ROOT_VOLUME_TYPE
     iops: ROOT_VOLUME_IOPS
     kmsKeyARN: ROOT_VOLUME_KEY
   bastionHost:
     subnetID: BASTION_HOST_SUBNET_ID
     allowedSSHCIDRBlocks:
     - SSH_CIDR_BLOCK
     rootVolume: # Optional
       kmsKeyARN: BASTION_VOLUME_KEY
   proxy: PROXY_JSON_FILE
```
Sostituisci i seguenti valori:
- AWS_REGION con la regione AWS in cui eseguire il cluster.
- ADMIN_AWS_IAM_ARN con il nome della risorsa Amazon della chiave AWS IAM dell'amministratore.
- KMS_KEY_ARN con il nome risorsa Amazon della chiave AWS KMS che protegge i dati del servizio di gestione quando viene creato.
- DATABASE_KMS_KEY_ARN con l'Amazon Resource Name della chiave AWS KMS che protegge i tuoi database etcd.
- SECURITY_GROUP_IDS con ID gruppo di sicurezza aggiuntivi consentiti accedi alle VM del servizio di gestione.
- GCP_PROJECT_ID con il progetto Google Cloud che ospita l'ambiente GKE su AWS.
- MANAGEMENT_KEY_PATH con la posizione della tua Google Cloud gestione chiave dell'account di servizio.
- HUB_KEY_PATH con la posizione della tua Google Cloud Connessione chiave del service account.
- NODE_KEY_PATH con la posizione della chiave dell'account di servizio del nodo GKE su AWS.
- VPC_SUBNET_ID con l'ID subnet in cui viene eseguito il servizio di gestione.
- SSH_SECURITY_GROUP con l'elenco degli ID dei gruppi di sicurezza a cui è consentito l'accesso SSH all'interno delle istanze del servizio di gestione.
(Facoltativo) Se vuoi criptare i volumi del servizio di gestione, sostituisci i seguenti valori:
- ROOT_VOLUME_SIZE con le dimensioni del volume in gigabyte per il servizio di gestione. Ad esempio, 10.
- ROOT_VOLUME_TYPE con il tipo di volume EBS. Ad esempio: gp3.
- ROOT_VOLUME_IOPS con il numero di operazioni di I/O sottoposte a provisioning al secondo (IOPS) per il volume. Valido solo quando volumeType è GP3. Per maggiori informazioni, consulta Volumi SSD per uso generico (gp3).
- ROOT_VOLUME_KEY con l'Amazon Resource Name della chiave AWS KMS che cripta i volumi root dell'istanza del servizio di gestione. Per saperne di più, vedi Utilizzo di una CMK gestita dal cliente per criptare i volumi.
(Facoltativo) Se vuoi creare un bastion host per accedere al tuo ambiente GKE su AWS con un tunnel SSH, sostituisci i seguenti valori:
- BASTION_HOST_SUBNET_ID con l'ID subnet in cui viene eseguito l'host bastion. Assicurati che VPC_SUBNET_ID consenta le connessioni in entrata da BASTION_HOST_SUBNET_ID.
- SSH_CIDR_BLOCK con il blocco CIDR da cui l'host bastion consente la connessione SSH in entrata. Ad esempio 203.0.113.0/24. Se vuoi consentire SSH da qualsiasi indirizzo IP, utilizza 0.0.0.0/0.
- BASTION_VOLUME_KEY con l'Amazon Resource Name della chiave AWS KMS che protegge il volume root del bastion host.
(Facoltativo) Se vuoi il traffico diretto tramite un proxy HTTP, sostituisci il seguente valore:
- PROXY_JSON_FILE con il percorso relativo del file di configurazione del proxy. Se non utilizzi un proxy, rimuovi questa riga.
Esegui anthos-gke aws management init per creare i file di configurazione:
```
anthos-gke aws management init
```
Esegui anthos-gke aws management apply per creare il cluster.
```
anthos-gke aws management apply
```
Il completamento del comando anthos-gke aws management apply potrebbe richiedere fino a 10 minuti. Al termine dell'operazione anthos-gke, il servizio di gestione viene eseguito su AWS.

Tagga le subnet con il nome del cluster

Se utilizzi subnet AWS esistenti con GKE su AWS e vuoi creare bilanciatori del carico, devi taggare il VPC e le subnet con il nome del tuo servizio di gestione. Se hai creato il VPC con anthos-gke o hai già taggato le subnet, salta questo passaggio.

Per taggare le subnet, segui questi passaggi:

Passa alla directory con la configurazione di GKE su AWS. Hai creato questa directory durante l'installazione del servizio di gestione.
```
cd anthos-aws
```
Esporta l'ID cluster come variabile di ambiente $CLUSTER-ID. Scegli la tua versione di Terraform, poi esegui i seguenti comandi:
Terraform 0.12, 0.13
```
export CLUSTER_ID=$(terraform output cluster_id)
```
Terraform 0.14.3+
```
export CLUSTER_ID=$(terraform output -raw cluster_id)
```
Esporta l'ID VPC AWS come variabile di ambiente $VPC_ID. Scegli la tua versione di Terraform, poi esegui i seguenti comandi:
Terraform 0.12, 0.13
```
export VPC_ID=$(terraform output vpc_id)
```
Terraform 0.14.3+
```
export VPC_ID=$(terraform output -raw vpc_id)
```
Recupera gli ID subnet privati con lo strumento CLI aws.
```
  aws ec2 describe-subnets \
      --filters "Name=vpc-id,Values=$VPC_ID" "Name=tag:Name,Values=*private*" \
      --query "Subnets[*].SubnetId" \
      --output text
```
Nota: questo comando presuppone che le subnet contengano private nel nome. Se le tue subnet non includono questo testo, modifica i parametri del flag --filters. Per ulteriori informazioni, consulta la sezione Utilizzo dei filtri.
Tagga le tue subnet con l'ID cluster. Esegui questo comando per ogni subnet.
```
  aws ec2 create-tags \
      --resources SUBNET_IDS \
      --tags Key=gke:multicloud:cluster-id,Value=$CLUSTER_ID
```
Sostituisci SUBNET_IDS con l'elenco degli ID subnet, separati da spazi. Ad esempio, subnet-012345678abcdef subnet-abcdef123456789 subnet-123456789abcdef.

Connessione al servizio di gestione

In questa sezione, stabilisci una connessione al servizio di gestione. Puoi indirizzare i comandi tramite un bastion host. Se hai una connessione diretta al tuo VPC AWS, vai a Genera credenziali e connettiti.

Connessione a un bastion host

Se utilizzi un bastion host per configurare il tunnel SSH, prima configura l'host in anthos-gke.yaml. Successivamente, crea uno script per aprire il tunnel seguendo questi passaggi:

Utilizza terraform per generare uno script che apre un tunnel SSH all'host bastion.
```
terraform output bastion_tunnel > bastion-tunnel.sh
chmod 755 bastion-tunnel.sh
```
Terraform crea lo script bastion-tunnel.sh che utilizza la chiave SSH dell'host bastion (~/.ssh/anthos-gke).
Per aprire il tunnel, esegui lo script bastion-tunnel.sh. Il tunnel inoltra da localhost:8118 al bastion host.

Per aprire un tunnel all'bastion host, esegui questo comando:
```
./bastion-tunnel.sh -N
```
I messaggi del tunnel SSH vengono visualizzati in questa finestra. Quando sei pronto a chiudere la connessione, interrompi la procedura utilizzando Ctrl+C o chiudendo la finestra.
Passa alla directory con la configurazione di GKE su AWS.
```
cd anthos-aws
```

Genera le credenziali e connettiti

La documentazione di GKE su AWS presuppone che tu utilizzi un tunnel SSH sulla porta localhost per accedere al cluster. Se utilizzi un altro tipo di connessione al tuo VPC, ad esempio un'interconnessione diretta, una VPN o un altro metodo, puoi rimuovere la riga env HTTP_PROXY=http://localhost:8118 dai comandi.

Genera un kubeconfig per l'autenticazione. Utilizza anthos-gke per aggiungere le credenziali alla configurazione archiviata in ~/.kube/config.
```
anthos-gke aws management get-credentials
```
Verifica di poter connetterti al servizio di gestione con kubectl.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl cluster-info
```
kubectl stampa lo stato del cluster.

Passaggi successivi

Crea un cluster utente.
Utilizza un proxy con GKE su AWS.
Modifica la configurazione di kubectl per connetterti a GKE su AWS con meno opzioni della riga di comando.
Consulta i gruppi di sicurezza minimi richiesti per i cluster utente e il servizio di gestione GKE su AWS.