Creazione di una workstation amministrativa

In questa pagina viene spiegato come creare una workstation di amministrazione che puoi utilizzare per installare GKE On-Prem.

In questo argomento creerai una workstation di amministrazione che ha un indirizzo IP statico. Ciò è coerente con il percorso di installazione di base, che crea cluster che utilizzano indirizzi IP statici.

Se vuoi creare una workstation di amministrazione che utilizza il protocollo DHCP (Dynamic Host Configuration Protocol) per recuperare il relativo indirizzo IP, consulta la sezione Creare una workstation di amministrazione utilizzando DHCP.

< Indietro

Panoramica

La workstation di amministrazione è una VM vSphere che contiene tutti gli strumenti necessari per creare e gestire i cluster GKE On-Prem. Per creare la workstation di amministrazione, esegui i passaggi descritti in questo argomento:

• Scarica il file Open Virtual Appliance (OVA) della workstation di amministrazione, un'immagine compressa della VM della workstation di amministrazione.
• Per importare l'OVA in vSphere come modello VM, utilizza govc, l'interfaccia a riga di comando per vSphere.
• Copia e compila i file di configurazione HashiCorp Terraform.
• Utilizza Terraform versione 0.11 per creare la VM della workstation di amministrazione.

Creazione di una chiave per l'account di servizio incluso nella lista consentita

Se non hai ancora un file della chiave JSON per il tuo account di servizio incluso nella lista consentita, creane uno ora:

1. gcloud auth login

2. gcloud iam service-accounts keys create whitelisted-key.json \
   --iam-account [ALLOWLISTED_SERVICE_ACCOUNT_EMAIL]
   

dove [ALLOWLISTED_SERVICE_ACCOUNT_EMAIL] è l'indirizzo email del tuo account di servizio incluso nella lista consentita.

Download dell'OVA della workstation di amministrazione

L'OVA della workstation di amministrazione include tutti i componenti del cluster, gli strumenti a riga di comando e le altre entità necessarie per installare e gestire i cluster GKE On-Prem.

Attiva il tuo account di servizio incluso nella lista consentita:

gcloud auth activate-service-account --key-file [KEY_ALLOWLISTED_ACCOUNT]

dove [KEY_ALLOWLISTED_ACCOUNT] è il percorso del file della chiave JSON dell'account di servizio incluso nella lista consentita.

Scarica l'ultima versione dell'OVA della workstation di amministrazione e il file di firma:

gsutil cp gs://gke-on-prem-release/admin-appliance/1.2.2-gke.2/gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2.{ova,ova.1.sig} ./

Verifica dell'OVA utilizzando openssl

Verifica il file OVA scaricato con la chiave pubblica utilizzando openssl:

openssl dgst -verify - -signature gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2.ova.1.sig gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2.ova <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

L'output previsto di questo comando è Verified OK.

Utilizzo di govc per importare l'OVA in vSphere e contrassegnarlo come modello di VM

Nelle seguenti sezioni:

1. Crea alcune variabili che dichiarano gli elementi del server vCenter e dell'ambiente vSphere.
2. Importa l'OVA della workstation di amministrazione in vSphere e contrassegnalo come modello di VM.

Creazione variabili per govc

Prima di importare l'OVA della workstation di amministrazione in vSphere, devi fornire govcalcune variabili che dichiarano gli elementi del tuo server vCenter e dell'ambiente vSphere:

Nota: puoi trovare molti di questi valori accedendo a vCenter Server.

export GOVC_URL=https://[VCENTER_SERVER_ADDRESS]/sdk
export GOVC_USERNAME=[VCENTER_SERVER_USERNAME]
export GOVC_PASSWORD=[VCENTER_SERVER_PASSWORD]
export GOVC_DATASTORE=[VSPHERE_DATASTORE]
export GOVC_DATACENTER=[VSPHERE_DATACENTER]
export GOVC_INSECURE=true

Puoi scegliere di utilizzare il pool di risorse predefinito vSphere o crearlo:

# If you want to use a resource pool you've configured yourself, export this variable:
export GOVC_RESOURCE_POOL=[VSPHERE_CLUSTER]/Resources/[VSPHERE_RESOURCE_POOL]

