Esercitazione: Configurare le cache in Cache Redis di Azure con Ansible

Importante

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

Cache Redis di Azure è un servizio compatibile con open source che consente di creare app reattive fornendo accesso rapido ai dati.

In questo articolo vengono illustrate le operazioni seguenti:

Creare una cache
Ridimensionare una cache
Riavviare una cache
Aggiungere una regola del firewall a una cache
Eliminare una cache

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 una cache

Creare una Cache Redis di Azure all'interno di un nuovo gruppo di risorse.

  - name: Create resource group
    azure_rm_resourcegroup:
      name: "{{ resource_group }}"
      location: "{{ location }}"

  - name: Create Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      sku:
        name: basic
        size: C1

Il provisioning di una cache può richiedere alcuni minuti. Il codice seguente indica a Ansible di attendere il completamento dell'operazione:

  - name: Wait for Redis provisioning to complete
    azure_rm_rediscache_info:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
    register: facts
    until: "{{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}"
    retries: 100
    delay: 60

Durante il processo di provisioning lungo, verranno visualizzati diversi messaggi di "errore". Questi messaggi possono essere ignorati in modo sicuro. Il messaggio importante è l'ultimo messaggio. Nell'esempio seguente sono presenti molti messaggi di errore fino al messaggio finale ("ok").

FAILED - RETRYING: Get facts (100 retries left).
FAILED - RETRYING: Get facts (99 retries left).
FAILED - RETRYING: Get facts (98 retries left).
FAILED - RETRYING: Get facts (97 retries left).
FAILED - RETRYING: Get facts (96 retries left).
FAILED - RETRYING: Get facts (95 retries left).
FAILED - RETRYING: Get facts (94 retries left).
FAILED - RETRYING: Get facts (93 retries left).
FAILED - RETRYING: Get facts (92 retries left).
FAILED - RETRYING: Get facts (91 retries left).
ok: [localhost]

Ridimensionare la cache

Cache Redis di Azure include offerte di cache diverse a seconda delle esigenze dell'app. Queste opzioni della cache offrono flessibilità nella scelta delle dimensioni e delle funzionalità della cache. Se i requisiti dell'app cambiano dopo la creazione della cache, è possibile ridimensionare la cache in base alle esigenze. Per altre informazioni sul ridimensionamento, vedere Come ridimensionare Cache Redis di Azure.

Il codice di esempio seguente ridimensiona la cache in Standard:

- name: Scale up Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      sku:
        name: standard
        size: C1

La scalabilità di una cache può richiedere alcuni minuti. Il codice seguente indica a Ansible di attendere il completamento dell'operazione:

  - name: Wait for Redis scaling up to complete
    azure_rm_rediscache_info:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
    register: facts
    until: "{{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}"
    retries: 100
    delay: 60

Analogamente all'attività di provisioning per Azure Cache per Redis, un output simile al seguente è normale:

**FAILED - RETRYING: Get facts (100 retries left)** is normal.

Riavviare la cache

Il codice seguente riavvia la cache creata nelle sezioni precedenti.

  - name: Reboot Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      reboot:
        reboot_type: all

Aggiungere una regola del firewall

Il codice seguente aggiunge una regola del firewall alla cache:

  - name: Add Firewall rule
    azure_rm_rediscachefirewallrule:
      resource_group: "{{ resource_group }}"
      cache_name: "{{ redis_name }}"
      name: rule1
      start_ip_address: 168.1.1.1
      end_ip_address: 168.1.1.4

Eliminare la cache

Il codice seguente elimina la cache:

  - name: Delete Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      state: absent

Scarica il playbook di esempio

Esistono due modi per ottenere il playbook di esempio completo:

Scaricare il playbook e salvarlo in rediscache.yml.
Creare un nuovo file denominato rediscache.yml e copiarne il contenuto seguente:

