Crea cluster di base

Questa è la seconda parte di una guida che illustra l'uso dei il software Google Distributed Cloud (precedentemente noto come Google Distributed Cloud) una piccola installazione proof-of-concept dei cluster GKE il tuo hardware Bare Metal. La prima parte, Configura l'infrastruttura minima, mostra come configurare l'hardware, pianificare gli indirizzi IP e configurare dell'infrastruttura. Questo documento si basa sulla configurazione e sulla pianificazione della precedente e illustra come creare un cluster di amministrazione e un cluster utente. Puoi quindi vai a Crea un servizio e un Ingress.

Questa guida ti aiuta a creare un'installazione minima di Google Distributed Cloud. Questo un'installazione minima potrebbe non essere adatta alle tue esigenze di produzione effettive e casi d'uso specifici. Per informazioni sulle installazioni di produzione, consulta guide all'installazione.

Prima di iniziare

  1. Assicurati di aver configurato l'hardware e di aver pianificato gli indirizzi IP come descritti nella parte precedente di questa guida, Configura l'infrastruttura minima. In alternativa, utilizza lo strumento di pianificazione dei requisiti di rete nella sezione Prerequisiti sezione del Crea un flusso del cluster di amministrazione bare metal nella console Google Cloud.

  2. Se vuoi usare Terraform per creare il cluster utente, devi 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

  3. Segui questi passaggi 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 progetto di del tuo progetto host del parco risorse.

      Se viene visualizzato un errore PERMISSION_DENIED, controlla l'ID progetto inserito. Se l'ID progetto è corretto, esegui gcloud auth login per accedere a Google Cloud CLI con l'account che ha accesso progetto.

    2. Se è la prima volta che abiliti l'API GKE On-Prem nel tuo progetto, devi inizializzare l'API. Puoi farlo chiamando un comando gcloud CLI che mostra le versioni 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:

  1. Raccogli le informazioni utilizzate per specificare la configurazione dei tuoi cluster.

  2. Crea un cluster di amministrazione per la gestione del cluster utente.

  3. Crea un cluster utente che possa eseguire i tuoi carichi di lavoro.

1. Raccogliere informazioni

Utilizza le informazioni che hai preparato nella Configura l'infrastruttura minima o dallo strumento di pianificazione 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. Alcune i segnaposto sono impostati sui valori precompilati del cluster generato di configurazione del deployment, ma tutti i segnaposto sono modificabili.

Informazioni di base sul cluster
Il nome del cluster di amministrazione che stai creando. La località e la denominazione di artefatti del cluster sulla workstation di amministrazione si basa sul cluster . Lo spazio dei nomi del cluster deriva dal nome del cluster. ADMIN_CLUSTER_NAME
Il nome del cluster utente che stai creando. La località e la denominazione di artefatti del cluster sulla workstation di amministrazione si basa sul 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. Di predefinita, il percorso è
/home/USERNAME/.ssh/id_rsa.		 SSH_PRIVATE_KEY_PATH
L'ID del progetto Google Cloud che vuoi utilizzare per la connessione. il tuo cluster a Google Cloud e la visualizzazione di log e metriche. Questo progetto è chiamato 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 proxy in entrata. USER_INGRESS_VIP
Intervallo di dieci indirizzi IP da utilizzare come indirizzi IP esterni per Servizi di tipo LoadBalancer. Nota che questo intervallo include il traffico in entrata VIP, richiesto da MetalLB. Nessun altro indirizzo IP può sovrapporsi a questo intervallo. START_IP-END_IP
CIDR pod e servizi
Intervallo di indirizzi IP nella notazione a blocchi CIDR per l'utilizzo da parte dei pod nella del cluster di amministrazione. Il valore iniziale consigliato, precompilato nel generato il file di configurazione del cluster è 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 nella del cluster di amministrazione. Il valore iniziale consigliato, precompilato nel generato il file di configurazione del cluster è 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 nella nel cluster utente. Il valore iniziale consigliato, precompilato nel di configurazione del cluster generato ed è il valore predefinito è 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 nella nel cluster utente. Il valore iniziale consigliato, precompilato nel di configurazione del cluster generato ed è il valore predefinito è 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 un cluster di amministrazione e un utente dell'installazione del cluster. Assicurati di aver fornito i valori per ogni segnaposto nella tabella della sezione precedente Raccogliere informazioni prima procedere.

