Versione 1.15. Questa versione non è più supportata. Per informazioni su come eseguire l'upgrade alla versione 1.16, vedi Eseguire l'upgrade dei cluster nella documentazione più recente. Per ulteriori informazioni sulle versioni supportate e non supportate, consulta la pagina Cronologia delle versioni nella documentazione più recente.

crea cluster di base

Questa pagina è la seconda parte di una guida che illustra una piccola installazione proof of concept di GDCV per Bare Metal. La prima parte, Configura l'infrastruttura minima, mostra come configurare l'hardware, pianificare gli indirizzi IP e configurare l'infrastruttura Google Cloud necessaria. Questo documento si basa sulla configurazione e sulla pianificazione della sezione precedente e mostra come creare un cluster di amministrazione e un cluster utente. Puoi quindi passare alla sezione Creare un servizio e una risorsa Ingress.

Questa guida ti aiuta a creare un'installazione minima di GKE su Bare Metal. Questa installazione minima potrebbe non essere adatta alle esigenze di produzione e ai casi d'uso reali. Per informazioni sulle installazioni di produzione, consulta le guide all'installazione.

Prima di iniziare

Assicurati di aver configurato l'hardware e pianificato i tuoi indirizzi IP come descritto nella parte precedente di questa guida, Configura l'infrastruttura minima. In alternativa, utilizza lo strumento di pianificazione dei requisiti di rete nella sezione Prerequisiti del flusso Creare un cluster di amministrazione GKE su Bare Metal nella console Google Cloud.
Se vuoi utilizzare Terraform per creare il cluster utente, devi utilizzare Terraform sulla workstation di amministrazione o su un altro computer.
1. Assicurati di aver installato i componenti più recenti di Google Cloud CLI:
```
gcloud components update
```
Per attivare e utilizzare l'API GKE On-Prem:
1. Abilita l'API nel tuo progetto:
```
gcloud services enable \
    --project PROJECT_ID \
    gkeonprem.googleapis.com
```
  Sostituisci PROJECT_ID con l'ID del progetto host del parco risorse.
  
  Se viene visualizzato un errore PERMISSION_DENIED, controlla l'ID progetto che hai inserito. Se l'ID progetto è corretto, esegui gcloud auth login per accedere a Google Cloud CLI con l'account che ha accesso al progetto.
2. Se è la prima volta che abiliti l'API GKE On-Prem nel progetto, devi inizializzare l'API. Per farlo, puoi chiamare un comando gcloud CLI che mostra le versioni disponibili che puoi utilizzare per creare un cluster:
```
gcloud container bare-metal clusters query-version-config \
    --project=PROJECT_ID \
    --location="us-central1"
```

Panoramica della procedura

La creazione di cluster di base prevede i seguenti passaggi principali:

Raccogliere informazioni utilizzate per specificare la configurazione dei cluster.
Crea un cluster di amministrazione per la gestione del cluster utente.
Crea un cluster utente che possa eseguire i tuoi carichi di lavoro.

1. Raccogliere informazioni

Utilizza le informazioni preparate in Configurare l'infrastruttura minima o quelle fornite dal pianificatore di rete per compilare ogni segnaposto nella tabella seguente. I segnaposto corrispondono ai valori dei campi nei file di configurazione del cluster per l'installazione minima di un cluster di amministrazione e un cluster utente. Alcuni segnaposto sono impostati sui valori precompilati dal file di configurazione del cluster generato, ma tutti i segnaposto sono modificabili.

