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

Integrazione con l'infrastruttura esistente

In questo argomento configurerai un Virtual Private Cloud (VPC) di 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, sono necessari:

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 abilitati.
- Nessun valore personalizzato domain-name negli insiemi di opzioni DHCP. Per ulteriori informazioni, consulta la sezione Risoluzione dei problemi. I cluster Anthos su AWS non supportano 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 subnet pubblici e privati del tuo VPC esistente. Ad esempio: subnet-1234567890abcdefg.
Per le versioni del cluster 1.20 o precedenti, un gruppo di sicurezza AWS che consente l'SSH (porta 22) in entrata dai gruppi di sicurezza o dagli intervalli IP in cui gestirai i cluster Anthos sull'installazione di AWS.
Per le versioni del cluster 1.21 o successive, un gruppo di sicurezza AWS che consente le connessioni Konnectivity (porta 8132) in uscita dagli intervalli IP VPC che ospitano i cluster Anthos sui pool di nodi 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 IAM AWS di amministrazione.
- KMS_KEY_ARN con il nome risorsa Amazon della chiave KMS AWS che protegge i dati del servizio di gestione quando viene creato.
- DATABASE_KMS_KEY_ARN con il nome risorsa Amazon della chiave KMS AWS che protegge i tuoi database etcd.
- SECURITY_GROUP_IDS con ID gruppo di sicurezza aggiuntivi ha consentito l'accesso alle VM del tuo servizio di gestione.
- GCP_PROJECT_ID con il progetto Google Cloud che ospita il tuo ambiente Anthos.
- MANAGEMENT_KEY_PATH con la posizione della tua chiave dell'account di servizio di gestione Google Cloud.
- HUB_KEY_PATH con la posizione della tua chiave dell'account di servizio Google Cloud Connect.
- NODE_KEY_PATH con la località dei tuoi cluster Anthos sul nodo AWS chiave account di servizio.
- VPC_SUBNET_ID con l'ID subnet in cui viene eseguito il servizio di gestione.
- SSH_SECURITY_GROUP con l'elenco degli ID gruppo di sicurezza ha 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 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 montaggio delle operazioni di IO di cui è stato eseguito il provisioning al secondo (IOPS) per il volume. Valido solo quando volumeType è GP3. Per saperne di più, consulta Volumi SSD per uso generico (gp3).
- ROOT_VOLUME_KEY con il nome risorsa Amazon della chiave KMS AWS che cripta i volumi root dell'istanza del servizio di gestione. Per maggiori informazioni, consulta Utilizzo di un CMK gestito dal cliente per criptare i volumi.
Facoltativo: se vuoi creare un host di base per accedere all'ambiente Cluster Anthos on AWS con un tunnel SSH, sostituisci i seguenti valori:
- BASTION_HOST_SUBNET_ID con l'ID subnet in cui viene eseguito il bastion host. 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 di base 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 il nome risorsa Amazon della chiave KMS AWS che protegge il volume root del bastion.
(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 proxy. Se non utilizzi un proxy, rimuovi questa riga.
Esegui anthos-gke aws management init per creare 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 verrà eseguito su AWS.

Tagga le tue subnet con il nome del tuo cluster

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

Per codificare le subnet, procedi nel seguente modo:

Passa alla directory con la configurazione di Cluster Anthos on 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, quindi esegui i comandi seguenti:
Terraform 0.12, 0.13
```
export CLUSTER_ID=$(terraform output cluster_id)
```
Terraform 0.14.3 e versioni successive
```
export CLUSTER_ID=$(terraform output -raw cluster_id)
```
Esporta l'ID VPC di AWS come variabile di ambiente $VPC_ID. Scegli la tua versione di Terraform, quindi esegui i comandi seguenti:
Terraform 0.12, 0.13
```
export VPC_ID=$(terraform output vpc_id)
```
Terraform 0.14.3 e versioni successive
```
export VPC_ID=$(terraform output -raw vpc_id)
```
Ottieni gli ID subnet privati con lo strumento dell'interfaccia a riga di comando di 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 il nome delle subnet sia private. Se le tue subnet non includono questo testo, modifica i parametri del flag --filters. Per maggiori informazioni, consulta la pagina Utilizzo dei filtri.
Tagga le tue subnet con l'ID del tuo cluster. Esegui il comando seguente per ciascuna delle subnet.
```
  aws ec2 create-tags \
      --resources SUBNET_IDS \
      --tags Key=gke:multicloud:cluster-id,Value=$CLUSTER_ID
```
Sostituisci SUBNET_IDS con l'elenco di ID subnet, separati da spazi. Ad esempio: subnet-012345678abcdef subnet-abcdef123456789 subnet-123456789abcdef.

Connessione al servizio di gestione

In questa sezione stabilirerai una connessione al tuo servizio di gestione. Puoi eseguire il tunneling dei comandi tramite un host di base. Se hai una connessione diretta al tuo VPC AWS, vai a Generare le credenziali e connettersi.

Connessione con un bastion host

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

Usa terraform per generare uno script che apra un tunnel SSH al bastion host.
```
terraform output bastion_tunnel > bastion-tunnel.sh
chmod 755 bastion-tunnel.sh
```
Terraform crea lo script bastion-tunnel.sh che utilizza la chiave SSH del bastion host (~/.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 al bastion host, esegui il comando seguente:
```
./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 Cluster Anthos on AWS.
```
cd anthos-aws
```

Genera le credenziali e connetti

La documentazione per i cluster Anthos su AWS presuppone che utilizzi un tunnel SSH sulla porta 8118 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 Cluster Anthos on AWS.
Modifica la configurazione di kubectl per connetterti ai cluster Anthos su AWS con meno opzioni a riga di comando.
Scopri i gruppi di sicurezza minimi richiesti per i tuoi cluster Anthos su servizi di gestione AWS e cluster utente.