Quando l'API GKE On-Prem (gkeonprem.googleapis.com) è abilitata per il tuo i cluster appena creati vengono automaticamente registrati con l'API. La registrazione avviene anche spec.gkeOnPremAPI non è specificato nel file di configurazione del cluster. Registrazione con questo L'API ospitata su Google Cloud ti consente di gestire il ciclo di vita del tuo cluster utilizzando console Google Cloud o gcloud CLI.

Per disattivare la registrazione automatica, rimuovi il commento dalla sezione spec.gkeOnPremAPI in il file di configurazione del cluster e imposta spec.gkeOnPremAPI.enabled su false prima di creare il cluster. Il campo spec.gkeOnPremAPI.enabled è modificabile, in modo da poter annullare la registrazione del cluster in qualsiasi momento dopo la creazione.

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

  1. Imposta le credenziali predefinite che Google Distributed Cloud può utilizzare per creare nel cluster con il comando seguente:

    gcloud auth application-default login

  2. Per generare un file di configurazione del cluster, esegui questo comando nella directory /baremetal sulla workstation di amministrazione:

    bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID

  3. Verifica il file di configurazione del cluster di amministrazione:

    Il seguente file di configurazione del cluster viene compilato con i valori che inserito nella tabella di pianificazione nella sezione precedente. Oltre a i valori inseriti, tieni presente le seguenti differenze rispetto ai valori di configurazione del deployment:

    • I commenti sono stati rimossi da questo campione per migliorarne la leggibilità.
    • La specifica NodePool è stata rimossa. I nodi worker non sono consentiti per un del 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
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1

  4. Sostituisci i contenuti del file di configurazione generato nella pagina di amministrazione con i contenuti dell'esempio precedente.

    Apri il file generato, bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml e sostituisco i suoi contenuti con quelli dell'esempio verificato nel passaggio precedente.

  5. Per creare il cluster di amministrazione, esegui questo comando dall'/baremetal sulla workstation di amministrazione:

    bmctl create cluster -c ADMIN_CLUSTER_NAME

    Il comando bmctl mostra l'output sullo schermo durante l'esecuzione preflight controlla e crea il cluster. Le informazioni dettagliate vengono scritte nei log in baremetal/bmctl-workspace/ADMIN_CLUSTER_NAME/log sulla workstation di amministrazione.

    La creazione del cluster può richiedere diversi minuti.

  6. 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

  7. Per concedere al tuo account utente il ruolo clusterrole/cluster-admin di Kubernetes sul 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 è troncato per migliorare la 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 ti consente di accedere al cluster Console Google Cloud per visualizzare ulteriori dettagli sul cluster.

3. Creazione di un cluster utente

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

Per creare un cluster utente per l'installazione minima:

bmctl

Quando l'API GKE On-Prem (gkeonprem.googleapis.com) è abilitata per il tuo i cluster appena creati vengono automaticamente registrati con l'API. La registrazione avviene anche spec.gkeOnPremAPI non è specificato nel file di configurazione del cluster. Quando il cluster viene registrati con questa API ospitata da Google Cloud, puoi utilizzare la console Google Cloud oppure gcloud CLI per gestire il ciclo di vita del cluster.

