Créer un poste de travail administrateur

Cette page explique comment créer un poste de travail administrateur permettant d'installer GKE On-Prem.

Dans cette rubrique, vous allez créer un poste de travail administrateur disposant d'une adresse IP statique. Ceci est conforme au processus d'installation de base qui crée des clusters utilisant des adresses IP statiques.

Si vous souhaitez créer un poste de travail administrateur utilisant le protocole DHCP (Dynamic Host Configuration Protocol) pour obtenir son adresse IP, consultez la section Créer un poste de travail administrateur via DHCP.

< Précédent

Présentation

Le poste de travail administrateur est une VM vSphere qui contient tous les outils dont vous avez besoin pour créer et gérer des clusters GKE On-Prem. Pour créer le poste de travail administrateur, procédez comme suit :

• Téléchargez le fichier Open Virtual Appliance (OVA) du poste de travail administrateur. Il s'agit d'une image compressée de la VM du poste de travail administrateur.
• Utilisez govc, l'interface de ligne de commande dans vSphere, pour importer le fichier OVA dans vSphere en tant que modèle de VM.
• Copiez et remplissez les fichiers de configuration HashiCorp Terraform.
• Utilisez la version 0.11 de Terraform pour créer la VM du poste de travail administrateur.

Créer une clé pour votre compte de service sur liste d'autorisation

Si vous ne possédez pas encore de fichier de clé JSON pour votre compte de service sur liste d'autorisation, créez-en un maintenant :

1. gcloud auth login

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

où [ALLOWLISTED_SERVICE_ACCOUNT_EMAIL] est l'adresse e-mail de votre compte de service sur liste d'autorisation.

Télécharger le fichier OVA du poste de travail administrateur

Le fichier OVA du poste de travail administrateur inclut tous les composants du cluster, les outils de ligne de commande, ainsi que toutes les autres entités nécessaires à l'installation et à la gestion des clusters GKE On-Prem.

Activez votre compte de service sur liste d'autorisation :

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

où [KEY_ALLOWLISTED_ACCOUNT] est le chemin d'accès du fichier de clé JSON pour votre compte de service sur liste d'autorisation.

Téléchargez la dernière version du fichier OVA du poste de travail administrateur et son fichier de signature :

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} ./

Vérifier le fichier OVA avec openssl

Vérifiez le fichier OVA téléchargé par rapport à la clé publique à l'aide de 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

Le résultat attendu de cette commande est Verified OK.

Utiliser govc pour importer le fichier OVA dans vSphere et le marquer comme modèle de VM

Dans les sections suivantes, vous allez :

1. créer des variables déclarant les éléments de votre environnement vSphere et vCenter Server ;
2. importer l'OVA du poste de travail d'administrateur dans vSphere et le marquer comme modèle de VM.

Créer des variables pour govc

Avant d'importer le fichier OVA du poste de travail administrateur dans vSphere, vous devez fournir à govc certaines variables déclarant les éléments de votre environnement vSphere et vCenter Server.

Remarque : Vous pouvez trouver un grand nombre de ces valeurs en vous connectant à 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

Vous pouvez choisir d'utiliser le pool de ressources par défaut de vSphere ou créer le vôtre :

# 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

où :

• [VCENTER_SERVER_ADDRESS] est le nom d'hôte ou l'adresse IP de votre serveur vCenter ;
• [VCENTER_SERVER_USERNAME] est le nom d'utilisateur d'un compte détenant le rôle d'administrateur ou des droits équivalents dans le serveur vCenter ;
• [VCENTER_SERVER_PASSWORD] est le mot de passe du compte serveur vCenter ;
• [VSPHERE_DATASTORE] est le nom du datastore que vous avez configuré dans votre environnement vSphere ;
• [VSPHERE_DATACENTER] est le nom du centre de données que vous avez configuré dans votre environnement vSphere ;
• [VSPHERE_CLUSTER] est le nom du cluster que vous avez configuré dans votre environnement vSphere.
Pour utiliser un pool de ressources autre que celui par défaut,
• [VSPHERE_RESOURCE_POOL] est le nom du pool de ressources que vous avez configuré dans votre environnement vSphere.