Informazioni di base sul cluster
Il nome del cluster di amministrazione che stai creando. La posizione e la denominazione degli artefatti del cluster sulla workstation di amministrazione si basano sul nome del cluster. Lo spazio dei nomi del cluster deriva dal nome del cluster.	`ADMIN_CLUSTER_NAME`
Il nome del cluster utente che stai creando. La posizione e la denominazione degli artefatti del cluster sulla workstation di amministrazione si basano sul nome del cluster. Lo spazio dei nomi del cluster deriva dal nome del cluster.	`USER_CLUSTER_NAME`
La versione di `bmctl` che hai scaricato nella prima parte di questa guida.	`CLUSTER_VERSION`
Dati dell'account
Il percorso del file della chiave privata SSH sulla workstation di amministrazione. Per impostazione predefinita, il percorso è `/home/USERNAME/.ssh/id_rsa`.	`SSH_PRIVATE_KEY_PATH`
L'ID del progetto Google Cloud che vuoi utilizzare per connettere il cluster a Google Cloud e visualizzare log e metriche. Questo progetto è definito anche progetto host del parco risorse.	`PROJECT_ID`
L'indirizzo email associato al tuo account Google Cloud. Ad esempio: `alex@example.com`.	`GOOGLE_ACCOUNT_EMAIL`
Indirizzi IP delle macchine del nodo
Un indirizzo IP per il nodo del piano di controllo del cluster di amministrazione.	`ADMIN_CP_NODE_IP`
Un indirizzo IP per il nodo del piano di controllo del cluster utente.	`USER_CP_NODE_IP`
Un indirizzo IP per il nodo worker del cluster utente.	`USER_WORKER_NODE_IP`
Indirizzi VIP
VIP per il server API Kubernetes del cluster di amministrazione.	`ADMIN_CP_VIP`
VIP per il server API Kubernetes del cluster utente.	`USER_CP_VIP`
Un VIP da utilizzare come indirizzo esterno per il proxy in entrata.	`USER_INGRESS_VIP`
Intervallo di dieci indirizzi IP da utilizzare come indirizzi IP esterni per i servizi di tipo LoadBalancer. Tieni presente che questo intervallo include il VIP in entrata, richiesto da MetalLB. Nessun altro indirizzo IP può sovrapporsi a questo intervallo.	`START_IP-END_IP`
CIDR di pod e servizi
Intervallo di indirizzi IP nella notazione a blocchi CIDR per l'utilizzo da parte dei pod nel cluster di amministrazione. Il valore iniziale consigliato, precompilato nel file di configurazione del cluster generato, è `192.168.0.0/16`.	`192.168.0.0/16`
Intervallo di indirizzi IP nella notazione a blocchi CIDR per l'utilizzo da parte dei servizi nel cluster di amministrazione. Il valore iniziale consigliato, precompilato nel file di configurazione del cluster generato, è `10.96.0.0/20`.	`10.96.0.0/20`
Intervallo di indirizzi IP nella notazione a blocchi CIDR per l'utilizzo da parte dei pod nel cluster utente. Il valore iniziale consigliato, precompilato nel file di configurazione del cluster generato, è `192.168.0.0/16`.	`192.168.0.0/16`
Intervallo di indirizzi IP nella notazione a blocchi CIDR per l'utilizzo da parte dei servizi nel cluster utente. Il valore iniziale consigliato, precompilato nel file di configurazione del cluster generato, è `10.96.0.0/20`.	`10.96.0.0/20`

2. Crea un cluster di amministrazione

I passaggi seguenti creano un cluster di amministrazione per l'installazione minima del cluster di amministrazione e del cluster utente. Assicurati di aver fornito i valori per ogni segnaposto nella tabella della sezione precedente Raccogliere informazioni prima di procedere.

Per creare un cluster di amministrazione per l'installazione minima:

Imposta le credenziali predefinite che GKE su Bare Metal può utilizzare per creare il cluster con il seguente comando:
```
gcloud auth application-default login
```
Per generare un file di configurazione del cluster, esegui questo comando dalla directory /baremetal sulla workstation di amministrazione:
```
bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID
```

Verifica il file di configurazione del cluster di amministrazione:

Il seguente file di configurazione del cluster è compilato con i valori inseriti nella tabella di pianificazione nella sezione precedente. Oltre ai valori inseriti, tieni presente le seguenti differenze rispetto al file di configurazione generato:

I commenti sono stati rimossi da questo esempio per migliorare la leggibilità.
La specifica NodePool è stata rimossa. I nodi worker non sono consentiti per un cluster di amministrazione.

gcrKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-gcr.json
sshPrivateKeyPath: SSH_PRIVATE_KEY_PATH
gkeConnectAgentServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-connect.json
gkeConnectRegisterServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-register.json
cloudOperationsServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-cloud-ops.json
---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-ADMIN_CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: ADMIN_CLUSTER_NAME
  namespace: cluster-ADMIN_CLUSTER_NAME
spec:
  type: admin
  profile: default
  anthosBareMetalVersion: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: ADMIN_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: ADMIN_CP_VIP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250

Sostituisci i contenuti del file di configurazione generato sulla workstation di amministrazione con i contenuti dell'esempio precedente.

Apri il file generato bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml e sostituiscine i contenuti con quelli dell'esempio verificato nel passaggio precedente.
Per creare il cluster di amministrazione, esegui questo comando dalla directory /baremetal sulla workstation di amministrazione:
```
bmctl create cluster -c ADMIN_CLUSTER_NAME
```
Il comando bmctl mostra l'output sullo schermo mentre esegue i controlli preflight e crea il cluster. Le informazioni dettagliate vengono scritte nei log nella cartella baremetal/bmctl-workspace/ADMIN_CLUSTER_NAME/log sulla workstation di amministrazione.

Il completamento della creazione del cluster può richiedere diversi minuti.

Verifica che il cluster sia stato creato e sia in esecuzione:

kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    get nodes

Se il cluster è in esecuzione, la risposta sarà simile a questa:

NAME     STATUS  ROLES          AGE  VERSION
node-01  Ready   control-plane  16h  v1.25.7-gke.1000

Per concedere al tuo account utente il ruolo Kubernetes clusterrole/cluster-admin nel cluster, esegui questo comando gcloud:

gcloud container fleet memberships generate-gateway-rbac \
    --membership=ADMIN_CLUSTER_NAME \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    --context=ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME \
    --apply

L'output di questo comando è simile al seguente, che viene troncato per una migliore leggibilità:

Validating input arguments.
Specified Cluster Role is: clusterrole/cluster-admin
Generated RBAC policy is:
--------------------------------------------
...

Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-kubeconfig, context: <var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-admin@<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

Tra le altre cose, il criterio RBAC consente di accedere al cluster nella console Google Cloud per visualizzare ulteriori dettagli del cluster.

Se vuoi, registra il cluster nell'API GKE On-Prem. Questa API ospitata da Google Cloud ti consente di gestire il ciclo di vita del cluster di amministrazione utilizzando la console Google Cloud o gcloud CLI.

gcloud container bare-metal admin-clusters enroll ADMIN_CLUSTER_NAME  \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
    --location=us-central1

3. Creazione di un cluster utente

I passaggi seguenti creano un cluster utente per un'installazione minima del cluster di amministrazione e del cluster utente. Assicurati di aver fornito i valori per ogni segnaposto nella tabella della precedente sezione Raccogli informazioni prima di procedere.

Se utilizzi Terraform per creare il cluster utente, questo viene automaticamente registrato nell'API GKE On-Prem. Questa API ospitata da Google Cloud ti consente di gestire il ciclo di vita del cluster utilizzando la console Google Cloud, gcloud CLI e Terraform. Se utilizzi bmctl, puoi facoltativamente registrare il cluster nell'API GKE On-Prem dopo la creazione del cluster.

Per creare un cluster utente per l'installazione minima:

`bmctl`

Genera un file di configurazione del cluster:

bmctl create config -c USER_CLUSTER_NAME \
  --project-id=PROJECT_ID

Verifica il file di configurazione del cluster utente:

Il seguente file di configurazione del cluster è compilato con i valori inseriti precedentemente nella tabella di pianificazione. Oltre ai valori inseriti, tieni presente le seguenti differenze rispetto al file di configurazione generato:

I commenti sono stati rimossi da questo esempio per migliorare la leggibilità.
Il tipo di cluster spec.type è stato impostato su user.
Il campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts è stato aggiunto per concedere il valore clusterrole/cluster-admin al tuo account. Tra le altre cose, questo campo consente di accedere al cluster nella console Google Cloud per visualizzare ulteriori dettagli sul cluster.