Per disattivare la registrazione automatica, rimuovi il commento dalla sezione spec.gkeOnPremAPI in il file di configurazione del cluster e imposta spec.gkeOnPremAPI.enabled su false prima di creare il cluster. Il campo spec.gkeOnPremAPI.enabled è modificabile per consentirti di annullare la registrazione del cluster in qualsiasi momento dopo la creazione.

  1. Genera un file di configurazione del cluster:

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

  2. Verifica il file di configurazione del cluster utente:

    Il seguente file di configurazione del cluster viene compilato con i valori che inserito in precedenza nella tabella di pianificazione. Oltre ai valori che hai inserito, tieni presente le seguenti differenze rispetto alla configurazione generata file:

    • I commenti sono stati rimossi da questo campione per migliorarne la leggibilità.
    • Il tipo di cluster spec.type è stato impostato su user.
    • Il campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts è stato aggiunto per concedere clusterrole/cluster-admin al tuo account. Tra altri aspetti, questo campo ti consente di accedere al cluster 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
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1
---
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

  3. Sostituisci i contenuti del file di configurazione generato nella pagina di amministrazione con i contenuti dell'esempio precedente.

    Apri il file generato, bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml e sostituisco i suoi contenuti con quelli dell'esempio verificato nel passaggio precedente.

  4. Crea il cluster utente:

    bmctl create cluster -c USER_CLUSTER_NAME \
--kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

    Il comando bmctl mostra l'output sullo schermo durante l'esecuzione preflight controlla e crea il cluster. Le informazioni dettagliate vengono scritte nei log in baremetal/bmctl-workspace/USER_CLUSTER_NAME/log sulla workstation di amministrazione.

    La creazione del cluster può richiedere diversi minuti.

  5. 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

Console

Segui questi passaggi per creare un cluster utente nella console:

  1. Nella console, vai a Crea un cluster bare metal. .

    Vai a Crea un cluster bare metal

  2. Assicurati che l'elenco di progetti Google Cloud abbia Opzione PROJECT_ID selezionata.

  3. Fai clic su Crea cluster.

  4. Nella finestra di dialogo, fai clic su On-premise.

  5. Accanto a Bare metal, fai clic su Configura. La pagina Prerequisiti vengono visualizzati i video.

  6. In Scegli il tipo di cluster, seleziona Crea un cluster utente per un cluster di amministrazione esistente

  7. Fai clic su Avanti.

Impostazioni di base del cluster

  1. Entra in USER_CLUSTER_NAME come nome del cluster utente o utilizza quello predefinito.

  2. Assicurati che il cluster di amministrazione appena creato sia selezionato.

  3. In Località API Google Cloud, seleziona us-central1.

  4. In Versione Google Distributed Cloud, seleziona CLUSTER_VERSION o utilizza il valore predefinito. Puoi utilizzare i valori predefiniti per le altre impostazioni in questa pagina.

  5. Fai clic su Networking nella barra di navigazione a sinistra.

Networking

  1. Nella sezione Piano di controllo, inserisci quanto segue nel campo Controllo campo plane node IP 1:

    USER_CP_NODE_IP

  2. Nella sezione Bilanciatore del carico, utilizza il bilanciatore del carico predefinito, In bundle con MetalLB.

  3. Vai alla sezione Nuovo pool di indirizzi. Inserisci l'intervallo di indirizzi IP nel Campo Intervallo indirizzi IP 1:

    10.200.0.51-10.200.0.70

  4. Fai clic su Fine.

  5. Nella sezione IP virtuali, inserisci l'indirizzo IP del Vip piano di controllo:

    USER_CP_VIP

  6. Inserisci l'indirizzo IP del VIP Ingress:

    USER_INGRESS_VIP

  7. Nella sezione CIDR di servizi e pod, se non hai modificato il CIDR servizi e pod nello strumento di pianificazione, puoi usare i valori predefiniti.

    Se hai modificato i CIDR, inserisci quelli che vuoi utilizzare:

    • CIDR del servizio:
    10.96.0.0/20
    • CIDR pod:
    192.168.0.0/16

  8. 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. R il pool di nodi è un modello per i gruppi di nodi worker creati in questo in un cluster Kubernetes.

Inserisci l'indirizzo IP del nodo worker del cluster utente nel campo Nodi indirizzo 1:

