

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# On-demand Skalierung für Memcached-Cluster
<a name="Scaling-self-designed.mem-heading"></a>

ElastiCache for Memcached bietet einen vollständig verwalteten In-Memory-Caching-Service, der Memcached in der Cloud bereitstellt, betreibt und vertikal skaliert. AWS 

**On-demand vertikale Skalierung**

Mit der vertikalen Skalierung bietet Memcached ein leistungsstarkes, verteiltes Speicher-Caching-System, das häufig verwendet wird, um dynamische Anwendungen zu beschleunigen, indem die Datenbanklast verringert wird. ElastiCache Es speichert Daten und Objekte im RAM, sodass weniger Daten aus externen Datenquellen gelesen werden müssen.

Sie können vertikale Skalierung sowohl auf bestehende als auch auf neue knotenbasierte Cluster anwenden. Dies kann für Flexibilität bei der Ressourcenzuweisung sorgen, sodass Benutzer sich effizient an sich ändernde Workloads anpassen können, ohne die Clusterarchitektur zu ändern. Diese Skalierungsfähigkeit verbessert die Leistung, indem sie die Cache-Kapazität in Zeiten hoher Nachfrage erhöht und in Zeiten geringer Nachfrage nach unten skaliert, um die Kosten zu optimieren. Dies vereinfacht den Betrieb, macht die Erstellung neuer Cluster für wechselnde Ressourcenanforderungen überflüssig und ermöglicht eine schnelle Reaktion auf Verkehrsschwankungen. Insgesamt kann die vertikale Skalierung für knotenbasierte Memcached-Cluster dazu beitragen, die Kosteneffizienz zu erhöhen, die Ressourcennutzung zu verbessern und es Benutzern sogar zu ermöglichen, ihren Memcached-Instance-Typ zu ändern. All das erleichtert es Benutzern, ihre Caching-Infrastruktur an den tatsächlichen Anwendungsanforderungen auszurichten. 

**Anmerkung**  
Änderungen des Knotentyps sind nur für knotenbasierte Memcached-Cluster mit Engine-Versionen 1.5 oder höher verfügbar.
Auto Discovery muss aktiviert sein, um die vertikale Skalierung nutzen zu können. 

## Einrichtung der vertikalen Skalierung auf Abruf für knotenbasierte Memcached-Cluster
<a name="Scaling.Memcached.automatically.setup.cli"></a>

Sie können die vertikale Skalierung auf Abruf für Memcached mit konfigurieren`scale-config`, die zwei Parameter enthält: 

1. **ScaleIntervalMinutes:** Zeit (in Minuten) zwischen den Skalierungsstapeln während des Memcached-Upgrade-Vorgangs

1. **ScalePercentage:** Prozentsatz der Knoten, die während des Memcached-Upgrade-Vorgangs gleichzeitig skaliert werden

**Konvertierung eines vorhandenen Memcached-Knotentyps in einen Cache, der über die CLI vertikal skaliert werden kann**

Um einen vorhandenen knotenbasierten Memcached-Cluster in einen Cache zu konvertieren, der vertikal skaliert werden kann, können Sie dies über die CLI verwenden`elasticache modify-cache-cluster`.

```
aws elasticache modify-cache-cluster \
    --cache-cluster-id <your-cluster-id> \
    --cache-node-type <new-node-type> \
    --scale-config <scale-config> \ 
    --apply-immediately
```

**Vertikale Skalierung mit der CLI einrichten**

Um die vertikale Skalierung für einen knotenbasierten Memcached-Cluster über die CLI einzurichten, verwenden Sie `elasticache modify-cache-cluster` with `scale-config` und seine Parameter und. `ScalePercentage` `ScaleIntervalMinutes` 
+ **scale-interval-minutes: Dies definiert die Zeit (in Minuten**) zwischen den Skalierungsstapeln. Diese Einstellung kann zwischen 2 und 30 Minuten liegen. Wenn kein Wert angegeben ist, wird der Standardwert von 5 Minuten angewendet.
+ **Skalierungsprozentsatz:** Dies gibt den Prozentsatz der Knoten an, die in jedem Stapel gleichzeitig skaliert werden sollen. Diese Einstellung kann zwischen 10 und 100 liegen. Die Einstellung wird beim Dividieren aufgerundet. Wenn das Ergebnis beispielsweise 49,5 wäre, wird die Einstellung 50 angewendet. Wenn kein Wert angegeben ist, wird der Standardwert 20 angewendet.