Créer des variables pour votre proxy

Si vous utilisez un proxy, exportez les variables correspondant à l'adresse HTTP et HTTPS, où [PROXY_ADDRESS] est le nom d'hôte ou l'adresse IP du proxy :

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

Importer le fichier OVA dans vSphere : commutateur standard

Si vous utilisez un commutateur standard vSphere, importez le fichier OVA dans vSphere à l'aide de la commande suivante :

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

Importer le fichier OVA dans vSphere : commutateur distribué

Si vous utilisez un commutateur distribué vSphere, importez le fichier OVA dans vSphere à l'aide de cette commande, où [YOUR_DISTRIBUTED_PORT_GROUP_NAME] est le nom de votre groupe de ports distribué :

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

Copier les fichiers de configuration Terraform

Créez un répertoire pour vos fichiers Terraform :

mkdir [TERRAFORM_DIR]

où [TERRAFORM_DIR] est le chemin d'accès au répertoire dans lequel vous souhaitez conserver vos fichiers Terraform.

Copiez les fichiers TF et TFVARS suivants, puis enregistrez-les dans [TERRAFORM_DIR]/terraform.tf et [TERRAFORM_DIR]/terraform.tfvars, respectivement.

Le fichier TF est la configuration HCL de Terraform qui effectue la création de la VM.

Les fichiers Terraform présentés ici s'appliquent à un poste de travail administrateur disposant d'une adresse IP statique. Si vous souhaitez créer un poste de travail administrateur utilisant DHCP pour obtenir son adresse IP, utilisez les fichiers Terraform fournis dans la section Créer un poste de travail administrateur via DHCP.

<-- Cliquez sur la flèche d'affichage pour afficher les fichiers 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}"
}

Créer une clé SSH

Créez une clé SSH pour pouvoir vous connecter en SSH au poste de travail administrateur depuis votre ordinateur portable ou votre poste de travail local. Sur les systèmes d'exploitation Linux, vous pouvez utiliser ssh-keygen :

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

Modifier le fichier TFVARS

Ouvrez terraform.tfvars dans un éditeur de texte et fournissez des valeurs pour les variables suivantes. Vous pouvez trouver un grand nombre de ces valeurs en vous connectant au client vCenter :

vcenter_user

Fournissez un compte utilisateur de serveur vCenter sous forme de chaîne. Le compte utilisateur doit disposer du rôle d'administrateur ou de privilèges équivalents (voir les exigences concernant vSphere).

Exemple :

vcenter_user = "[e-mail]"

vcenter_password

Indiquez le mot de passe du compte utilisateur de serveur vCenter sous forme de chaîne. Exemple :

vcenter_password = "#STyZ2T#Ko2o"

vcenter_server

Indiquez l'adresse (IP ou nom d'hôte) de votre serveur vCenter sous forme de chaîne. Exemple :

vcenter_server = "198.51.100.2"

ssh_public_key_path

Indiquez le chemin d'accès à la clé publique SSH que vous avez créée lors d'une étape précédente :

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

vm_name

Indiquez le nom de votre choix pour le poste de travail administrateur. Exemple :

vm_name = "my-admin-workstation"

datastore

Indiquez le nom de votre datastore vSphere sous forme de chaîne. Exemple :

datastore = "MY-DATASTORE"

datacenter

Indiquez le nom de votre centre de données vSphere sous forme de chaîne. Exemple :

datacenter = "MY-DATACENTER"

cluster

Indiquez le nom de votre cluster vSphere sous forme de chaîne. Exemple :

cluster = "MY-CLUSTER"

resource_pool

Si vous utilisez un pool de ressources différent de celui par défaut, indiquez le nom de votre pool de ressources vSphere sous forme de chaîne. Exemple :

resource_pool = "MY-POOL"

Si vous utilisez le pool de ressources par défaut, indiquez la valeur suivante :

