Kubernetes - wdrożenie klastra na Azure przy użyciu Terraform i Azure CLI
Podziel się

Poniżej wyjaśnię, jak przygotować klaster Kubernetes na platformie Azure nazywany Azure Kubernetes Service przy użyciu Terraform oraz Azure CLI.

Jako usługa Azure, Azure Kubernetes Service jest w pełni odpowiedzialny za zarządzanie klastrem, dzięki czemu możemy wykorzystywać zalety platformy, takie jak:

  • zarządzanie poprzez API,
  • administracja certyfikatami,
  • skalowanie,
  • szybka aktualizacja.

Klaster Kubernetosowy na portalu Azure można zainstalować między innymi na trzy sposoby:

  • poprzez interfejs webowy (https://portal.azure.com),
  • Azure Command Line,
  • klaster jako kod używając narzędzia np. Terraform.

Instalacja klastra Kubernetes w Azure z wykorzystaniem narzędzia CLI

Przygotowanie środowiska – instalacja Azure CLI

Zanim rozpoczniemy właściwą konfigurację należy przygotować środowisko, na którym pracujemy poprzez instalację Azure CLI. Instrukcję instalacji Azure CLI znajdziesz tu: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli

Wykorzystując Azure CLI, zaloguj się do swojego konta:

$az login

Polecenie to otworzy okno w przeglądarce celem potwierdzenia poświadczeń oraz uprawnień.

Jednym ze sposobów ręcznej instalacji klastra Kubernetes w Azure jest wykorzystanie narzędzia CLI, które nie wymaga dodatkowego oprogramowania do zarządzania zasobami Azure. Przejdziemy przez ten proces, aby dowiedzieć się jakie usługi oraz zasoby są niezbędne do stworzenia klastra.

Sprawdźmy jak to można zrobić i co jest nam potrzebne:

$az aks create --help

Wywołana komenda wylistuje nam wszystkie możliwe argumenty – wymagane oraz dodatkowe. Na końcu listy otrzymamy również przykłady, na których możemy się wzorować. Jak zauważmy wymaganymi argumentami do stworzenia klastra Kubernetes są name oraz resource-group. W przypadku name podajemy nazwę naszego nowego klastra, który ma zostać stworzony. Dla resource-group musimy podjąć działanie, aby taką grupę stworzyć przed konfiguracją.

Tworzenie resource-group

W celu stworzenia resource-group wystarczy podać nazwę oraz lokalizację, w której ma zostać stworzona. Aby wybrać dla siebie odpowiednią lokalizację można wylistować wszystkie możliwe:

$az account list-locations -o table

Tworzenie resource group:

az group create --name aks-cluster --location eastus2

Po stworzeniu grupy powinniśmy zobaczyć w wyniku polecenia:

…
"provisioningState": "Succeeded"
…

Rejestracja serwisu i nadanie uprawnień

Kolejnym krokiem jest zarejestrowanie naszego serwisu oraz nadanie mu uprawnień:

$az provider register -n Microsoft.ContainerService

Ostatnim krokiem jest stworzenie klastra Kubernetes:

$az aks create -g aks-cluster -n k8s-cluster --generate-ssh-keys --node-count 2

Argument –generate-ssh-keys jest wymagany jeśli nie podajemy własnego klucza ssh. Argument –node-cout jest wymagany jeśli chcemy mieć pewność, że ilość węzłów nie przekroczy naszego założonego limitu.

Przygotowanie klastra może trwać do 15 min.

Po wykonaniu możemy sprawdzić, czy został stworzony:

$az aks show -n k8s-cluster -g aks-cluster

Instalacja kubectl do zarządzania klastrem

Do zarządzania klastrem niezbędne będzie instalacja narzędzia kubectl. Pomoc w instalacji można znaleźć na stronie: https://kubernetes.io/docs/tasks/tools/

Ostatnim elementem jest stworzenie pliku konfiguracyjnego dla kubectl:

$az aks get-credentials -n k8s-cluster -g aks-cluster 

Polecenie to stworzy plik config w katalogowym użytkownika, z którego narzędzie kubectl będzie pobierać dane do autoryzacji.

Jeśli wszystkie kroki zostały zakończone sukcesem po możemy sprawdzić, czy mamy połączenie z naszym klastrem przykładowo poprzez wylistowanie węzłów:

$kubectl get nodes
NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-28836717-vmss000000   Ready    agent   8m49s   v1.20.9
aks-nodepool1-28836717-vmss000001   Ready    agent   8m14s   v1.20.9

Aby usunąć klaster, użyj komendy:

$az aks delete -g aks-cluster -n k8s-cluster 

Kubernetes – instalacja klastra z użyciem Terraform

Zamiast pisania oraz stworzenia infrastruktury ręcznie możemy użyć narzędzia Terraform, aby ten proces zautomatyzować. Do tego celu definiujemy plan, według którego nasze środowisko zostanie przygotowane. Dodatkowo możemy przygotować model CI/CD do łatwiejszego zarządzaniem środowiska DEV/TEST/PROD.

Nasz plan w formie kodu będę trzymał w GitLab oraz wykorzystam GitLab-ci do przeprowadzenia instalacji automatycznie.

Tworzenie roli z dostępem do subskrypcji w Azure

Przed przystąpieniem do instalacji klastra z użyciem Terraform w powinniśmy stworzyć odpowiednią rolę z dostępem do naszej subskrypcji w Azure. Dla celów tego artykułu wykorzystam rolę Contributor.

$az ad sp create-for-rbac \
  --role="Contributor" \
  --scopes="/subscriptions/SUBSCRIPTION_ID"

W celu uzyskania SUBSCRIPTION_ID możesz użyć komendy:

$az account list |  grep -oP '(?<="id": ")[^"]*'

Po stworzeniu roli otrzymamy wynik w postaci JSON (zamiast zer pojawią się prawidłowe dane):

{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "azure-cli-2021-11-16-09-37-26",
  "name": "81e35a03-f0a1-4de3-b4ce-cfb03f65ff69",
  "password": "00000000-0000-0000-0000-000000000000",
  "tenant": "00000000-0000-0000-0000-000000000000"
}

Zapisz appid, password oraz tetant. Będą one potrzebne w dalszych krokach.

Jako że powyższe dane są danymi wrażliwymi, nie wprowadzaj ich czystym tekstem do kodu. W naszym wypadku zapiszemy je jako dane wrażliwe w GitLab, aby móc się do nich odwoływać podczas tworzenia środowiska.

Kubernetes Azure CLI Terraform

Tworzenie Storage Account

Dodatkowym krokiem jest stworzenie Storage Account, w którym trzymane będą pliki tfstate

$az storage account create -g aks-cluster -n k8steststorage

Przygotowanie kodu dla Terraform zaczynamy od storzenia pliku provider.tf w ktorym zostną umieszczone dane, z jakich źródeł będziemy korzystać oraz wskazanie lokalizacji pliku tfstate.

provider "azurerm" {
    features {}  
    tenant_id      	= var.tenant_id
    subscription_id 	= var.subscription_id
}

terraform {
  backend "azurerm" {
    resource_group_name	  = "labexapmple"
    storage_account_name  = "labtestaks"
    container_name	  = "tfstate"
    key                   = "terraform.tfstate"
  }
}

Kolejnym plikiem jest main.tf, w którym umieszczamy dane, które następnie zostaną przez Terraform przetłumaczone i wdrożone:

resource "azurerm_resource_group" "aks-rg" {
  name     	= var.aks-rg
  location 	= var.location
}

resource "azurerm_kubernetes_cluster" "aks-cluster" {
  name                  = "aks-${var.env}"
  location           	= azurerm_resource_group.aks-rg.location
  resource_group_name 	= azurerm_resource_group.aks-rg.name
  dns_prefix          	= var.env

  default_node_pool {
    name      		= "${var.env}pool"
    node_count 		= var.node_count_in
    vm_size    		= var.vm_size_in
  }
  service_principal {
    client_id     	= var.client_id
    client_secret 	= var.client_secret
  }
  tags = {
    Environment 	= terraform.workspace  }
}

Utwórzmy również plik var.tf, w którym wprowadzamy zmienne, które będą definiować nazwy oraz wielkość naszego środowiska:

variable "location" {
    default = "East US 2"
}

variable "client_id" {}

variable "client_secret" {}

variable "subscription" {}

variable "tenant_id" {}

variable "storage_name" {
    default = " k8steststorage"
}

variable "sc_name" {
    default = "terraform-state"
}

variable "node_count" {
    default = 2
}

variable "vm_size" {
    default = "Standard_D2_v2"
}

W celu uzyskania pliku konfiguracyjnego dla kubectl potrzebny jest również output.tf:

 output "kube_config" {
    value 	= azurerm_kubernetes_cluster.aks-cluster.kube_config_raw
    sensitive 	= true
}

GitLab-ci – wdrożenie

Mając przygotowany zestaw plików dla Terraform możemy przystąpić do ostatniego kroku, jakim jest wdrożenie GitLab-ci do naszego modelu. Stwórzmy plik .gitlab-ci.yml:

image:
  name: hashicorp/terraform:1.0.7
  entrypoint:
    - '/usr/bin/env'
    - 'PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'

before_script:
  - rm -rf .terraform
  - terraform --version
  - terraform init
  - terraform workspace new $CI_COMMIT_BRANCH
  - terraform workspace select $CI_COMMIT_BRANCH

stages:
  - validate
  - plan
  - apply
  - deploy
validate:
  stage: validate
  script:
    - terraform validate

plan:
  stage: plan
  script:
    - terraform plan -out="tfplan"  -var="client_id=$ARM_CLIENT_ID" -var="client_secret=$ARM_CLIENT_SECRET" -var="subscription_id=$ARM_SUBSCRIPTION_ID" -var="tenant_id=$ARM_TENANT_ID"
  dependencies:
    - validate
  artifacts:
    paths:
      - ./tfplan

apply:
  stage: apply
  script:
    - terraform apply -input=false "tfplan"
  dependencies:
    - plan

Powyższy schemat do wdrożenia klastra wykorzysta kontener Terraform pobierając z platformy Docker Hub (wersja może być różna). Podzieli również implementację na sekcje – przygotowania środowiska, przygotowanie planu wdrożenia oraz samo wdrożenie.

Powyższy schemat również będzie wrażliwy na gałąź, z jakiej GitLab-ci będzie uruchamiany. Dzięki temu w łatwy sposób możemy przygotować wersję DEV/TEST/PROD i w szybki sposób wykonać promocję środowiska.

Aby dostać się do klastra Kubernetes niezbędny będzie nam plik konfiguracyjny, który możemy pobrać, poprzez wykorzystanie Azure CLI lub z użyciem Terraform Output. Posiadając pliki z repozytorium na własnej maszynie, możemy go pobrać i zapisać, wykonując polecenie znajdujące się w katalogu z kodem:

$terraform output kube_config > ~.kube/config

Wdrożenie klastra Kubernetes na Azure przy użyciu Terraform oraz Azure CLI – podsumowanie

Powyższe przykłady wdrożenia oczywiście można dodatkowo rozbudować, tak aby uzyskać środowisko, które najbardziej nam odpowiada. Jak widać na tym przykładzie wdrożenie klastra Azure Kubernetes Service jest niezwykle łatwe, a z wcześniej przygotowanym planem Terraform niewielkim kosztem można zarządzać klastrem i dostrajać go według własnych potrzeb.

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany.

    Skontaktuj się z nami