Esercitazione: Gestire il traffico web con Azure Application Gateway con Ansible

Importante

Ansible 2.7 (o versione successiva) è necessario per eseguire i playbook di esempio in questo articolo.

Il gateway applicazione di Azure è un servizio di bilanciamento del carico del traffico Web che consente di gestire il traffico verso le applicazioni Web. In base all'indirizzo IP e alla porta di origine, i servizi di bilanciamento del carico tradizionali instradano il traffico a un indirizzo IP e a una porta di destinazione. Il Gateway Applicativo offre un livello di controllo più dettagliato, consentendo di instradare il traffico in base all'URL. Ad esempio, è possibile definire che se images è il percorso dell'URL, il traffico viene instradato a un set specifico di server (noto come pool) configurato per le immagini.

In questo articolo vengono illustrate le operazioni seguenti:

Configurare una rete
Creare due istanze di Azure Container con immagini HTTPD
Creare un gateway applicativo che funzioni con le istanze di Azure Container Instances nel pool di server

Prerequisiti

Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Installare Ansible: eseguire una delle opzioni seguenti:
- Installare e configurare Ansible in una macchina virtuale Linux
- Configurare Azure Cloud Shell e, se non si ha accesso a una macchina virtuale Linux, creare una macchina virtuale con Ansible.

Creare un gruppo di risorse

Il codice del playbook in questa sezione crea un gruppo di risorse di Azure. Un gruppo di risorse è un contenitore logico in cui sono configurate le risorse di Azure.

Salva il seguente playbook come rg.yml:

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

Prima di eseguire il playbook, vedere le note seguenti:

Il nome del gruppo di risorse è myResourceGroup. Questo valore viene usato in tutta l'esercitazione.
Il gruppo di risorse viene creato nella eastus località.

Eseguire il playbook usando ansible-playbook

ansible-playbook rg.yml

Creare risorse di rete

Nella presente sezione, il codice del playbook crea una rete virtuale per permettere al gateway applicativo di comunicare con altre risorse.

Salva il playbook seguente come 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 }}"

Prima di eseguire il playbook, consultare le note sotto riportate.

La vars sezione contiene i valori usati per creare le risorse di rete.
Sarà necessario modificare questi valori per l'ambiente specifico.

Avvia il playbook usando ansible-playbook

ansible-playbook vnet_create.yml

Creare server

Il codice del playbook in questa sezione crea due istanze di container Azure con immagini di HTTPD da usare come server web per il gateway dell'applicazione.

Salva il seguente playbook con nome 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

Eseguire il playbook usando ansible-playbook

ansible-playbook aci_create.yml

Creare il gateway applicazione

Il codice del playbook in questa parte crea un gateway di applicazione denominato myAppGateway.

Salva il playbook seguente come 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

Prima di eseguire il playbook, consultare le note seguenti:

appGatewayIP è definito nel gateway_ip_configurations blocco . Per la configurazione IP del gateway è necessario un riferimento alla subnet.
appGatewayBackendPool è definito nel backend_address_pools blocco . Un gateway applicativo deve avere almeno un pool di indirizzi back-end.
appGatewayBackendHttpSettings è definito nel backend_http_settings_collection blocco . Specifica che la porta 80 e un protocollo HTTP vengono usate per la comunicazione.
appGatewayHttpListener è definito nel backend_http_settings_collection blocco . Si tratta del listener predefinito associato ad appGatewayBackendPool.
appGatewayFrontendIP è definito nel frontend_ip_configurations blocco . Assegna *myAGPublicIPAddress* ad *appGatewayHttpListener*.
rule1 è definito nel request_routing_rules blocco . Si tratta della regola di routing predefinita associata ad appGatewayHttpListener.

Eseguire il playbook usando ansible-playbook

ansible-playbook appgw_create.yml

La creazione del gateway applicazione potrebbe richiedere alcuni minuti.

Testare il gateway applicazione

Nella sezione Creare un gruppo di risorse si specifica una posizione. Nota il valore.
Nella sezione Crea risorse di rete specificare il dominio. Annota il suo valore.
Per l'URL di test, si deve sostituire il pattern seguente con il percorso e il dominio: http://<domain>.<location>.cloudapp.azure.com.
Vai all'URL di test.
Se viene visualizzata la pagina seguente, il gateway applicazione funziona come previsto.

Pulire le risorse

Salvare il codice seguente come delete_rg.yml.

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

Esegui il playbook usando il comando ansible-playbook. Sostituire il segnaposto con il nome del gruppo di risorse da eliminare. Tutte le risorse all'interno del gruppo di risorse verranno eliminate.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Punti chiave:
- A causa della variabile register e della sezione debug del playbook, i risultati vengono visualizzati al termine del comando.

Eseguire az group delete per eliminare il gruppo di risorse. Tutte le risorse all'interno del gruppo di risorse verranno eliminate.
```
az group delete --name <resource_group>
```
Verificare che il gruppo di risorse sia stato eliminato usando az group show.
```
az group show --name <resource_group>
```

Eseguire Remove-AzResourceGroup per eliminare il gruppo di risorse. Tutte le risorse all'interno del gruppo di risorse verranno eliminate.
```
Remove-AzResourceGroup -Name <resource_group>
```
Verificare che il gruppo di risorse sia stato eliminato usando Get-AzResourceGroup.
```
Get-AzResourceGroup -Name <resource_group>
```

Passaggi successivi

Ansible in Azure

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2025-10-10

Esercitazione: Gestire il traffico web con Azure Application Gateway con Ansible

Prerequisiti

Creare un gruppo di risorse

Creare risorse di rete

Creare server

Creare il gateway applicazione

Testare il gateway applicazione

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive