Dela via

Självstudie: Konfigurera kubenet-nätverk i Azure Kubernetes Service (AKS) med Ansible

  • Artikel

Viktigt!

Ansible 2.8 (eller senare) krävs för att köra exempelspelböckerna i den här artikeln.

Azure Kubernetes Service (AKS) gör det enkelt att distribuera ett hanterat Kubernetes-kluster i Azure. AKS minskar komplexiteten och arbetet med att hantera Kubernetes genom att avlasta en stor del av det ansvaret till Azure. Som Kubernetes-värdtjänst hanterar Azure viktiga uppgifter som övervakning av hälsotillstånd och underhåll åt dig. Kubernetes-huvudservrar hanteras av Azure. Du kan endast hantera och underhålla agentnoderna. Som en hanterad Kubernetes-tjänst är AKS kostnadsfri – du betalar bara för agentnoderna i dina kluster. inte för mästarna.

Med hjälp av AKS kan du distribuera ett kluster med hjälp av följande nätverksmodeller:

  • Kubenet-nätverk – Nätverksresurser skapas och konfigureras vanligtvis när AKS-klustret distribueras.
  • CNI-nätverk (Azure Container Networking Interface) – AKS-klustret är anslutet till befintliga virtuella nätverksresurser och konfigurationer.

Mer information om nätverk till dina program i AKS finns i Nätverksbegrepp för program i AKS.

I den här artikeln kan du se hur du:

  • Skapa ett AKS-kluster
  • Konfigurera Azure kubenet-nätverk

Förutsättningar

  • Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.
  • Azure-tjänstens huvudnamn: Skapa ett huvudnamn för tjänsten och anteckna följande värden: appId, displayName, lösenord och klientorganisation.

Skapa ett virtuellt nätverk och ett undernät

Spelbokskoden i det här avsnittet skapar följande Azure-resurser:

  • Virtuellt nätverk
  • Undernät i det virtuella nätverket

Spara följande spelbok som 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

Skapa ett AKS-kluster i det virtuella nätverket

Spelbokskoden i det här avsnittet skapar ett AKS-kluster i ett virtuellt nätverk.

Spara följande spelbok som 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

Här följer några viktiga kommentarer att tänka på när du arbetar med exempelspelboken:

  • Använd azure_rm_aks_version modulen för att hitta den version som stöds.

  • vnet_subnet_id är det undernät som skapades i föregående avsnitt.

  • network_profile Definierar egenskaperna för kubenet-nätverkets plugin-program.

  • service_cidr Används för att tilldela interna tjänster i AKS-klustret till en IP-adress. Det här IP-adressintervallet ska vara ett adressutrymme som inte används utanför AKS-klustren. Du kan dock återanvända samma tjänst-CIDR för flera AKS-kluster.

  • Adressen dns_service_ip ska vara ".10"-adressen för tjänstens IP-adressintervall.

  • pod_cidr Bör vara ett stort adressutrymme som inte används någon annanstans i nätverksmiljön. Adressintervallet måste vara tillräckligt stort för att rymma det antal noder som du förväntar dig att skala upp till. Du kan inte ändra det här adressintervallet när klustret har distribuerats. Precis som med tjänst-CIDR bör det här IP-intervallet inte finnas utanför AKS-klustret, men det kan återanvändas på ett säkert sätt mellan kluster.

  • Ip-adressintervallet för podden används för att tilldela ett /24-adressutrymme till varje nod i klustret. I följande exempel pod_cidr tilldelar 192.168.0.0/16 den första noden 192.168.0.0/24, den andra noden 192.168.1.0/24 och den tredje noden 192.168.2.0/24.

  • När klustret skalar eller uppgraderas fortsätter Azure att tilldela en podd-IP-adressintervall till varje ny nod.

  • Spelboken läses in ssh_key från ~/.ssh/id_rsa.pub. Om du ändrar det använder du enkelradsformatet – från och med "ssh-rsa" (utan citattecken).

  • Värdena client_id och client_secret läses in från ~/.azure/credentials, vilket är standardfilen för autentiseringsuppgifter. Du kan ange dessa värden till tjänstens huvudnamn eller läsa in dessa värden från miljövariabler:

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

Associera nätverksresurserna

När du skapar ett AKS-kluster skapas en nätverkssäkerhetsgrupp och routningstabell. Dessa resurser hanteras av AKS och uppdateras när du skapar och exponerar tjänster. Associera nätverkssäkerhetsgruppen och routningstabellen med ditt virtuella nätverksundernät på följande sätt.

Spara följande spelbok som 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 }}"

Här följer några viktiga kommentarer att tänka på när du arbetar med exempelspelboken:

  • node_resource_group är resursgruppens namn där AKS-noderna skapas.
  • vnet_subnet_id är det undernät som skapades i föregående avsnitt.

Kör exempelspelboken

I det här avsnittet visas den fullständiga exempelspelboken som anropar de uppgifter som skapas i den här artikeln.

Spara följande spelbok som 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]

I avsnittet vars gör du följande ändringar:

  • resource_group För nyckeln ändrar du värdet aksansibletest till resursgruppens namn.
  • name För nyckeln ändrar du värdet aksansibletest till ditt AKS-namn.
  • Location För nyckeln ändrar du värdet eastus till resursgruppens plats.

Kör den fullständiga spelboken med kommandot ansible-playbook :

ansible-playbook aks-kubenet.yml

När du kör spelboken visas resultat som liknar följande utdata:

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

Rensa resurser

  1. Spara följande kod som delete_rg.yml.

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

  2. Kör spelboken med kommandot ansible-playbook . Ersätt platshållaren med namnet på den resursgrupp som ska tas bort. Alla resurser i resursgruppen tas bort.

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

    Viktiga punkter:

    • På grund av variabeln register och debug avsnittet i spelboken visas resultatet när kommandot har slutförts.

Nästa steg

Självstudie – Konfigurera CNI-nätverk (Azure Container Networking Interface) i AKS med Ansible