resource_pool = "[MY_CLUSTER]/Resources"

où [MY_CLUSTER] est le nom de votre cluster vSphere.

Consultez la section Spécifier le pool de ressources racine pour un hôte autonome.

network

Indiquez sous forme de chaîne le réseau vSphere sur lequel vous souhaitez créer votre poste de travail d'administrateur. Exemple :

network = "MY-VM-NETWORK"

vm_template

Indiquez le nom du modèle de VM sous forme de chaîne. Vous avez créé/importé le fichier OVA et l'avez marqué comme modèle lors d'une étape précédente. Notez que le nom du modèle ne comporte pas l'extension .ova.

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

ipv4_address

Indiquez une adresse IP statique IPv4 pour le poste de travail administrateur. Exemple :

ipv4_address = "203.0.113.1"

ipv4_netmask_prefix_length

Indiquez le nombre de bits dans le masque de sous-réseau du réseau sur lequel vous souhaitez créer votre poste de travail administrateur. Exemple :

ipv4_netmask_prefix_length = "22"

ipv4_gateway

Indiquez l'adresse IP de la passerelle par défaut du sous-réseau dans lequel le poste de travail administrateur doit être créé. Exemple :

ipv4_gateway = "198.51.100.1

dns_nameservers

Fournissez des serveurs de noms DNS à utiliser par le poste de travail administrateur, séparés par des virgules. Exemple :

dns_nameservers = "8.8.8.8,8.8.4.4"

Créer le poste de travail administrateur

Vous êtes maintenant prêt à créer la VM du poste de travail administrateur. Utilisez la version 0.11 de Terraform pour les étapes de cette section.

1. Accédez au répertoire qui contient vos fichiers de configuration Terraform (TF et TFVARS) :

2. Initialisez Terraform dans le répertoire et appliquez la configuration. Cela peut prendre quelques minutes.

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

   Remarque : Le nom du fichier TFVARS doit être terraform.tfvars. Sinon, vous devez transmettre le paramètre --var-file et spécifier le fichier TFVARS.

Se connecter en SSH au poste de travail administrateur

1. Accédez au répertoire contenant vos fichiers de configuration Terraform.

2. Récupérez l'adresse IP du poste de travail administrateur :

   terraform output ip_address

   Notez l'adresse IP du poste de travail administrateur.

3. Connectez-vous en SSH au poste de travail administrateur à l'aide de votre clé SSH et de l'adresse IP :

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

Vérifier la bonne configuration du poste de travail administrateur

Vérifiez que gkectl et docker sont installés sur votre poste de travail administrateur :

gkectl version
docker version

Configurer le serveur NTP sur votre poste de travail administrateur

Par défaut, le poste de travail administrateur utilise ntp.ubuntu.com comme serveur NTP (Network Time Protocol). Si votre organisation utilise un autre serveur de temps, configurez votre poste de travail administrateur pour qu'il utilise le même serveur NTP que le reste de votre organisation.

Saisissez les commandes suivantes pour configurer le serveur NTP sur votre poste de travail administrateur :

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

où [NTP_SERVER] est le nom d'hôte ou l'adresse IP de votre serveur NTP.

Pour vérifier que votre serveur NTP fonctionne, saisissez la commande suivante :

timedatectl

Le résultat est semblable à ceci :

                      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

< Précédent Suivant >

Dépannage

openssl ne peut pas valider le fichier OVA du poste de travail administrateur.

Symptômes

L'exécution de openssl dgst sur le fichier OVA du poste de travail administrateur ne renvoie pas Verified OK.

Causes probables

Le fichier OVA comporte un problème qui empêche la validation.

Solution

Essayez à nouveau de télécharger et de déployer le fichier OVA du poste de travail administrateur, comme indiqué dans la section Télécharger le fichier OVA du poste de travail administrateur. Si le problème persiste, contactez Google pour obtenir de l'aide.

Pour en savoir plus, consultez la section Dépannage.

< Précédent Suivant >