---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-USER_CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: USER_CLUSTER_NAME
  namespace: cluster-USER_CLUSTER_NAME
spec:
  type: user
  profile: default
  anthosBareMetalVersion: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: USER_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: USER_CP_VIP
      ingressVIP: USER_INGRESS_VIP
    addressPools:
    - name: pool1
      addresses:
      - START_IP-END_IP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - GOOGLE_ACCOUNT_EMAIL
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-USER_CLUSTER_NAME
spec:
  clusterName: USER_CLUSTER_NAME
  nodes:
  - address: USER_WORKER_NODE_IP

Sostituisci i contenuti del file di configurazione generato sulla workstation di amministrazione con i contenuti dell'esempio precedente.

Apri il file generato bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml e sostituiscine i contenuti con quelli dell'esempio verificato nel passaggio precedente.
Crea il cluster utente:
```
bmctl create cluster -c USER_CLUSTER_NAME \
--kubeconfig ADMIN_KUBECONFIG
```
Il comando bmctl mostra l'output sullo schermo mentre esegue i controlli preflight e crea il cluster. Le informazioni dettagliate vengono scritte nei log nella cartella baremetal/bmctl-workspace/USER_CLUSTER_NAME/log sulla workstation di amministrazione.

Il completamento della creazione del cluster può richiedere diversi minuti.

Verifica che il cluster sia stato creato e sia in esecuzione:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-kubeconfig \
  get nodes

Se il cluster è in esecuzione, la risposta sarà simile a questa:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Se vuoi, registra il cluster nell'API GKE On-Prem:

gcloud container bare-metal clusters enroll USER_CLUSTER_NAME  \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
  --location=us-central1

Console

Per creare un cluster utente nella console:

Nella console, vai alla pagina Crea un cluster GKE su Bare Metal.

Vai a Crea un cluster GKE su Bare Metal
Assicurati che nell'elenco dei progetti Google Cloud sia selezionato PROJECT_ID.
In Scegli il tipo di cluster, seleziona Crea un cluster utente per un cluster di amministrazione esistente.
Tocca Avanti.

Impostazioni di base del cluster

Inserisci USER_CLUSTER_NAME come nome del cluster utente o utilizza il valore predefinito.
Assicurati che sia selezionato il cluster di amministrazione appena creato.
In Posizione API Google Cloud, seleziona us-central1.
In GDCV per la versione Bare Metal, seleziona CLUSTER_VERSION o utilizza il valore predefinito. Puoi utilizzare i valori predefiniti per le altre impostazioni in questa pagina.
Fai clic su Networking nella barra di navigazione a sinistra.

Networking

Nella sezione Piano di controllo, inserisci quanto segue nel campo IP 1 del nodo del piano di controllo:
```
USER_CP_NODE_IP
```
Nella sezione Bilanciatore del carico, utilizza il bilanciatore del carico predefinito, In bundle con MetalLB.
Vai alla sezione Nuovo pool di indirizzi. Inserisci l'intervallo di indirizzi IP nel campo Intervallo di indirizzi IP 1:
```
10.200.0.51-10.200.0.70
```
Fai clic su Fine.
Nella sezione IP virtuali, inserisci l'indirizzo IP per il VIP del piano di controllo:
```
USER_CP_VIP
```
Inserisci l'indirizzo IP per il VIP in entrata:
```
USER_INGRESS_VIP
```
Nella sezione CIDR servizi e pod, se non hai modificato i CIDR per servizi e pod nello strumento di pianificazione, puoi utilizzare i valori predefiniti.

Se hai modificato i CIDR, inserisci i CIDR che vuoi utilizzare:
- CIDR del servizio:
```
10.96.0.0/20
```
- CIDR del pod:
```
192.168.0.0/16
```
Fai clic su Pool predefinito nella barra di navigazione a sinistra.

Crea un pool di nodi

Il cluster deve avere almeno un pool di nodi per i nodi worker. Un pool di nodi è un modello per i gruppi di nodi worker creati in questo cluster.