USER_WORKER_NODE_IP

Crea il cluster

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

    Per creare il cluster utente sono necessari almeno 15 minuti. La Nella console sono visualizzati messaggi di stato durante la verifica delle impostazioni. e crea il cluster.

    Se si verifica un problema con la configurazione, la console visualizza un messaggio di errore che dovrebbe essere abbastanza chiaro da consentirti di correggere di configurazione e riprova a creare il cluster.

    Per visualizzare ulteriori informazioni sul processo di creazione, fai clic su Mostra dettagli per visualizzare un riquadro laterale. Clic per chiudere i dettagli dal riquadro.

    Alla creazione del cluster viene visualizzato Stato del cluster: in esecuzione.

  2. Dopo aver creato il cluster, fai clic su Cluster rimasti torna alla pagina Cluster.

Interfaccia a riga di comando gcloud

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

  1. 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 è il OPERATION_ID dell'operazione a lunga esecuzione. Puoi scoprire lo stato dell'operazione con il seguente comando:

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

    Per creare il cluster sono necessari almeno 15 minuti. Quando il cluster puoi eseguire il comando precedente ogni tanto per visualizzare lo stato attuale.

    Una volta 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].

  2. Dopo aver creato il cluster, esegui questo comando per creare 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 con Terraform.

  1. Crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf. In questa guida, il file è denominato main.tf.

    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Verifica la risorsa Terraform del cluster utente:

    Il seguente esempio di risorsa Terraform è compilato con i valori che inserito nella tabella di pianificazione nella 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"
    }
  }
}

  3. Copia la risorsa Terraform in main.tf e salva il file.

  4. Inizializza e crea il piano Terraform:

    terraform init

    Terraform installa le librerie necessarie, ad esempio il provider Google Cloud.

  5. Rivedi la configurazione e apporta le modifiche necessarie:

    terraform plan

  6. Applica il piano Terraform per creare il cluster utente:

    terraform apply

    Quando richiesto, inserisci yes.

    Sono necessari circa 15 minuti (o più, in base alla rete) per creare il cluster utente di base e il pool di nodi.

  7. 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 del cluster utente, ad esempio:

    bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig

    TIMESTAMP nel nome del file indica la data e volta in cui è stato creato il file.

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

  8. 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

A prescindere dallo strumento utilizzato per creare il cluster utente, il tuo indirizzo email è hai concesso i criteri di controllo dell'accesso basato su ruoli (RBAC, Role-Based Access Control) che ti consentono di connetterti per il cluster con privilegi amministrativi completi. Dove si trova il tuo indirizzo email dipende dallo strumento:

  • bmctl: il tuo indirizzo email è incluso nella sezione clusterSecurity del file di configurazione utente di esempio.

  • Terraform: il tuo indirizzo email è incluso nella sezione security_config della risorsa google_gkeonprem_bare_metal_cluster di esempio.

  • Console: in qualità di creatore del cluster, il tuo indirizzo email è incluse automaticamente nella pagina Impostazioni di base del cluster nella Autorizzazione.

Anche se è specificato solo il tuo indirizzo email, puoi includere un altro indirizzo per concedere l'accesso amministrativo al cluster ad altri utenti.

I criteri RBAC concessi al tuo indirizzo email:

  • Concederti il ruolo clusterrole/cluster-admin di Kubernetes sul cluster.

  • Ti consente di accedere al cluster nella console Google Cloud utilizzando e identità di base. Puoi visualizzare il cluster Cluster GKE nella console.

  • Ti consente di eseguire i comandi kubectl sul computer locale utilizzando kubeconfig del gateway.

Per ottenere il componente kubeconfig del gateway di connessione, esegui questo comando dal computer locale:

  1. Ottieni la voce kubeconfig che può accedere al cluster tramite connetti il gateway.

    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.

  2. 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. Tu eseguirai questi comandi sulla workstation di amministrazione.

Passaggi successivi