Lernprogramm: Konfigurieren von Caches im Azure-Cache für Redis mithilfe von Ansible

Von Bedeutung

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

Azure Cache for Redis ist ein open-source-kompatibler Dienst, mit dem Sie reaktionsfähige Apps erstellen können, indem Sie schnellen Zugriff auf Daten bereitstellen.

In diesem Artikel erfahren Sie, wie Sie:

Erstellen eines Caches
Skalieren eines Caches
Neustarten eines Caches
Hinzufügen einer Firewallregel zu einem Cache
Löschen eines Caches

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 eines Caches

Erstellen Sie einen Azure-Cache für Redis in einer neuen Ressourcengruppe.

  - 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

Es kann mehrere Minuten dauern, bis ein Cache bereitgestellt wird. Der folgende Code weist Ansible darauf hin, darauf zu warten, bis der Vorgang abgeschlossen ist.

  - 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

Während des langen Bereitstellungsprozesses werden mehrere Fehlermeldungen angezeigt. Diese Nachrichten können sicher ignoriert werden. Die wichtige Nachricht ist die letzte Nachricht. Im folgenden Beispiel gibt es viele Fehlermeldungen, bis die endgültige Meldung ("ok") angezeigt wird.

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]

Skalieren des Caches

Der Azure Cache für Redis verfügt je nach App-Anforderungen über unterschiedliche Cacheangebote. Diese Cacheoptionen bieten Flexibilität bei der Auswahl der Cachegröße und -features. Wenn sich die App-Anforderungen ändern, nachdem der Cache erstellt wurde, können Sie den Cache nach Bedarf skalieren. Weitere Informationen zur Skalierung finden Sie unter Skalieren des Azure-Caches für Redis.

Der folgende Beispielcode skaliert den Cache auf Standard:

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

Es kann mehrere Minuten dauern, bis ein Cache skaliert wird. Der folgende Code weist Ansible an, auf den Abschluss des Vorgangs zu warten:

  - 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

Ähnlich wie bei der Aufgabe zum Bereitstellen von Azure Cache für Redis ist die Ausgabe wie die folgende Meldung normal:

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

Neustarten des Caches

Der folgende Code startet den cache neu, der in früheren Abschnitten erstellt wurde.

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

Hinzufügen einer Firewallregel

Der folgende Code fügt dem Cache eine Firewallregel hinzu:

  - 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

Löschen des Caches

Der folgende Code löscht den Cache:

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

Beispiel-Playbook abrufen

Es gibt zwei Möglichkeiten, das vollständige Beispiel-Playbook zu erhalten:

Laden Sie das Playbook herunter , und speichern Sie es auf rediscache.yml.
Erstellen Sie eine neue Datei mit dem Namen rediscache.yml , und kopieren Sie den folgenden Inhalt darin:

- 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

Führen Sie das Beispiel-Playbook aus

Führen Sie in diesem Abschnitt das Playbook aus, um verschiedene In diesem Artikel gezeigte Features zu testen.

Ersetzen Sie im vars Abschnitt den {{ resource_group_name }} Platzhalter durch den Namen Ihrer Ressourcengruppe.

Führen Sie das Playbook mit ansible-playbook aus

ansible-playbook rediscache.yml

Die Ausgabe sieht ähnlich wie die folgenden Ergebnisse aus:

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

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