Udostępnij za pośrednictwem

Samouczek: konfigurowanie sieci kubenet w usłudze Azure Kubernetes Service (AKS) przy użyciu rozwiązania Ansible

  • Artykuł

Ważne

Rozwiązanie Ansible w wersji 2.8 (lub nowszej) jest wymagane do uruchomienia przykładowych podręczników w tym artykule.

Usługa Azure Kubernetes Service (AKS) ułatwia wdrażanie zarządzanego klastra Kubernetes na platformie Azure. Usługa AKS zmniejsza złożoność i nakłady operacyjne związane z zarządzaniem rozwiązaniem Kubernetes, przenosząc znaczną część tej odpowiedzialności na platformę Azure. Jako hostowana usługa Kubernetes, platforma Azure obsługuje krytyczne zadania, takie jak monitorowanie kondycji i konserwacja. Wzorce rozwiązania Kubernetes są zarządzane przez platformę Azure. Zarządzasz tylko węzłami agentów i obsługujesz je. Jako zarządzana usługa Kubernetes usługa AKS jest bezpłatna — płacisz tylko za węzły agenta w klastrach; nie dla mistrzów.

Za pomocą usługi AKS można wdrożyć klaster przy użyciu następujących modeli sieciowych:

  • Sieć Kubenet — zasoby sieciowe są zwykle tworzone i konfigurowane jako klaster usługi AKS jest wdrażany.
  • Sieć usługi Azure Container Networking Interface (CNI) — klaster usługi AKS jest połączony z istniejącymi zasobami i konfiguracjami sieci wirtualnej.

Aby uzyskać więcej informacji na temat sieci w aplikacjach w usłudze AKS, zobacz Pojęcia dotyczące sieci dla aplikacji w usłudze AKS.

W tym artykule omówiono sposób wykonywania następujących zadań:

  • Tworzenie klastra AKS
  • Konfigurowanie sieci usługi Azure Kubenet

Wymagania wstępne

  • Subskrypcja platformy Azure: jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • Jednostka usługi platformy Azure: Utwórz jednostkę usługi, zanotuj następujące wartości: appId, displayName, password i tenant.

Tworzenie sieci wirtualnej i podsieci

Kod podręcznika w tej sekcji tworzy następujące zasoby platformy Azure:

  • Sieć wirtualna
  • Podsieć w ramach sieci wirtualnej

Zapisz następujący podręcznik jako vnet.yml:

- name: Create vnet
  azure_rm_virtualnetwork:
      resource_group: "{{ resource_group }}"
      name: "{{ name }}"
      address_prefixes_cidr:
          - 10.0.0.0/8

- name: Create subnet
  azure_rm_subnet:
      resource_group: "{{ resource_group }}"
      name: "{{ name }}"
      address_prefix_cidr: 10.240.0.0/16
      virtual_network_name: "{{ name }}"
  register: subnet

Tworzenie klastra usługi AKS w sieci wirtualnej

Kod podręcznika w tej sekcji tworzy klaster usługi AKS w sieci wirtualnej.

Zapisz następujący podręcznik jako aks.yml:

- name: List supported kubernetes version from Azure
  azure_rm_aks_version:
      location: "{{ location }}"
  register: versions

- name: Create AKS cluster with vnet
  azure_rm_aks:
      resource_group: "{{ resource_group }}"
      name: "{{ name }}"
      dns_prefix: "{{ name }}"
      kubernetes_version: "{{ versions.azure_aks_versions[-1] }}"
      agent_pool_profiles:
        - count: 3
          name: nodepool1
          vm_size: Standard_D2_v2
          vnet_subnet_id: "{{ vnet_subnet_id }}"
      linux_profile:
          admin_username: azureuser
          ssh_key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"
      service_principal:
          client_id: "{{ lookup('ini', 'client_id section=default file=~/.azure/credentials') }}"
          client_secret: "{{ lookup('ini', 'secret section=default file=~/.azure/credentials') }}"
      network_profile:
          network_plugin: kubenet
          pod_cidr: 192.168.0.0/16
          docker_bridge_cidr: 172.17.0.1/16
          dns_service_ip: 10.0.0.10
          service_cidr: 10.0.0.0/16
  register: aks