- name: Manage Azure Cache for Redis
  hosts: localhost
  connection: local
  vars:
    resource_group: "{{ resource_group_name }}"
    redis_name: "redis{{ resource_group_name }}"
    location: eastus2

  roles:
    - azure.azure_preview_modules

  tasks:
  - name: Create resource group
    azure_rm_resourcegroup:
      name: "{{ resource_group }}"
      location: "{{ location }}"

  - name: Create Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      sku:
        name: basic
        size: C1

  - name: Wait for Redis provisioning to complete
    azure_rm_rediscache_info:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
    register: facts
    until: "{{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}"
    retries: 100
    delay: 60

  - name: Scale up Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      sku:
        name: standard
        size: C1

  - name: Wait for Redis scaling up to complete
    azure_rm_rediscache_info:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
    register: facts
    until: "{{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}"
    retries: 100
    delay: 60

  - name: Reboot Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      reboot:
        reboot_type: all

  - name: Add Firewall rule
    azure_rm_rediscachefirewallrule:
      resource_group: "{{ resource_group }}"
      cache_name: "{{ redis_name }}"
      name: rule1
      start_ip_address: 168.1.1.1
      end_ip_address: 168.1.1.4

  - name: Delete Azure Cache for Redis
    azure_rm_rediscache:
      resource_group: "{{ resource_group }}"
      name: "{{ redis_name }}"
      state: absent

Esegui il playbook di esempio

In questa sezione, esegui il playbook e testa le varie funzionalità illustrate in questo articolo.

vars Nella sezione sostituire il {{ resource_group_name }} segnaposto con il nome del gruppo di risorse.

Eseguire il playbook usando ansible-playbook

ansible-playbook rediscache.yml

L'output è simile ai risultati seguenti:

TASK [create resource group] 
Tuesday 12 March 2019  16:21:07 +0800 (0:00:00.054)       0:00:01.503 
ok: [localhost]

TASK [Create Azure Cache for Redis] 
Tuesday 12 March 2019  16:21:09 +0800 (0:00:01.950)       0:00:03.454 
 [WARNING]: Azure API profile latest does not define an entry for RedisManagementClient

changed: [localhost]

TASK [Dump host name] 
Tuesday 12 March 2019  16:21:49 +0800 (0:00:40.125)       0:00:43.580 
ok: [localhost] =>
  output['host_name']: redis0312.redis.cache.windows.net

TASK [Get facts] 
Tuesday 12 March 2019  16:21:49 +0800 (0:00:00.056)       0:00:43.636 
 [WARNING]: conditional statements should not include jinja2 templating delimiters such as {{ }} or {% %}. Found: {{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}

FAILED - RETRYING: Get facts (100 retries left).
FAILED - RETRYING: Get facts (99 retries left).
FAILED - RETRYING: Get facts (98 retries left).
FAILED - RETRYING: Get facts (97 retries left).
FAILED - RETRYING: Get facts (96 retries left).
FAILED - RETRYING: Get facts (95 retries left).
FAILED - RETRYING: Get facts (94 retries left).
FAILED - RETRYING: Get facts (93 retries left).
FAILED - RETRYING: Get facts (92 retries left).
FAILED - RETRYING: Get facts (91 retries left).
FAILED - RETRYING: Get facts (90 retries left).
ok: [localhost]

TASK [Scale up Azure Cache for Redis] 
Tuesday 12 March 2019  16:33:20 +0800 (0:11:31.296)       0:12:14.933 
changed: [localhost]

TASK [Get facts] 
Tuesday 12 March 2019  16:33:29 +0800 (0:00:09.164)       0:12:24.097 
 [WARNING]: conditional statements should not include jinja2 templating delimiters such as {{ }} or {% %}. Found: {{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}

FAILED - RETRYING: Get facts (100 retries left).
FAILED - RETRYING: Get facts (99 retries left).
FAILED - RETRYING: Get facts (98 retries left).
FAILED - RETRYING: Get facts (97 retries left).
FAILED - RETRYING: Get facts (96 retries left).
FAILED - RETRYING: Get facts (95 retries left).
FAILED - RETRYING: Get facts (94 retries left).
FAILED - RETRYING: Get facts (93 retries left).
FAILED - RETRYING: Get facts (92 retries left).
FAILED - RETRYING: Get facts (91 retries left).
ok: [localhost]

TASK [Reboot Azure Cache for Redis] 
Tuesday 12 March 2019  16:43:57 +0800 (0:10:27.740)       0:22:51.838 
ok: [localhost]

TASK [Add Firewall rule] 
Tuesday 12 March 2019  16:44:02 +0800 (0:00:05.432)       0:22:57.271 
changed: [localhost]

TASK [Delete Azure Cache for Redis] 
Tuesday 12 March 2019  16:44:08 +0800 (0:00:05.137)       0:23:02.409 
changed: [localhost]

PLAY RECAP 
localhost                  : ok=10   changed=4    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0

Tuesday 12 March 2019  16:44:14 +0800 (0:00:06.217)       0:23:08.626

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 rimuovere 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 effettivamente eliminato utilizzando 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