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 sottoreti pubbliche e private ed esegui anthos-gke per completare l'installazione di un servizio di gestione.

Prima di iniziare

Per completare i passaggi che seguono, devi disporre di quanto segue:

Autorizzazioni IAM AWS 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 negli insiemi 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 AWS, consulta VPC con subnet pubbliche e private.
Gli ID delle subnet pubbliche e private della VPC esistente. Ad esempio, subnet-1234567890abcdefg.
Per le versioni del cluster 1.20 o precedenti, un gruppo di sicurezza AWS che consenta l'ingresso di SSH (porta 22) 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 consenta le connessioni in uscita di Konnectivity (porta 8132) dagli intervalli di indirizzi IP del 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 contenuti seguenti 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 della risorsa Amazon della chiave AWS KMS che protegge i dati del servizio di gestione al momento della sua creazione.
- DATABASE_KMS_KEY_ARN con l'Amazon Resource Name della chiave KMS AWS che protegge i tuoi database etcd.
- SECURITY_GROUP_IDS con ID gruppo di sicurezza aggiuntivi che consentono accesso alle VM del servizio di gestione.
- GCP_PROJECT_ID con il Google Cloud progetto che ospita il tuo ambiente GKE Enterprise.
- MANAGEMENT_KEY_PATH con la posizione della Google Cloud chiave dell'account di servizio di gestione.
- HUB_KEY_PATH con la posizione della Google Cloud chiave dell'account di servizio.
- NODE_KEY_PATH con la posizione della chiave dell'account di servizio del tuo node GKE su AWS.
- VPC_SUBNET_ID con l'ID della subnet in cui viene eseguito il servizio di gestione.
- SSH_SECURITY_GROUP con l'elenco degli ID gruppo di sicurezza che consentono 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 ulteriori informazioni, consulta Volumi SSD per uso generico (gp3).
- ROOT_VOLUME_KEY con l'Amazon Resource Name della chiave AWS KMS che cripta i volumi principali dell'istanza del servizio di gestione. Per saperne di più, consulta Utilizzare una CMK gestita dal cliente per criptare i volumi.
(Facoltativo) Se vuoi creare un host bastione per accedere al tuo ambiente GKE su AWS con un tunnel SSH, sostituisci i seguenti valori:
- BASTION_HOST_SUBNET_ID con l'ID della subnet in cui viene eseguito l'host bastione. Assicurati che VPC_SUBNET_ID consenta le connessioni in entrata da BASTION_HOST_SUBNET_ID.
- SSH_CIDR_BLOCK con il blocco CIDR da cui il tuo host bastione consente la connessione SSH in entrata. Ad esempio, 203.0.113.0/24. Se vuoi consentire l'accesso SSH da qualsiasi indirizzo IP, utilizza 0.0.0.0/0.
- BASTION_VOLUME_KEY con l'Amazon Resource Name della chiave KMS di AWS che protegge il volume root del bastione.
(Facoltativo) Se vuoi indirizzare il traffico 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 dieci minuti. Al termine di anthos-gke, il servizio di gestione viene eseguito su AWS.

Tagga le sottoreti con il nome del cluster

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

Per taggare le sottoreti, svolgi i seguenti passaggi:

Passa alla directory con la configurazione di GKE su AWS. Hai creato questa directory durante la installazione del servizio di gestione.
```
cd anthos-aws
```
Esporta l'ID cluster come variabile di ambiente $CLUSTER-ID. Scegli la versione di Terraform, quindi esegui i seguenti comandi:
Terraform 0.12, 0.13
```
export CLUSTER_ID=$(terraform output cluster_id)
```
Terraform 0.14.3 o versioni successive
```
export CLUSTER_ID=$(terraform output -raw cluster_id)
```
Esporta l'ID VPC AWS come variabile di ambiente $VPC_ID. Scegli la versione di Terraform, quindi esegui i seguenti comandi:
Terraform 0.12, 0.13
```
export VPC_ID=$(terraform output vpc_id)
```
Terraform 0.14.3 o versioni successive
```
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 abbiano private nel nome. Se le sottoreti non includono questo testo, modifica i parametri del flag --filters. Per ulteriori informazioni, consulta Utilizzare i filtri.
Tagga le sottoreti con l'ID cluster. Esegui il seguente comando per ciascuna delle tue sottoreti.
```
  aws ec2 create-tags \
      --resources SUBNET_IDS \
      --tags Key=gke:multicloud:cluster-id,Value=$CLUSTER_ID
```
Sostituisci SUBNET_IDS con l'elenco di ID sottorete, 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 eseguire il tunneling dei comandi tramite un host bastione. Se hai una connessione diretta al tuo VPC AWS, vai a Genera le 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 apra un tunnel SSH all'host bastione.
```
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 bastione (~/.ssh/anthos-gke).
Per aprire il tunnel, esegui lo script bastion-tunnel.sh. Il tunnel inoltra da localhost:8118 all'bastion host.

Per aprire un tunnel per l'bastion host, esegui il seguente comando:
```
./bastion-tunnel.sh -N
```
I messaggi del tunnel SSH vengono visualizzati in questa finestra. Quando è tutto pronto, per chiudere la connessione, interrompi il processo 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 8118 di localhost per accedere al cluster. Se utilizzi un altro tipo di connessione alla tua 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 memorizzata in ~/.kube/config.
```
anthos-gke aws management get-credentials
```
Verifica di essere in grado di 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 di utenti.
Utilizza un proxy con GKE su AWS.
Modifica la configurazione di kubectl per connetterti a GKE su AWS con meno opzioni a riga di comando.
Consulta i gruppi di sicurezza minimi richiesti per il servizio di gestione GKE su AWS e i cluster utente.