Poniżej przedstawiono kilka kluczowych uwag, które należy wziąć pod uwagę podczas pracy z przykładowym podręcznikiem:

  • Użyj azure_rm_aks_version modułu, aby znaleźć obsługiwaną wersję.

  • Jest vnet_subnet_id to podsieć utworzona w poprzedniej sekcji.

  • Element network_profile definiuje właściwości wtyczki sieciowej kubenet.

  • Element service_cidr służy do przypisywania usług wewnętrznych w klastrze usługi AKS do adresu IP. Ten zakres adresów IP powinien być przestrzenią adresową, która nie jest używana poza klastrami usługi AKS. Można jednak ponownie użyć tej samej trasy CIDR usługi dla wielu klastrów usługi AKS.

  • Adres dns_service_ip powinien być adresem ".10" zakresu adresów IP usługi.

  • Powinna pod_cidr to być duża przestrzeń adresowa, która nie jest używana w innym miejscu w środowisku sieciowym. Zakres adresów musi być wystarczająco duży, aby pomieścić liczbę węzłów, które mają zostać przeskalowane w górę. Nie można zmienić tego zakresu adresów po wdrożeniu klastra. Podobnie jak w przypadku trasy CIDR usługi ten zakres adresów IP nie powinien istnieć poza klastrem usługi AKS, ale można go bezpiecznie użyć ponownie w klastrach.

  • Zakres adresów IP zasobnika służy do przypisywania przestrzeni adresowej /24 do każdego węzła w klastrze. W poniższym przykładzie z pod_cidr 192.168.0.0/16 przypisuje pierwszy węzeł 192.168.0.0/24, drugi węzeł 192.168.1.0/24, a trzeci węzeł 192.168.2.0/24.

  • W miarę skalowania lub uaktualniania klastra platforma Azure nadal przypisuje zakres adresów IP zasobnika do każdego nowego węzła.

  • Podręcznik jest ładowany ssh_key z ~/.ssh/id_rsa.pubelementu . Jeśli go zmodyfikujesz, użyj formatu jednowierszowego — zaczynając od ciągu "ssh-rsa" (bez cudzysłowów).

  • Wartości client_id i client_secret są ładowane z ~/.azure/credentialspliku , który jest domyślnym plikiem poświadczeń. Możesz ustawić te wartości na jednostkę usługi lub załadować te wartości ze zmiennych środowiskowych:

    client_id: "{{ lookup('env', 'AZURE_CLIENT_ID') }}"
client_secret: "{{ lookup('env', 'AZURE_SECRET') }}"

Kojarzenie zasobów sieciowych

Podczas tworzenia klastra usługi AKS tworzona jest sieciowa grupa zabezpieczeń i tabela tras. Te zasoby są zarządzane przez usługę AKS i aktualizowane podczas tworzenia i uwidaczniania usług. Skojarz sieciową grupę zabezpieczeń i tabelę tras z podsiecią sieci wirtualnej w następujący sposób.

Zapisz następujący podręcznik jako associate.yml.

- name: Get route table
  azure_rm_routetable_facts:
      resource_group: "{{ node_resource_group }}"
  register: routetable

- name: Get network security group
  azure_rm_securitygroup_facts:
      resource_group: "{{ node_resource_group }}"
  register: nsg

- name: Parse subnet id
  set_fact:
      subnet_name: "{{ vnet_subnet_id | regex_search(subnet_regex, '\\1') }}"
      subnet_rg: "{{ vnet_subnet_id | regex_search(rg_regex, '\\1') }}"
      subnet_vn: "{{ vnet_subnet_id | regex_search(vn_regex, '\\1') }}"
  vars:
      subnet_regex: '/subnets/(.+)'
      rg_regex: '/resourceGroups/(.+?)/'
      vn_regex: '/virtualNetworks/(.+?)/'

- name: Associate network resources with the node subnet
  azure_rm_subnet:
      name: "{{ subnet_name[0] }}"
      resource_group: "{{  subnet_rg[0] }}"
      virtual_network_name: "{{ subnet_vn[0] }}"
      security_group: "{{ nsg.ansible_facts.azure_securitygroups[0].id }}"
      route_table: "{{ routetable.route_tables[0].id }}"

Poniżej przedstawiono kilka kluczowych uwag, które należy wziąć pod uwagę podczas pracy z przykładowym podręcznikiem:

  • To node_resource_group nazwa grupy zasobów, w której są tworzone węzły usługi AKS.
  • Jest vnet_subnet_id to podsieć utworzona w poprzedniej sekcji.

Uruchamianie przykładowego podręcznika

W tej sekcji wymieniono kompletny przykładowy podręcznik, który wywołuje zadania tworzone w tym artykule.

Zapisz następujący podręcznik jako aks-kubenet.yml:

---
- hosts: localhost
  vars:
      resource_group: aksansibletest
      name: aksansibletest
      location: eastus
  tasks:
     - name: Ensure resource group exist
       azure_rm_resourcegroup:
           name: "{{ resource_group }}"
           location: "{{ location }}"

     - name: Create vnet
       include_tasks: vnet.yml

     - name: Create AKS
       vars:
           vnet_subnet_id: "{{ subnet.state.id }}"
       include_tasks: aks.yml

     - name: Associate network resources with the node subnet
       vars:
           vnet_subnet_id: "{{ subnet.state.id }}"
           node_resource_group: "{{ aks.node_resource_group }}"
       include_tasks: associate.yml

     - name: Get details of the AKS
       azure_rm_aks_facts:
           name: "{{ name }}"
           resource_group: "{{ resource_group }}"
           show_kubeconfig: user
       register: output

     - name: Show AKS cluster detail
       debug:
           var: output.aks[0]