Diese Konfigurationsoptionen ermöglichen es Ihnen, den Skalierungsprozess an Ihre spezifischen Bedürfnisse anzupassen und dabei ein Gleichgewicht zwischen der Minimierung von Clusterunterbrechungen und der Optimierung der Skalierungsgeschwindigkeit zu finden. Der Parameter scale-config gilt nur für Memcached-Engine-Typen und wird für andere Cache-Engines ignoriert, sodass die Abwärtskompatibilität mit der bestehenden API-Nutzung für andere Cluster gewährleistet ist.

**API-Aufruf**

```
aws elasticache modify-cache-cluster \
    --cache-cluster-id <your-cluster-id> \
    --cache-node-type <new-node-type> \
    --scale-config '{
            "ScalePercentage": 30,
            "ScaleIntervalMinutes": 2
          }'
    --apply-immediately
```

**Ergebnis:**

Gibt die Cluster-ID und die ausstehende Änderung zurück.

```
{
    "CacheCluster": {
        "CacheNodeType": "old_insance_type",
         ...
         ...
         "PendingModifiedValues": {
            "CacheNodeType": "new_instance_type"
         },
    }
}
```

**Listet Ihre vertikale Skalierungseinstellung für den Memcached-Cache auf**

Sie können die Skalierungsoptionen für Ihre Memcache-Caches abrufen und sehen, welche aktuellen Optionen für die vertikale Skalierung verfügbar sind. 

**API-Aufruf**

```
aws elasticache list-allowed-node-type-modifications --cache-cluster-id <your-cluster-id>
```

**Ergebnis:**

```
{ 
  "ScaleUpModifications": [
      "cache.x.xxxx", 
      "cache.x.xxxx"
   	  ],
   "ScaleDownModifications": [ 
      "cache.x.xxxx", 
      "cache.x.xxxx", 
      "cache.x.xxxx" 
      ] 
}
```

**Vertikale Skalierung für Memcached mit dem AWS-Managementkonsole**

Gehen Sie wie folgt vor, um mit dem einen AWS-Managementkonsole knotenbasierten Memcached-Cluster in einen vertikal skalierbaren Cluster umzuwandeln.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole unter. ElastiCache [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)

1. Wählen Sie den zu konvertierenden Memcached-Cluster aus.

1. Wählen Sie die Registerkarte **Ändern** aus.

1. Gehen Sie zum Abschnitt **Cache-Einstellungen** und wählen Sie den gewünschten **Knotentyp** aus.

1. Wählen Sie „**Änderungen in der Vorschau anzeigen**“ und überprüfen Sie die Änderungen.

1. Wählen Sie **Modify** aus.

## Automatisierte horizontale Skalierung für Memcached
<a name="Scaling-self-designed.mem-heading.horizontal"></a>

ElastiCache lässt sich jetzt in den Service AWS Application Auto Scaling (AAS) integrieren, um automatisierte horizontale Skalierung für Memcached-Cluster zu ermöglichen. Sie können Skalierungsrichtlinien über den AWS Application Auto Scaling Scaling-Dienst definieren und die Anzahl der Knoten in Memcached-Clustern automatisch nach Bedarf anpassen, basierend auf vordefinierten Metriken oder Zeitplänen.

**Anmerkung**  
Automatisierte horizontale Skalierung ist derzeit in den Regionen Peking und Ningxia nicht verfügbar. 

Dies sind die verfügbaren Methoden für die automatische horizontale Skalierung Ihrer knotenbasierten Cluster.
+ **Geplante Skalierung:** Die Skalierung auf der Grundlage eines Zeitplans ermöglicht es Ihnen, Ihren eigenen Skalierungsplan für vorhersehbare Laständerungen festzulegen. Angenommen, die Auslastung Ihrer Webanwendung steigt am Mittwoch, bleibt am Donnerstag auf diesem hohen Niveau und fällt am Freitag ab. Sie können Auto Scaling so konfigurieren, dass die Kapazität am Mittwoch erhöht und die Kapazität am Freitag verringert wird. 
+ **Zielverfolgung:** Bei Skalierungsrichtlinien für die Zielverfolgung wählen Sie eine Skalierungsmetrik und legen einen Zielwert fest. Application Auto Scaling erstellt und verwaltet die CloudWatch Alarme, die die Skalierungsrichtlinie auslösen, und berechnet die Skalierungsanpassung auf der Grundlage der Metrik und des Zielwerts. Durch die Skalierungsrichtlinie wird so viel Kapazität wie erforderlich hinzugefügt oder entfernt, damit die Metrik auf oder nahe an dem Zielwert gehalten wird. 