# If you want to use vSphere's default resource pool, export this variable instead:
export GOVC_RESOURCE_POOL=[VSPHERE_CLUSTER]/Resources

dove:

• [VCENTER_SERVER_ADDRESS] corrisponde all'indirizzo IP o al nome host del server vCenter.
• [VCENTER_SERVER_USERNAME] è il nome utente di un account che ha il ruolo Amministratore o privilegi equivalenti in vCenter Server.
• [VCENTER_SERVER_PASSWORD] è la password dell'account vCenter Server.
• [VSPHERE_DATASTORE] è il nome del datastore che hai configurato nel tuo ambiente vSphere.
• [VSPHERE_DATACENTER] è il nome del data center che hai configurato nell'ambiente vSphere.
• [VSPHERE_CLUSTER] è il nome del cluster che hai configurato nel tuo ambiente vSphere.
Per l'utilizzo di un pool di risorse non predefinito,
• [VSPHERE_RESOURCE_POOL] è il nome del pool di risorse che hai configurato per il tuo ambiente vSphere.

Creazione delle variabili per il proxy

Se utilizzi un proxy, esporta le variabili per gli indirizzi HTTP e HTTPS, dove [PROXY_ADDRESS] è l'indirizzo IP o il nome host del proxy.

export HTTP_PROXY=http://[PROXY_ADDRESS]
export HTTPS_PROXY=https://[PROXY_ADDRESS]

Importazione dell'OVA in vSphere: sensore standard

Se utilizzi uno scambio standard vSphere, importa l'OVA in vSphere utilizzando questo comando:

govc import.ova -options - gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2.ova <<EOF
{
  "DiskProvisioning": "thin",
  "MarkAsTemplate": true
}
EOF

Importazione dell'OVA in vSphere: sensore distribuito

Se utilizzi uno scambio vSphere distribuito, importa l'OVA in vSphere utilizzando questo comando, dove [YOUR_DISTRIBUTED_PORT_GROUP_NAME] è il nome del tuo gruppo di porte distribuite:

govc import.ova -options - gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2.ova <<EOF
{
  "DiskProvisioning": "thin",
  "MarkAsTemplate": true,
  "NetworkMapping": [
      {
          "Name": "VM Network",
          "Network": "[YOUR_DISTRIBUTED_PORT_GROUP_NAME]"
      }
  ]
}
EOF

Copia dei file di configurazione Terraform

Crea una directory per i file Terraform:

mkdir [TERRAFORM_DIR]

dove [TERRAFORM_DIR] è il percorso di una directory in cui vuoi conservare i tuoi file Terraform.

Copia i seguenti file TF e TFVARS e salvali rispettivamente su [TERRAFORM_DIR]/terraform.tf e [TERRAFORM_DIR]/terraform.tfvars.

Il file TF è la configurazione HCL di Terraform che esegue la creazione della VM.

I file Terraform specificati qui si applicano a una workstation di amministrazione che ha un indirizzo IP statico. Se vuoi creare una workstation di amministrazione che utilizza il protocollo DHCP per recuperarne l'indirizzo IP, utilizza i file Terraform forniti in Creazione di una workstation di amministrazione tramite DHCP.

<-- Fai clic sulla freccia di divulgazione per visualizzare i file Terraform.

terraform.tfvars

# vCenter Server username
vcenter_user = ""

# vCenter Server password
vcenter_password = ""

# vCenter Server IP or hostname
vcenter_server = ""

# Path in which the admin workstation's VM's public key should be saved
ssh_public_key_path = "~/.ssh/vsphere_workstation.pub"

# Hostname for the VM
vm_name = ""

# vSphere datastore to use for storage
datastore = ""

# vSphere datacenter in which to create the VM
datacenter = ""

# vSphere cluster in which to create the VM
cluster = ""

# vSphere resource pool in which to create VM, if you are using a non-default resource pool
# If you are using the default resource pool, provide a value like "[CLUSTER-NAME]/Resources"
resource_pool = ""

# vSphere network to use for the VM
network = ""

# Number of CPUs for this VM. Recommended minimum 4.
num_cpus = 4

# Memory in MB for this VM. Recommended minimum 8192.
memory = 8192