vars W sekcji wprowadź następujące zmiany:

  • resource_group Dla klucza zmień aksansibletest wartość na nazwę grupy zasobów.
  • name Dla klucza zmień aksansibletest wartość na nazwę usługi AKS.
  • Location Dla klucza zmień eastus wartość na lokalizację grupy zasobów.

Uruchom kompletny podręcznik przy użyciu ansible-playbook polecenia :

ansible-playbook aks-kubenet.yml

Uruchomienie podręcznika powoduje wyświetlenie wyników podobnych do następujących danych wyjściowych:

PLAY [localhost] 

TASK [Gathering Facts] 
ok: [localhost]

TASK [Ensure resource group exist] 
ok: [localhost]

TASK [Create vnet] 
included: /home/devops/aks-kubenet/vnet.yml for localhost

TASK [Create vnet] 
ok: [localhost]

TASK [Create subnet] 
ok: [localhost]

TASK [Create AKS] 
included: /home/devops/aks-kubenet/aks.yml for localhost

TASK [List supported kubernetes version from Azure] 
 [WARNING]: Azure API profile latest does not define an entry for
ContainerServiceClient

ok: [localhost]

TASK [Create AKS cluster with vnet] 
changed: [localhost]

TASK [Associate network resources with the node subnet] 
included: /home/devops/aks-kubenet/associate.yml for localhost

TASK [Get route table] 
ok: [localhost]

TASK [Get network security group] 
ok: [localhost]

TASK [Parse subnet id] 
ok: [localhost]

TASK [Associate network resources with the node subnet] 
changed: [localhost]

TASK [Get details of the AKS] 
ok: [localhost]

TASK [Show AKS cluster detail] 
ok: [localhost] => {
    "output.aks[0]": {
        "id": /subscriptions/BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB/resourcegroups/aksansibletest/providers/Microsoft.ContainerService/managedClusters/aksansibletest",
        "kube_config": "apiVersion: ...",
        "location": "eastus",
        "name": "aksansibletest",
        "properties": {
            "agentPoolProfiles": [
                {
                    "count": 3,
                    "maxPods": 110,
                    "name": "nodepool1",
                    "osDiskSizeGB": 100,
                    "osType": "Linux",
                    "storageProfile": "ManagedDisks",
                    "vmSize": "Standard_D2_v2",
                    "vnetSubnetID": "/subscriptions/BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB/resourceGroups/aksansibletest/providers/Microsoft.Network/virtualNetworks/aksansibletest/subnets/aksansibletest"
                }
            ],
            "dnsPrefix": "aksansibletest",
            "enableRBAC": false,
            "fqdn": "aksansibletest-cda2b56c.hcp.eastus.azmk8s.io",
            "kubernetesVersion": "1.12.6",
            "linuxProfile": {
                "adminUsername": "azureuser",
                "ssh": {
                    "publicKeys": [
                        {
                            "keyData": "ssh-rsa ..."
                        }
                    ]
                }
            },
            "networkProfile": {
                "dnsServiceIP": "10.0.0.10",
                "dockerBridgeCidr": "172.17.0.1/16",
                "networkPlugin": "kubenet",
                "podCidr": "192.168.0.0/16",
                "serviceCidr": "10.0.0.0/16"
            },
            "nodeResourceGroup": "MC_aksansibletest_pcaksansibletest_eastus",
            "provisioningState": "Succeeded",
            "servicePrincipalProfile": {
                "clientId": "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA"
            }
        },
        "type": "Microsoft.ContainerService/ManagedClusters"
    }
}

PLAY RECAP 
localhost                  : ok=15   changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Czyszczenie zasobów

  1. Zapisz następujący kod jako delete_rg.yml.

    ---
- hosts: localhost
  tasks:
    - name: Deleting resource group - "{{ name }}"
      azure_rm_resourcegroup:
        name: "{{ name }}"
        state: absent
      register: rg
    - debug:
        var: rg

  2. Uruchom podręcznik przy użyciu polecenia ansible-playbook . Zastąp symbol zastępczy nazwą grupy zasobów, która ma zostać usunięta. Wszystkie zasoby w grupie zasobów zostaną usunięte.

    ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"

    Kluczowe punkty:

    • Ze względu na zmienną register i debug sekcję podręcznika wyniki są wyświetlane po zakończeniu polecenia.

Następne kroki

Samouczek — konfigurowanie sieci usługi Azure Container Networking Interface (CNI) w usłudze AKS przy użyciu rozwiązania Ansible