**So richten Sie die horizontale Skalierung für einen knotenbasierten Memcached-Cluster über die CLI ein**

Bei der horizontalen Skalierung eines knotenbasierten Memcached-Clusters können Sie eine Ziel-Tracking-Richtlinie, eine geplante Richtlinie oder beides verwenden.

1. **Registrieren Sie eine Ressource als skalierbares Ziel**

   Rufen Sie die `RegisterScalableTarget` API in AWS Application Auto Scaling auf, um das Ziel für die skalierbare Dimension zu registrieren`elasticache:cache-cluster:Nodes`. 

   **API: ApplicationAutoScaling.RegisterScalableTarget**

   Eingabe:

   ```
   {
   	"ScalableDimension": "elasticache:cache-cluster:Nodes",
   	"ResourceId": "cache-cluster/test-cluster-1",
   	"ServiceNamespace": "elasticache",
   	"MinCapacity": 20,  
   	"MaxCapacity": 50 
   }
   ```

1. **Erstellen Sie eine Skalierungsrichtlinie für Target-Tracking**

   Als Nächstes können Sie eine Skalierungsrichtlinie für die Zielverfolgung für die Ressource erstellen, indem Sie die Put-Skalierungsrichtlinien-API aufrufen. 

1. **Vordefinierte Metrik**

   Im Folgenden finden Sie eine Richtlinie, die entlang der Cache-Node-Dimension skaliert und dabei die vordefinierte Metrik verwendet` ElastiCacheCPUUtilization`, die für Cluster test-cluster-1 auf 50 festgelegt ist. Beim Löschen von Knoten für das Skalieren werden die letzten n Knoten entfernt.

   API: ApplicationAutoScaling.PutScalingPolicy

   Eingabe:

   ```
   {
   	"PolicyName": "cpu50-target-tracking-scaling-policy",
   	"PolicyType": "TargetTrackingScaling",
   	"TargetTrackingScalingPolicyConfiguration": {
   		"TargetValue": 50,
   		"PredefinedMetricSpecification": {
   			"PredefinedMetricType": "ElastiCacheCPUUtilization"
   			},
   		"ScaleOutCooldown": 600,
   		"ScaleInCooldown": 600
   			},
   	"ServiceNamespace": "elasticache",
   	"ScalableDimension": "elasticache:cache-cluster:Nodes",
   	"ResourceId": "cache-cluster/test-cluster-1"
   }
   ```

   Ausgabe:

   ```
   {
   	"PolicyARN": "arn:aws:autoscaling:us-west-2:012345678910:scalingPolicy:6d8972f3-efc8-437c-92d1-6270f29a66e7:resource/elasticache/cache-cluster/test-cluster-1:policyName/cpu50-target-tracking-scaling-policy",
   	"Alarms": [
   		{
   		"AlarmARN": "arn:aws:cloudwatch:us-west-2:012345678910:alarm:TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca",
   		"AlarmName": "TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca"
   		},
   		{
   		"AlarmARN": "arn:aws:cloudwatch:us-west-2:012345678910:alarm:TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmLow-1b437334-d19b-4a63-a812-6c67aaf2910d",
   		"AlarmName": "TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmLow-1b437334-d19b-4a63-a812-6c67aaf2910d"
   		}
   	]
   }
   ```