# The VM template (OVA) to clone. Change the version if you imported a different version of the OVA.
vm_template = "gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2"

################################################
# Static IP settings                           #
################################################

# An IPv4 static IP for the admin workstataion
ipv4_address = ""

# The netmask prefix length to use
ipv4_netmask_prefix_length = ""

# The IPv4 gateway the admin workstation should use
ipv4_gateway = ""

# Comma-delimited DNS servers
dns_nameservers = ""

terraform.tf

#########################
####### VARIABLES #######
#########################

# The following variables are declared in the accompanying TFVARS file

# vCenter Server username
variable "vcenter_user" { }

# vCenter Server password
variable "vcenter_password" { }

# vCenter Server address
variable "vcenter_server" { }

# Path in which the VM's public key should be saved
variable "ssh_public_key_path" { default = "~/.ssh/vsphere_workstation.pub" }

# vSphere network to use for the VM
variable "network" { default = "VM Network"}

# Hostname for the VM
variable "vm_name" { default = "vsphere-workstation" }

# vSphere datacenter in which to create the admin workstation VM
variable "datacenter" { }

# vSphere datastore to use for storage
variable "datastore" { }

# vSphere cluster in which to create the VM
variable "cluster" { }

# vSphere resource pool in which to create the VM
variable "resource_pool" { }

# Number of CPUs for this VM. Recommended minimum 4.
variable "num_cpus" { default = 4 }

# Memory in MB for this VM. Recommended minimum 8192.
variable "memory" { default = 8192 }

# The VM template (OVA) to clone
variable "vm_template" { }

# The IP address to assign to the VM
variable "ipv4_address" { }

# Netmask prefix length
variable "ipv4_netmask_prefix_length" { }

# Default gateway to use
variable "ipv4_gateway" { }

# DNS resolvers to use
variable "dns_nameservers" { }

##########################
##########################

provider "vsphere" {
  version        = "1.15"
  user           = "${var.vcenter_user}"
  password       = "${var.vcenter_password}"
  vcenter_server = "${var.vcenter_server}"

  # if you have a self-signed cert
  allow_unverified_ssl = true
}

### vSphere Data ###

data "vsphere_datastore" "datastore" {
  name          = "${var.datastore}"
  datacenter_id = "${data.vsphere_datacenter.dc.id}"
}

data "vsphere_datacenter" "dc" {
  name = "${var.datacenter}"
}

data "vsphere_compute_cluster" "cluster" {
  name          = "${var.cluster}"
  datacenter_id = "${data.vsphere_datacenter.dc.id}"
}

data "vsphere_resource_pool" "pool" {
  name          = "${var.resource_pool}"
  datacenter_id = "${data.vsphere_datacenter.dc.id}"
}

data "vsphere_network" "network" {
  name          = "${var.network}"
  datacenter_id = "${data.vsphere_datacenter.dc.id}"
}

data "vsphere_virtual_machine" "template_from_ovf" {
  name          = "${var.vm_template}"
  datacenter_id = "${data.vsphere_datacenter.dc.id}"
}

##########################
### IF USING STATIC IP ###
##########################
data "template_file" "static_ip_config" {
  template = <<EOF
network:
  version: 2
  ethernets:
    ens192:
      dhcp4: no
      dhcp6: no
      addresses: ["${var.ipv4_address}/${var.ipv4_netmask_prefix_length}"]
      gateway4: ${var.ipv4_gateway}
      nameservers:
        addresses: [${var.dns_nameservers}]
EOF
}

data "template_file" "user_data" {
  template = <<EOF
#cloud-config
apt:
  primary:
    - arches: [default]
      uri: http://us-west1.gce.archive.ubuntu.com/ubuntu/
write_files:
  - path: /tmp/static-ip.yaml
    permissions: '0644'
    encoding: base64
    content: |
      $${static_ip_config}
runcmd:
  - /var/lib/gke/guest-startup.sh
EOF
  vars = {
    static_ip_config = "${base64encode(data.template_file.static_ip_config.rendered)}"

  }
}
##########################
### IF USING STATIC IP ###
##########################

### vSphere Resources ###