Inserisci l'indirizzo IP del nodo worker del cluster utente nel campo Indirizzo dei nodi 1:

USER_WORKER_NODE_IP

Crea il cluster

Fai clic su Verifica e crea per creare il cluster utente.

La creazione del cluster utente richiede almeno 15 minuti. La console mostra i messaggi di stato mentre verifica le impostazioni e crea il cluster.

Se si è verificato un problema con la configurazione, nella console viene visualizzato un messaggio di errore sufficientemente chiaro da permetterti di risolvere il problema di configurazione e riprovare a creare il cluster.

Per ulteriori informazioni sul processo di creazione, fai clic su Mostra dettagli per visualizzare un riquadro laterale. Fai clic su per chiudere il riquadro dei dettagli.

Quando il cluster viene creato, viene visualizzato lo stato Stato del cluster: in esecuzione.
Dopo aver creato il cluster, fai clic su Cluster per tornare alla pagina Cluster.

Interfaccia a riga di comando gcloud

Questa sezione mostra come creare un cluster utente e un pool di nodi utilizzando gcloud CLI.

Esegui questo comando per creare un cluster utente:

gcloud container bare-metal clusters create USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --admin-cluster-membership=ADMIN_CLUSTER_NAME \
  --admin-cluster-membership-project=PROJECT_ID \
  --admin-cluster-membership-location=global \
  --version=CLUSTER_VERSION \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
  --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=START_IP-END_IP' \
  --control-plane-node-configs='node-ip=USER_CP_NODE_IP' \
  --control-plane-vip=USER_CP_VIP \
  --control-plane-load-balancer-port=443 \
  --ingress-vip=USER_INGRESS_VIP \
  --lvp-share-path=/mnt/localpv-share \
  --lvp-share-storage-class=local-shared \
  --lvp-node-mounts-config-path=/mnt/localpv-disk \
  --lvp-node-mounts-config-storage-class=local-disks

L'output del comando è simile al seguente:

Waiting for operation [projects/example-project-12345/locations/us-west1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.

Nell'output di esempio, la stringa operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 è la stringa OPERATION_ID dell'operazione a lunga esecuzione. Puoi conoscere lo stato dell'operazione con il seguente comando:

gcloud container bare-metal operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

La creazione del cluster richiede circa 15 minuti o più. Durante la creazione del cluster, puoi eseguire il comando precedente di tanto in tanto per ottenere lo stato attuale.

Quando viene creato il cluster, viene visualizzato un output simile al seguente:

Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/bareMetalClusters/USER_CLUSTER_NAME].

Dopo aver creato il cluster, esegui questo comando per creare un pool di nodi sul cluster appena creato.

gcloud container bare-metal node-pools create node-pool-1 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --node-configs node-ip=USER_WORKER_NODE_IP

Per ulteriori informazioni e altri esempi, consulta quanto segue:

Terraform

Questa sezione mostra come creare un cluster utente e un pool di nodi utilizzando Terraform.

Crea una directory e un nuovo file all'interno di quella directory. Il nome del file deve avere l'estensione .tf. In questa guida, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```

Verifica la risorsa Terraform del cluster utente:

Il seguente esempio di risorsa Terraform viene compilato con i valori inseriti nella tabella di pianificazione della sezione precedente.

resource "google_gkeonprem_bare_metal_cluster"  "cluster-basic" {
  provider = google-beta
  name = "USER_CLUSTER_NAME"
  project = "PROJECT_ID"
  location = "us-central1"
  admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME"
  bare_metal_version = "CLUSTER_VERSION"
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["10.96.0.0/20"]
      pod_address_cidr_blocks = ["192.168.0.0/16"]
    }
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        labels = {}
        operating_system = "LINUX"
        node_configs {
          labels = {}
          node_ip = "USER_CP_NODE_IP"
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = "USER_CP_VIP"
      ingress_vip = "USER_INGRESS_VIP"
    }
    metal_lb_config {
      address_pools {
        pool = "pool1"
        addresses = [
          "START_IP-END_IP"
        ]
        avoid_buggy_ips = true
        manual_assign = true
      }
    }
  }
  storage {
    lvp_share_config {
      lvp_config {
        path = "/mnt/localpv-share"
        storage_class = "local-shared"
      }
      shared_path_pv_count = 5
    }
    lvp_node_mounts_config {
      path = "/mnt/localpv-disk"
      storage_class = "local-disks"
    }
  }
  security_config {
    authorization {
      admin_users {
        username = "GOOGLE_ACCOUNT_EMAIL"
      }
    }
  }
}

resource "google_gkeonprem_bare_metal_node_pool" "node-pool-default" {
  provider = google-beta
  name =  "node-pool-1"
  bare_metal_cluster = google_gkeonprem_bare_metal_cluster.cluster-basic.name
  project = "PROJECT_ID"
  location = "us-central1"
  node_pool_config {
    operating_system = "LINUX"
    node_configs {
      node_ip = "USER_WORKER_NODE_IP"
    }
  }
}

Copia la risorsa Terraform in main.tf e salva il file.
Inizializza e crea il piano Terraform:
```
terraform init
```
Terraform installa tutte le librerie necessarie, ad esempio il provider Google Cloud.
Rivedi la configurazione e apporta modifiche, se necessario:
```
terraform plan
```
Applica il piano Terraform per creare il cluster utente:
```
terraform apply
```
Quando richiesto, inserisci yes.

La creazione del cluster utente di base e del pool di nodi richiede circa 15 minuti (o più, a seconda della rete).
Per creare un file kubeconfig per il cluster utente, esegui questo comando sulla workstation di amministrazione:
```
bmctl get credentials --cluster USER_CLUSTER_NAME \
--admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
```
L'output del comando mostra il nome del file kubeconfig per il cluster utente, ad esempio:
```
bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig
```
TIMESTAMP nel nome del file indica la data e l'ora di creazione del file.

Poiché questo file contiene le credenziali di autenticazione per il cluster, devi archiviarlo in una posizione sicura con accesso limitato.

Verifica che il cluster sia stato creato e sia in esecuzione:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig \
    get nodes

Se il cluster è in esecuzione, la risposta sarà simile a questa:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Per ulteriori informazioni e altri esempi, consulta quanto segue:

Connettiti al cluster utente

Se hai creato il cluster utente utilizzando bmctl, il tuo indirizzo email è incluso nella sezione clusterSecurity del file di configurazione utente di esempio. Se hai creato il cluster utilizzando Terraform, il tuo indirizzo email è incluso nella sezione security_config della risorsa google_gkeonprem_bare_metal_cluster di esempio. Questi esempi configurano automaticamente criteri di controllo dell'accesso basato su ruoli (RBAC), in modo da:

Concederti il ruolo Kubernetes clusterrole/cluster-admin nel cluster.
Consenti di accedere al cluster nella console Google Cloud utilizzando la tua identità Google. Puoi visualizzare il cluster nella pagina Cluster GKE della console.
Puoi eseguire i comandi kubectl sul computer locale utilizzando il kubeconfig del gateway di connessione.

Per ottenere il kubeconfig del gateway di connessione, esegui questi comandi dal computer locale:

Recupera la voce kubeconfig che può accedere al cluster tramite il gateway di connessione.

gcloud container fleet memberships get-credentials USER_CLUSTER_NAME  \
--project=PROJECT_ID

L'output è simile al seguente:

Starting to build Gateway kubeconfig...
Current project_id: PROJECT_ID
A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.

Ora puoi eseguire i comandi kubectl tramite il gateway di connessione:
```
kubectl get nodes
```
L'output è simile al seguente:
```
NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001
```
Molti comandi kubectl richiedono kubeconfig per il cluster di amministrazione. Dovrai eseguire questi comandi sulla workstation di amministrazione.

Passaggi successivi

Crea un servizio e un Ingress
Scopri di più su:
- La google_gkeonprem_bare_metal_clusterrisorsa Terraform
- Il gateway di connessione