1. **Benutzerdefinierte Metrik**

   Sie können auch eine Skalierungsrichtlinie für die Dimension festlegen, indem Sie einen benutzerdefinierten Prozentsatz verwenden, der auf der Cloudwatch-Metrik basiert.

   Eingabe:

   ```
   {
   	"PolicyName": "cpu50-target-tracking-scaling-policy",
   	"PolicyType": "TargetTrackingScaling",
   	"TargetTrackingScalingPolicyConfiguration": {
   		"CustomizedMetricSpecification": { 
   			"Dimensions": [ 
   				{ 
   				"Name": "MyMetricDimension",
   				"Value": "DimensionValue"
   				}
   				],
   			"MetricName": "MyCustomMetric",
   			"Namespace": "MyNamespace",
   			"Statistic": "Average",
   			"Unit": "Percent"
   			},
   		"TargetValue": 40,
   		"ScaleOutCooldown": 600,
   		"ScaleInCooldown": 600
   		},
   	"ServiceNamespace": "elasticache",
   	"ScalableDimension": "elasticache:cache-cluster:Nodes",
   	"ResourceId": "cache-cluster/test-cluster-1"
   }
   ```

1. **Geplante Aktionen**

   Wenn Sie für ein bestimmtes Ereignis die Skalierung vornehmen und nach dem Ereignis wieder skalieren müssen, können Sie zwei geplante Aktionen erstellen, indem Sie die `PutScheduledAction` API aufrufen. 

   **Richtlinie 1: Skalierung**

   Der `at` Befehl in `--schedule` plant, dass die Aktion einmal an einem bestimmten Datum und zu einer bestimmten Uhrzeit in der future ausgeführt wird. Das Zeitplanfeld unterstützt auch Rate (Minute, Stunde, Tag usw.) und Cron (für Cron-Ausdruck).

   Zum angegebenen Datum und zur angegebenen Uhrzeit aktualisiert Application Auto Scaling die Werte `MinCapacity` und `MaxCapacity`. Application Auto Scaling skaliert MinCapacity auf bis zu 70 Cache-Knoten. 

   **API: ApplicationAutoScaling.PutScheduledAction**

   Eingabe:

   ```
   {
   	"ResourceId": "elasticache:ache-cluster:test-cluster-1",
   	"ScalableDimension": "elasticache:cache-cluster:Nodes",
   		"ScalableTargetAction": { 
   			"MaxCapacity": 100,
   			"MinCapacity": 70
   			},
   	"Schedule": "at(2020-05-20T17:05:00)",
   	"ScheduledActionName": "ScalingOutScheduledAction",
   	"ServiceNamespace": "elasticache",
   }
   ```

   **Richtlinie 2: Skalierung**

   Am angegebenen Datum und zur angegebenen Uhrzeit aktualisiert Application Auto Scaling die Werte `MinCapacity` und und skaliert auf `MaxCapacity``MaxCapacity`, sodass die Cache-Knoten wieder auf 60 zurückgesetzt werden.

   **API: ApplicationAutoScaling.PutScheduledAction**

   Eingabe:

   ```
   {
   	"ResourceId": "elasticache:cache-cluster:test-cluster-1",
   	"ScalableDimension": "elasticache:cache-cluster:Nodes",
   	"ScalableTargetAction": { 
   		"MaxCapacity": 60,
   		"MinCapacity": 40
   		},
   	"Schedule": "at(2020-05-21T17:05:00)",
   	"ScheduledActionName": "ScalingInScheduledAction",
   	"ServiceNamespace": "elasticache",
   }
   ```

1. **Sehen Sie sich die Skalierungsaktivitäten an**

   Sie können die Skalierungsaktivitäten mithilfe der `DescribeScalingActivities` API anzeigen. 

   **API: ApplicationAutoScaling.DescribeScalingActivities**

   Ausgabe:

   ```
   {
   	"ScalingActivities": [
   		{
   		"ScalableDimension": "elasticache:elasticache:DesiredCount",
   		"Description": "Setting desired count to 30.",
   		"ResourceId": "elasticache/cache-cluster/test-cluster-1",
   		"ActivityId": "4d759079-a31f-4d0c-8468-504c56e2eecf",
   		"StartTime": 1462574194.658,
   		"elasticacheNamespace": "elasticache",
   		"EndTime": 1462574276.686,
   		"Cause": "monitor alarm TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca in state ALARM triggered policy cpu50-target-tracking-scaling-policy",
   		"StatusMessage": "Failed to set desired count to 30",
   		"StatusCode": "Failed"
   		},
   		{
   		"ScalableDimension": "elasticache:elasticache:DesiredCount",
   		"Description": "Setting desired count to 25.",
   		"ResourceId": "elasticache/cache-cluster/test-cluster-1",
   		"ActivityId": "90aff0eb-dd6a-443c-889b-b809e78061c1",
   		"StartTime": 1462574254.223,
   		"elasticacheNamespace": "elasticache",
   		"EndTime": 1462574333.492,
   		"Cause": "monitor alarm TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca in state ALARM triggered policy cpu50-target-tracking-scaling-policy",
   		"StatusMessage": "Successfully set desired count to 25. Change successfully fulfilled by elasticache.",
   		"StatusCode": "Successful"
   		}
   	]
   }
   ```