resource "vsphere_virtual_machine" "vm" {
  name             = "${var.vm_name}"
  resource_pool_id = "${data.vsphere_resource_pool.pool.id}"
  datastore_id     = "${data.vsphere_datastore.datastore.id}"
  num_cpus         = "${var.num_cpus}"
  memory           = "${var.memory}"
  guest_id         = "${data.vsphere_virtual_machine.template_from_ovf.guest_id}"
  enable_disk_uuid = "true"
  scsi_type = "${data.vsphere_virtual_machine.template_from_ovf.scsi_type}"
  network_interface {
    network_id   = "${data.vsphere_network.network.id}"
    adapter_type = "${data.vsphere_virtual_machine.template_from_ovf.network_interface_types[0]}"
  }

  wait_for_guest_net_timeout = 15

  nested_hv_enabled = false
  cpu_performance_counters_enabled = false

  disk {
    label            = "disk0"
    size             = "${max(50, data.vsphere_virtual_machine.template_from_ovf.disks.0.size)}"
    eagerly_scrub    = "${data.vsphere_virtual_machine.template_from_ovf.disks.0.eagerly_scrub}"
    thin_provisioned = "${data.vsphere_virtual_machine.template_from_ovf.disks.0.thin_provisioned}"
  }

  cdrom {
    client_device = true
  }

  vapp {
    properties = {
      hostname    = "${var.vm_name}"
      public-keys = "${file(var.ssh_public_key_path)}"
      user-data   = "${base64encode(data.template_file.user_data.rendered)}"
    }
  }

  clone {
    template_uuid = "${data.vsphere_virtual_machine.template_from_ovf.id}"
  }
}

output "ip_address" {
  value = "${vsphere_virtual_machine.vm.default_ip_address}"
}

Creazione di una chiave SSH

Crea una chiave SSH, in modo da poterti connettere alla workstation di amministrazione dal laptop o dalla workstation locale. Sui sistemi operativi basati su Linux, puoi utilizzare ssh-keygen:

ssh-keygen -t rsa -f ~/.ssh/vsphere_workstation -N ""

Modifica del file TFVARS

Apri terraform.tfvars in un editor di testo e fornisci i valori per le seguenti variabili. Puoi trovare molti di questi valori accedendo al client vCenter:

vcenter_user

Fornisci un account utente vCenter Server come stringa. L'account utente deve avere il ruolo Amministratore o privilegi equivalenti (consulta i requisiti vSphere).

Ad esempio:

vcenter_user = "[e-mail]"

vcenter_password

Fornisci la password dell'account utente vCenter Server come stringa. Ad esempio:

vcenter_password = "#STyZ2T#Ko2o"

vcenter_server

Fornisci il tuo indirizzo vCenter Server (IP o nome host) come stringa. Ad esempio:

vcenter_server = "198.51.100.2"

ssh_public_key_path

Fornisci il percorso della chiave pubblica SSH. L'hai creato nel passaggio precedente:

ssh_public_key_path = "~/.ssh/vsphere_workstation.pub"

vm_name

Specifica un nome a tua scelta per la workstation di amministrazione. Ad esempio:

vm_name = "my-admin-workstation"

datastore

Fornisci il nome del tuo datastore vSphere come stringa. Ad esempio:

datastore = "MY-DATASTORE"

datacenter

Fornisci il nome del tuo data center vSphere come stringa. Ad esempio:

datacenter = "MY-DATACENTER"

cluster

Fornisci il nome del cluster vSphere come stringa. Ad esempio,

cluster = "MY-CLUSTER"

resource_pool

Se utilizzi un pool di risorse non predefinito, fornisci il nome del pool di risorse vSphere come stringa. Ad esempio:

resource_pool = "MY-POOL"

Se utilizzi il pool di risorse predefinito, fornisci il seguente valore:

resource_pool = "[MY_CLUSTER]/Resources"

dove [MY_CLUSTER] è il nome del cluster vSphere.

Consulta Specificare il pool di risorse root per un host autonomo.

network

Fornisci la rete vSphere in cui vuoi creare la tua workstation di amministrazione, sotto forma di stringa. Ad esempio:

network = "MY-VM-NETWORK"

vm_template

Fornisci il nome del modello VM come stringa. Hai creato l'OVA e lo hai contrassegnato come modello in un passaggio precedente. Tieni presente che il nome del modello non ha l'estensione .ova.

