Lernprogramm: Verwalten von Webdatenverkehr mit Dem Azure-Anwendungsgateway mithilfe von Ansible

Von Bedeutung

Ansible 2.7 (oder höher) ist erforderlich, um die Beispiel-Playbooks in diesem Artikel auszuführen.

Azure Application Gateway ist ein Lastenausgleich für Webdatenverkehr, mit dem Sie eingehenden Datenverkehr für Ihre Webanwendungen verwalten können. Basierend auf der Quell-IP-Adresse und dem Port leiten herkömmliche Lastenausgleichsgeräte Datenverkehr an eine Ziel-IP-Adresse und einen Port weiter. Das Application Gateway bietet eine genauere Kontrolle, bei der der Datenverkehr basierend auf der URL weitergeleitet werden kann. Sie können beispielsweise definieren, dass der Datenverkehr, wenn images es sich um den Pfad der URL handelt, an einen bestimmten Satz von Servern (als Pool bezeichnet) weitergeleitet wird, der für Bilder konfiguriert ist.

In diesem Artikel erfahren Sie, wie Sie:

Einrichten eines Netzwerks
Erstellen von zwei Azure-Containerinstanzen mit HTTPD-Images
Erstellen eines Anwendungsgateways, das mit den Azure-Containerinstanzen im Serverpool funktioniert

Voraussetzungen

Azure-Abonnement: Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

Installieren Sie Ansible: Führen Sie eine der folgenden Optionen aus:
- Installieren und Konfigurieren von Ansible auf einem virtuellen Linux-Computer
- Konfigurieren Sie Azure Cloud Shell, und erstellen Sie – wenn Sie keinen Zugriff auf einen virtuellen Linux-Computer haben – einen virtuellen Computer mit Ansible.

Erstellen einer Ressourcengruppe

Der Playbook-Code in diesem Abschnitt erstellt eine Azure-Ressourcengruppe. Eine Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen konfiguriert sind.

Speichern Sie das folgende Playbook unter rg.yml:

- hosts: localhost
  vars:
    resource_group: myResourceGroup
    location: eastus 
  tasks:
    - name: Create a resource group
      azure_rm_resourcegroup:
        name: "{{ resource_group }}"
        location: "{{ location }}"

Bevor Sie das Playbook ausführen, beachten Sie bitte die folgenden Hinweise:

Der Ressourcengruppenname lautet myResourceGroup. Dieser Wert wird im gesamten Lernprogramm verwendet.
Die Ressourcengruppe wird am eastus Ort erstellt.

Führe das Playbook mit ansible-playbook aus

ansible-playbook rg.yml

Erstellen von Netzwerkressourcen

Der Playbook-Code in diesem Abschnitt erstellt ein virtuelles Netzwerk, damit das Anwendungsgateway mit anderen Ressourcen kommunizieren kann.

Speichern Sie das folgende Playbook unter vnet_create.yml:

- hosts: localhost
  vars:
    resource_group: myResourceGroup
    location: eastus 
    vnet_name: myVNet 
    subnet_name: myAGSubnet 
    publicip_name: myAGPublicIPAddress
    publicip_domain: mydomain
  tasks:
    - name: Create a virtual network
      azure_rm_virtualnetwork:
        name: "{{ vnet_name }}"
        resource_group: "{{ resource_group }}"
        address_prefixes_cidr:
            - 10.1.0.0/16
            - 172.100.0.0/16
        dns_servers:
            - 127.0.0.1
            - 127.0.0.2

    - name: Create a subnet
      azure_rm_subnet:
        name: "{{ subnet_name }}"
        virtual_network_name: "{{ vnet_name }}"
        resource_group: "{{ resource_group }}"
        address_prefix_cidr: 10.1.0.0/24

    - name: Create a public IP address
      azure_rm_publicipaddress:
        resource_group: "{{ resource_group }}" 
        allocation_method: Dynamic
        name: "{{ publicip_name }}"
        domain_name_label: "{{ publicip_domain }}"

Bevor Sie das Playbook ausführen, lesen Sie die folgenden Hinweise:

Der vars Abschnitt enthält die Werte, die zum Erstellen der Netzwerkressourcen verwendet werden.
Sie müssen diese Werte für Ihre spezifische Umgebung ändern.

Führen Sie das Playbook mit ansible-playbook aus

ansible-playbook vnet_create.yml

Erstellen von Servern

Der Playbook-Code in diesem Abschnitt erstellt zwei Azure-Containerinstanzen mit HTTPD-Images, die als Webserver für das Anwendungsgateway verwendet werden sollen.

Speichern Sie das folgende Playbook unter aci_create.yml:

- hosts: localhost
  vars:
    resource_group: myResourceGroup
    location: eastus 
    aci_1_name: myACI1
    aci_2_name: myACI2
  tasks:
    - name: Create a container with httpd image 
      azure_rm_containerinstance:
        resource_group: "{{ resource_group }}"
        name: "{{ aci_1_name }}"
        os_type: linux
        ip_address: public
        location: "{{ location }}"
        ports:
          - 80
        containers:
          - name: mycontainer
            image: httpd
            memory: 1.5
            ports:
              - 80

    - name: Create another container with httpd image 
      azure_rm_containerinstance:
        resource_group: "{{ resource_group }}"
        name: "{{ aci_2_name }}"
        os_type: linux
        ip_address: public
        location: "{{ location }}"
        ports:
          - 80
        containers:
          - name: mycontainer
            image: httpd
            memory: 1.5
            ports:
              - 80

Ausführen des Playbook unter Verwendung von ansible-playbook

ansible-playbook aci_create.yml

Erstellen des Anwendungsgateways