1. **Edit/Delete Richtlinie zur Skalierung**

   Sie können Richtlinien bearbeiten oder löschen, indem Sie die `PutScalingPolicy` API erneut aufrufen `DeleteScalingPolicy` oder `DeleteScheduled` Action aufrufen. 

1. **De-register skalierbare Ziele**

   Sie können das skalierbare Ziel über die `DeregisterScalableTarget` API abmelden. Durch die Deregistrierung eines skalierbaren Ziels werden die Skalierungsrichtlinien und die damit verbundenen geplanten Aktionen gelöscht. 

   **API: ApplicationAutoScaling.DeregisterScalableTarget**

   Eingabe:

   ```
   {
   	"ResourceId": "elasticache/cache-cluster/test-cluster-1",
   	"ServiceNamespace": "elasticache",
   	"ScalableDimension": "elasticache:cache-cluster:Nodes"
   }
   ```

1. **Skalierung der Richtlinienbereinigung**

1. **Mehrere Skalierungsrichtlinien**

   Sie können mehrere Skalierungsrichtlinien erstellen. Im Folgenden finden Sie wichtige Hinweise zum Verhalten von [Auto Scaling Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html). 
   + Sie können mehrere Skalierungsrichtlinien für die Ziel-Nachverfolgung für ein skalierbares Ziel besitzen, vorausgesetzt, dass diese alle verschiedene Metriken verwenden.
   + Die Absicht von Application Auto Scaling ist es, der Verfügbarkeit immer Vorrang einzuräumen. Daher unterscheidet sich das Verhalten von Application Auto Scaling, je nachdem, ob die Ziel-Tracking-Richtlinien für die Skalierung nach außen oder nach innen bereit sind. Sofern Richtlinien für die Ziel-Nachverfolgung für die horizontale Skalierung nach oben bereit sind, findet eine horizontale Skalierung des skalierbaren Ziels nach oben statt. Eine horizontale Skalierung nach unten wird jedoch nur vorgenommen, wenn alle Richtlinien für die Ziel-Nachverfolgung (mit aktivierter horizontaler Skalierung nach unten) zur horizontalen Skalierung nach unten bereit sind. 
   + Wenn mehrere Richtlinien das skalierbare Ziel gleichzeitig zum Skalieren nach außen oder nach innen anweisen, erfolgt Application Auto Scaling auf der Grundlage der Richtlinie, die die größte Kapazität sowohl für die Skalierung nach innen als auch nach außen bietet. Dies bietet Ihnen eine größere Flexibilität für verschiedene Szenarien und stellt sicher, dass immer ausreichend Kapazität vorhanden ist, um Ihre Anwendungs-Workloads zu verarbeiten. 
**Anmerkung**  
AWS Application Auto Scaling stellt Skalierungsrichtlinien nicht in eine Warteschlange. Application Auto Scaling wartet, bis die erste Skalierung abgeschlossen ist, kühlt sich dann ab und wiederholt dann den obigen Algorithmus.

**Automatisches horizontales Skalieren eines knotenbasierten Memcached-Clusters über AWS-Managementkonsole**

Gehen Sie wie folgt vor, um mit dem einen vorhandenen AWS-Managementkonsole knotenbasierten Memcache-Cluster in einen horizontal skalierbaren Cluster umzuwandeln.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole unter. ElastiCache [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)

1. Wählen Sie den zu konvertierenden Memcached-Cache aus.

1. Gehen Sie zur Registerkarte **Autoscaling**.

1. Wählen Sie die anzuwendende Skalierungsrichtlinie aus, indem Sie entweder **Dynamische Skalierung hinzufügen oder Geplante Skalierung** **hinzufügen** auswählen.

1. Geben Sie nach Bedarf die Details für die ausgewählte Richtlinie ein.

1. Klicken Sie auf **Create**.