vm_template = "gke-on-prem-admin-appliance-vsphere-1.2.2-gke.2"

ipv4_address

Fornisci un indirizzo IP statico IPv4 per la workstation di amministrazione. Ad esempio:

ipv4_address = "203.0.113.1"

ipv4_netmask_prefix_length

Fornisci il numero di bit nella subnet mask della rete in cui vuoi creare la workstation di amministrazione. Ad esempio:

ipv4_netmask_prefix_length = "22"

ipv4_gateway

Fornisci l'indirizzo IP del gateway predefinito della subnet in cui deve essere creata la workstation di amministrazione. Ad esempio:

ipv4_gateway = "198.51.100.1

dns_nameservers

Fornisci i server dei nomi DNS che devono essere utilizzati dalla workstation di amministrazione, separati da virgole. Ad esempio:

dns_nameservers = "8.8.8.8,8.8.4.4"

Creazione della workstation di amministrazione

Ora puoi iniziare a creare la VM della workstation di amministrazione. Utilizza Terraform versione 0.11 per i passaggi di questa sezione.

1. Vai alla directory che contiene i file di configurazione Terraform (TF e TFVARS):

2. Inizializza Terraform nella directory e applica la configurazione. L'operazione potrebbe richiedere alcuni minuti:

   terraform init && terraform apply -auto-approve -input=false

   Nota: il nome del file TFVARS deve essere terraform.tfvars. Altrimenti, devi passare il parametro --var-file e specificare il file TFVARS.

SSH nella workstation di amministrazione

1. Vai alla directory che contiene i file di configurazione Terraform.

2. Recupera l'indirizzo IP della workstation di amministrazione:

   terraform output ip_address

   Prendi nota dell'indirizzo IP della workstation di amministrazione.

3. Accedi alla workstation mediante SSH usando la chiave SSH e l'indirizzo IP.

   ssh -i ~/.ssh/vsphere_workstation ubuntu@[ADMIN_WORKSTATION_IP_ADDRESS]
   

Verifica che la workstation di amministrazione sia configurata correttamente

Verifica che gkectl e docker siano installati sulla tua workstation di amministrazione:

gkectl version
docker version

Configurazione del server NTP sulla workstation di amministrazione

Per impostazione predefinita, la workstation di amministrazione utilizza ntp.ubuntu.com come server Network Time Protocol (NTP). Se la tua organizzazione utilizza un server di tempo diverso, configura la workstation di amministrazione in modo che utilizzi lo stesso server NTP del resto dell'organizzazione.

Inserisci i comandi seguenti per configurare il server NTP sulla tua workstation di amministrazione:

sudo mkdir -p /etc/systemd/timesyncd.conf.d/

sudo bash -c "cat >> /etc/systemd/timesyncd.conf.d/cloud-init.conf" << EOF
[Time]
NTP=[NTP_SERVER]
EOF

sudo systemctl restart systemd-timesyncd
timedatectl status

dove [NTP_SERVER] è il nome host o l'indirizzo IP del server NTP.

Per verificare che il server NTP funzioni, inserisci il seguente comando:

timedatectl

L'output è simile al seguente:

                      Local time: Tue 2019-12-17 00:21:50 UTC
                  Universal time: Tue 2019-12-17 00:21:50 UTC
                        RTC time: Tue 2019-12-17 00:21:50
                       Time zone: Etc/UTC (UTC, +0000)
       System clock synchronized: yes
systemd-timesyncd.service active: yes
                 RTC in local TZ: no

< Indietro Avanti >

Risolvere i problemi

openssl non può convalidare l'OVA della workstation di amministrazione

Sintomi

L'esecuzione di openssl dgst nel file OVA della workstation di amministrazione non restituisce Verified OK

Potenziali cause

Nel file OVA è presente un problema che impedisce una convalida riuscita.

Risoluzione

Prova a scaricare e a eseguire il deployment dell'OVA della workstation di amministrazione, come indicato nell'articolo Scaricare l'OVA della workstation di amministrazione. Se il problema persiste, contatta Google per ricevere assistenza.

Per ulteriori informazioni, consulta la sezione Risoluzione dei problemi.

< Indietro Avanti >