Der Playbook-Code in diesem Abschnitt erstellt ein Anwendungsgateway mit dem Namen myAppGateway.

Speichern Sie das folgende Playbook unter appgw_create.yml:

- hosts: localhost
  connection: local
  vars:
    resource_group: myResourceGroup
    vnet_name: myVNet
    subnet_name: myAGSubnet
    location: eastus
    publicip_name: myAGPublicIPAddress
    appgw_name: myAppGateway
    aci_1_name: myACI1
    aci_2_name: myACI2
  tasks:
    - name: Get info of Subnet
      azure_rm_resource_facts:
        api_version: '2018-08-01'
        resource_group: "{{ resource_group }}"
        provider: network
        resource_type: virtualnetworks
        resource_name: "{{ vnet_name }}"
        subresource:
          - type: subnets
            name: "{{ subnet_name }}"
      register: subnet

    - name: Get info of backend server 1
      azure_rm_resource_facts:
        api_version: '2018-04-01'
        resource_group: "{{ resource_group }}"
        provider: containerinstance
        resource_type: containergroups
        resource_name: "{{ aci_1_name }}"
      register: aci_1_output
    - name: Get info of backend server 2
      azure_rm_resource_facts:
        api_version: '2018-04-01'
        resource_group: "{{ resource_group }}"
        provider: containerinstance
        resource_type: containergroups
        resource_name: "{{ aci_2_name }}"
      register: aci_2_output

    - name: Create instance of Application Gateway
      azure_rm_appgateway:
        resource_group: "{{ resource_group }}"
        name: "{{ appgw_name }}"
        sku:
          name: standard_v2
          tier: standard_v2
          capacity: 2
        gateway_ip_configurations:
          - subnet:
              id: "{{ subnet.response[0].id }}"
            name: appGatewayIP
        frontend_ip_configurations:
          - public_ip_address: "{{ publicip_name }}"
            name: appGatewayFrontendIP
        frontend_ports:
          - port: 80
            name: appGatewayFrontendPort
        backend_address_pools:
          - backend_addresses:
              - ip_address: "{{ aci_1_output.response[0].properties.ipAddress.ip }}"
              - ip_address: "{{ aci_2_output.response[0].properties.ipAddress.ip }}"
            name: appGatewayBackendPool
        backend_http_settings_collection:
          - port: 80
            protocol: http
            cookie_based_affinity: enabled
            name: appGatewayBackendHttpSettings
        http_listeners:
          - frontend_ip_configuration: appGatewayFrontendIP
            frontend_port: appGatewayFrontendPort
            name: appGatewayHttpListener
        request_routing_rules:
          - rule_type: Basic
            backend_address_pool: appGatewayBackendPool
            backend_http_settings: appGatewayBackendHttpSettings
            http_listener: appGatewayHttpListener
            name: rule1

Bevor Sie das Playbook ausführen, lesen Sie die folgenden Notizen:

appGatewayIP ist im gateway_ip_configurations Block definiert. Für die IP-Konfiguration des Gateways ist ein Subnetzverweis erforderlich.
appGatewayBackendPool ist im backend_address_pools Block definiert. Ein Anwendungsgateway muss über mindestens einen Back-End-Adresspool verfügen.
appGatewayBackendHttpSettings ist im backend_http_settings_collection Block definiert. Es gibt an, dass Port 80 und ein HTTP-Protokoll für die Kommunikation verwendet werden.
appGatewayHttpListener ist im backend_http_settings_collection Block definiert. Es ist der Standardlistener, der appGatewayBackendPool zugeordnet ist.
appGatewayFrontendIP ist im frontend_ip_configurations Block definiert. Es weist "myAGPublicIPAddress" dem "appGatewayHttpListener" zu.
rule1 ist im request_routing_rules Block definiert. Es ist die Standardroutingregel, die appGatewayHttpListener zugeordnet ist.

Führen Sie das Playbook mit ansible-playbook aus

ansible-playbook appgw_create.yml

Es kann mehrere Minuten dauern, bis das Anwendungsgateway erstellt wird.

Testen des Anwendungsgateways

Geben Sie im Abschnitt "Erstellen einer Ressourcengruppe " einen Speicherort an. Notieren Sie sich den Wert.
Geben Sie im Abschnitt " Netzwerkressourcen erstellen " die Domäne an. Beachten Sie den Wert.
Ersetzen Sie für die Test-URL das folgende Muster durch den Speicherort und die Domäne: http://<domain>.<location>.cloudapp.azure.com
Navigieren Sie zur Test-URL.
Wenn die folgende Seite angezeigt wird, funktioniert das Anwendungsgateway erwartungsgemäß.

Bereinigen von Ressourcen

Speichern Sie den folgenden Code als delete_rg.yml.

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

Führen Sie das Playbook mit dem Befehl "ansible-playbook" aus. Ersetzen Sie den Platzhalter durch den Namen der zu löschenden Ressourcengruppe. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Wichtige Punkte:
- Aufgrund der register Variablen und des debug Abschnitts des Playbooks werden die Ergebnisse angezeigt, sobald der Befehl abgeschlossen ist.

Führen Sie az group delete aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
az group delete --name <resource_group>
```
Überprüfen Sie, ob die Ressourcengruppe mithilfe der az group show gelöscht wurde.
```
az group show --name <resource_group>
```

Führen Sie Remove-AzResourceGroup aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
Remove-AzResourceGroup -Name <resource_group>
```
Überprüfen Sie, ob die Ressourcengruppe mithilfe von "Get-AzResourceGroup" gelöscht wurde.
```
Get-AzResourceGroup -Name <resource_group>
```

Nächste Schritte

Ansible on Azure

Feedback

War diese Seite hilfreich?

Zuletzt aktualisiert um 2025-10-10