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.
# Serverloses Verwenden von Amazon DocumentDB
Amazon DocumentDB serverless ist eine On-Demand-Konfiguration mit auto Skalierung, die die Prozesse der dynamischen Anpassung der Kapazität Ihrer Amazon DocumentDB DocumentDB-Datenbank an die Anwendungsnachfrage automatisiert. Ihnen werden nur die Ressourcen in Rechnung gestellt, die Ihre Cluster verbrauchen. Somit kann DocumentDB serverless Ihnen helfen, Ihr Budget einzuhalten und zu vermeiden, für Computerressourcen zu bezahlen, die Sie nicht nutzen.
Diese Art der Automatisierung ist besonders nützlich für Umgebungen mit sehr variablen und unvorhersehbaren Workloads, wie z. B. Mehrmandantendatenbanken, verteilte Datenbanken sowie Entwicklungs- und Testsysteme.
**Topics**
+ [Anwendungsfälle für Serverless](#docdb-serverless-use-cases)
+ [Vorteile von Amazon DocumentDB serverlos](#docdb-serverless-advantages)
+ [Wie funktioniert Serverless](docdb-serverless-how-it-works.md)
+ [Serverlose Anforderungen und Einschränkungen](docdb-serverless-limitations.md)
+ [Einen Cluster erstellen, der Serverless verwendet](docdb-serverless-create-cluster.md)
+ [Migration zu serverlosem System](docdb-serverless-migrating.md)
+ [Verwaltung von serverlosen Systemen](docdb-serverless-managing.md)
+ [Limits für serverlose Instances](docdb-serverless-instance-limits.md)
+ [Konfiguration für serverlose Skalierung](docdb-serverless-scaling-config.md)
+ [Serverlose Überwachung](docdb-serverless-monitoring.md)
## Anwendungsfälle für serverlose DocumentDB
Sowohl von Amazon DocumentDB bereitgestellte Cluster als auch DocumentDB serverless unterstützen viele Arten von Datenbank-Workloads, von Entwicklungs- und Testumgebungen bis hin zu den anspruchsvollsten, geschäftskritischen Anwendungen, die eine hohe Skalierbarkeit und Verfügbarkeit erfordern. DocumentDB serverless erweitert die Workloads der Kunden jedoch um eine weitere Dimension, nämlich die Fähigkeit, Websites und Anwendungen mit unvorhersehbaren Workloads zu unterstützen.
DocumentDB serverless ist besonders nützlich für die folgenden Anwendungsfälle:
+ **Variable Workloads** — Sie führen Workloads aus, bei denen die Aktivität plötzlich und unvorhersehbar zunimmt. Ein Beispiel dafür ist eine Verkehrs-Website, für die Aktivitätsspitzen entstehen, wenn es zu regnen beginnt. Eine andere ist eine E-Commerce-Website mit erhöhtem Datenverkehr, wenn Sie Verkaufs- oder Sonderaktionen anbieten. Mit DocumentDB serverless skaliert Ihre Datenbank automatisch die Kapazität, um den Anforderungen der Spitzenlast der Anwendung gerecht zu werden, und wird wieder herunterskaliert, wenn der Aktivitätsschub vorbei ist. Mit DocumentDB serverless müssen Sie keine Spitzen- oder Durchschnittskapazitäten mehr bereitstellen. Sie können eine obere Kapazitätsgrenze angeben, um die schlimmste Situation zu bewältigen. Diese Kapazität wird nur genutzt, wenn sie benötigt wird.
+ Die Granularität der Skalierung in DocumentDB serverless hilft Ihnen dabei, die Kapazität genau an die Anforderungen Ihrer Datenbank anzupassen. Für einen bereitgestellten Cluster erfordert die Skalierung das Hinzufügen einer ganz neuen Instanz. DocumentDB serverless kann eine halbe DCU hinzufügen, wenn nur etwas mehr Kapazität benötigt wird. Je DCUs nach der zusätzlichen Kapazität, die zur Bewältigung einer erhöhten Arbeitslast benötigt wird, können 0,5, 1, 1,5, 2 oder weitere Hälfte hinzugefügt werden. Und es kann 0,5, 1, 1,5, 2 oder zusätzliche Hälfte entfernen, DCUs wenn die Arbeitslast abnimmt und diese Kapazität nicht mehr benötigt wird.
+ **Mehrinstanzenanwendungen** — Mit DocumentDB serverless müssen Sie die Datenbankkapazität nicht für jede Anwendung in Ihrer Flotte einzeln verwalten. DocumentDB serverless verwaltet individuelle Datenbankkapazitäten für Sie.
+ Sie können einen Cluster für jeden Mandanten erstellen. Auf diese Weise können Sie Funktionen wie Klonen und Snapshot-Wiederherstellung verwenden, um die Hochverfügbarkeit und die Notfallwiederherstellung für jeden Mandanten entsprechend zu verbessern.
+ Jeder Mandant kann je nach Tageszeit, Jahreszeit, Werbeveranstaltungen usw. bestimmte Perioden mit hoher und geringer Aktivität haben. Jeder Cluster kann einen großen Kapazitätsbereich aufweisen. Auf diese Weise fallen für Cluster mit geringer Aktivität nur minimale Instanzgebühren an. Jeder Cluster kann schnell hochskaliert werden, um Perioden mit hoher Aktivität zu bewältigen.
+ **Neue Anwendungen** — Sie stellen eine neue Anwendung bereit und sind sich nicht sicher, welche Instance-Größe Sie benötigen. Wenn Sie DocumentDB serverless verwenden, können Sie einen Cluster mit einer oder mehreren Instanzen einrichten und die Datenbank automatisch an die Kapazitätsanforderungen Ihrer Anwendung anpassen lassen.
+ **Anwendungen mit gemischter Nutzung** — Nehmen wir an, Sie haben eine OLTP-Anwendung (Online Transaction Processing), aber Sie erleben regelmäßig Spitzenwerte im Abfrageverkehr. Indem Sie Upgrade-Stufen für die serverlosen DocumentDB-Instances in einem Cluster angeben, können Sie Ihren Cluster so konfigurieren, dass die Reader-Instances unabhängig von der Writer-Instanz skaliert werden können, um die zusätzliche Last zu bewältigen. Wenn der Nutzungsanstieg nachlässt, werden die Reader-Instances wieder herunterskaliert, um sie an die Kapazität der Writer-Instanz anzupassen.
+ **Kapazitätsplanung** — Nehmen wir an, dass Sie in der Regel Ihre Datenbankkapazität anpassen oder die optimale Datenbankkapazität für Ihre Arbeitslast überprüfen, indem Sie die Instance-Klassen aller Instances in einem Cluster ändern. Mit DocumentDB serverless können Sie diesen administrativen Aufwand vermeiden. Sie können die entsprechende Mindest- und Höchstkapazität ermitteln, indem Sie den Workload ausführen und überprüfen, wie stark die Instanzen tatsächlich skalieren.
+ Sie können bestehende Instanzen von bereitgestellt zu DocumentDB serverlos oder von DocumentDB serverlos zu bereitgestellt ändern. In solchen Fällen müssen Sie keinen neuen Cluster oder eine neue Instanz erstellen.
+ **Entwicklung und Testen** — Neben der Ausführung Ihrer anspruchsvollsten Anwendungen können Sie DocumentDB auch serverlos für Entwicklungs- und Testumgebungen verwenden. Mit DocumentDB serverless können Sie Instanzen mit einer niedrigen Mindestkapazität erstellen, anstatt burstable db.t\$1-Instanzklassen zu verwenden. Sie können die maximale Kapazität so hoch einstellen, dass diese Instanzen trotzdem umfangreiche Workloads ausführen können, ohne dass der Arbeitsspeicher knapp wird. Wenn die Datenbank nicht verwendet wird, werden alle Instanzen herunterskaliert, um unnötige Gebühren zu vermeiden.
### Serverlose Nutzung von Amazon DocumentDB für bestehende bereitgestellte Workloads
Angenommen, Sie haben bereits eine DocumentDB-Anwendung, die auf einem bereitgestellten Cluster ausgeführt wird. Sie können überprüfen, wie die Anwendung mit DocumentDB serverless funktionieren würde, indem Sie dem vorhandenen Cluster eine oder mehrere serverlose DocumentDB-Instanzen als Reader-Instanzen hinzufügen. Sie können überprüfen, wie oft die Reader-Instanzen nach oben oder unten skaliert werden. Sie können den DocumentDB-Failover-Mechanismus verwenden, um eine serverlose DocumentDB-Instanz zum Autor hochzustufen und zu überprüfen, wie sie mit der Arbeitslast umgeht. read/write Auf diese Weise können Sie mit minimalen Ausfallzeiten und ohne Ändern des Endpunkts, den Ihre Clientanwendungen verwenden, umstellen. Einzelheiten zum Verfahren zur Konvertierung vorhandener Cluster in serverlose DocumentDB-Cluster finden Sie unter. [Migration zu Amazon DocumentDB serverlos](docdb-serverless-migrating.md)
## Vorteile von Amazon DocumentDB serverlos
DocumentDB serverless ist für variable oder „stachelige“ Workloads vorgesehen. Bei solch unvorhersehbaren Workloads haben Sie möglicherweise Schwierigkeiten zu planen, wann Ihre Datenbankkapazität geändert werden soll. Möglicherweise haben Sie auch Probleme, Kapazitätsänderungen schnell genug vorzunehmen, indem Sie die bekannten Mechanismen wie das Hinzufügen von Instanzen oder das Ändern von Instanzklassen verwenden. DocumentDB serverless bietet die folgenden Vorteile, um bei solchen Anwendungsfällen zu helfen:
+ **Einfacheres Kapazitätsmanagement als bereitgestellt** — DocumentDB serverless reduziert den Aufwand für die Planung der Instanzgrößen und die Größenänderung von Instanzen, wenn sich die Arbeitslast ändert. Es reduziert auch den Aufwand für die Aufrechterhaltung einer konsistenten Kapazität für alle Instanzen in einem Cluster.
+ **Schnellere und einfachere Skalierung in Zeiten hoher Aktivität** — DocumentDB serverless skaliert die Rechen- und Speicherkapazität nach Bedarf, ohne dass die Kundentransaktionen oder Ihre gesamte Arbeitslast unterbrochen werden. Die Möglichkeit, Reader-Instanzen mit DocumentDB serverless zu verwenden, hilft Ihnen, zusätzlich zur vertikalen Skalierung auch die Vorteile der horizontalen Skalierung zu nutzen. Die Möglichkeit, globale DocumentDB-Cluster zu verwenden, bedeutet, dass Sie Ihren serverlosen DocumentDB-Lese-Workload auf mehrere verteilen können. AWS-Regionen Diese Fähigkeit ist bequemer als die Skalierungsmechanismen für bereitgestellte Cluster.
+ **Kostengünstig in Zeiten geringer Aktivität** — DocumentDB serverless hilft Ihnen, eine Überprovisionierung Ihrer Instanzen zu vermeiden. DocumentDB serverless fügt Ressourcen in granulierten Schritten hinzu, wenn Instanzen skaliert werden. Sie zahlen nur für die Datenbankressourcen, die Sie verbrauchen. Die Nutzung serverloser DocumentDB-Ressourcen wird pro Sekunde gemessen. Auf diese Weise wird die reduzierte Ressourcennutzung sofort registriert, wenn eine Instanz herunterskaliert wird.
+ **Funktionsparität mit bereitgestellten** Funktionen — Sie können alle DocumentDB-Funktionen mit DocumentDB serverless verwenden. Mit DocumentDB serverless können Sie beispielsweise Reader-Instanzen, AWS Identity and Access Management (IAM) -Datenbankauthentifizierung und Performance Insights verwenden.
Insbesondere mit DocumentDB serverless können Sie die folgenden Funktionen von bereitgestellten Clustern nutzen:
+ **Reader-Instanzen** — DocumentDB serverless kann Reader-Instanzen nutzen, um horizontal zu skalieren. Wenn ein Cluster eine oder mehrere Reader-Instanzen enthält, kann der Cluster bei Problemen mit der Writer-Instanz sofort ein Failover durchführen.
+ **Multi-AZ-Cluster** — Sie können die serverlosen DocumentDB-Instanzen eines Clusters auf mehrere Availability Zones () verteilen. AZs Die Einrichtung eines Multi-AZ-Clusters trägt dazu bei, die Geschäftskontinuität auch in seltenen Fällen von Problemen sicherzustellen, die eine gesamte AZ betreffen.
+ **Globale Cluster** — Sie können DocumentDB serverless in Kombination mit globalen DocumentDB-Clustern verwenden, um für Disaster Recovery-Zwecke zusätzliche schreibgeschützte Kopien Ihres Clusters in anderen AWS-Regionen zu erstellen.
# So funktioniert Amazon DocumentDB serverless
**Topics**
+ [-Übersicht](#docdb-serverlerss-overviewn)
+ [Konfigurationen für Amazon DocumentDB-Cluster](#docdb-serverlerss-configuration)
+ [Serverlose Skalierungskapazität von Amazon DocumentDB](#docdb-serverless-scaling-capacity)
+ [Serverlose Skalierung von Amazon DocumentDB](#docdb-serverless-scaling)
+ [Ruhezustand (0.5 DCUs)](#docdb-serverlerss-idle-state)
## -Übersicht
Amazon DocumentDB serverless eignet sich für die anspruchsvollsten, sehr variablen Workloads. Zum Beispiel könnte Ihre Datenbanknutzung für einen kurzen Zeitraum sehr hoch sein, gefolgt von langen Zeiträumen mit nur leichter oder gar keiner Aktivität. Beispiele hierfür sind Einzelhandels-Websites, Spiele oder Sportveranstaltungen mit regelmäßigen Werbeveranstaltungen sowie Datenbanken, die nach Bedarf Berichte erstellen. Andere Beispiele sind Entwicklungs- und Testumgebungen sowie neue Anwendungen, in denen die Nutzung schnell ansteigen könnte. In Fällen wie diesen und vielen anderen ist es mit dem bereitgestellten Modell nicht immer möglich, die Kapazität vorab korrekt zu konfigurieren. Es können auch höhere Kosten entstehen, wenn Sie zu viel Kapazität bereitstellen, die Sie dann nicht benötigen.
Im Gegensatz dazu eignen sich von DocumentDB bereitgestellte Cluster für stetige Workloads. Bei bereitgestellten Clustern wählen Sie eine Instanzklasse aus, die über eine vordefinierte Menge an Arbeitsspeicher, CPU-Leistung, I/O Bandbreite usw. verfügt. Wenn sich Ihre Workload ändert, ändern Sie die Instance-Klasse Ihres Writers und Ihrer Readers manuell. Das bereitgestellte Modell funktioniert gut, wenn Sie die Kapazität im Vorfeld der erwarteten Verbrauchsmustern anpassen können. Es ist akzeptabel, dass kurze Ausfälle auftreten, während Sie die Instance-Klasse des Writers und der Reader in Ihrem Cluster ändern.
DocumentDB Serverless wurde von Grund auf so konzipiert, dass es serverlose Cluster unterstützt, die sofort skalierbar sind. DocumentDB serverless wurde so konzipiert, dass es das gleiche Maß an Sicherheit und Isolierung bietet wie bereitgestellte Writer und Reader. Diese Aspekte sind in serverlosen Cloud-Umgebungen mit mehreren Mandanten entscheidend. Der dynamische Skalierungsmechanismus umfasst sehr wenig Aufwand, sodass er schnell auf Änderungen der Datenbank-Workload reagieren kann. Er bietet auch genügend Leistung, um einen drastischen Anstieg beim Bedarf nach Rechenleistung zu meistern.
Wenn Sie DocumentDB serverless verwenden, können Sie einen DocumentDB-Cluster erstellen, ohne an eine bestimmte Datenbankkapazität für jeden Writer und Reader gebunden zu sein. Sie geben den minimalen und maximalen Bereich für die Kapazität an. DocumentDB skaliert jeden serverlosen DocumentDB-Writer oder -Leser im Cluster innerhalb dieses Kapazitätsbereichs. Durch die Verwendung eines Multi-AZ-Clusters, in dem jeder Writer oder Reader dynamisch skalieren kann, können Sie die dynamische Skalierung und Hochverfügbarkeit nutzen.
DocumentDB serverless skaliert die Datenbankressourcen automatisch auf der Grundlage Ihrer Mindest- und Höchstkapazitätsspezifikationen. Die Skalierung ist schnell, da die meisten Skalierungsereignisoperationen den Writer oder Reader auf demselben Host halten. In den seltenen Fällen, in denen ein serverloser DocumentDB-Writer oder -Leser von einem Host auf einen anderen verschoben wird, verwaltet DocumentDB serverless die Verbindungen automatisch. Sie müssen Ihren Datenbank-Client-Anwendungscode oder Ihre Datenbank-Verbindungszeichenfolgen nicht ändern.
Bei DocumentDB Serverless sind, wie bei bereitgestellten Clustern, Speicherkapazität und Rechenkapazität getrennt. Wenn wir von serverloser Kapazität und Skalierung von DocumentDB sprechen, ist es immer die Rechenkapazität, die zunimmt oder sinkt. Somit kann Ihr Cluster viele Terabyte an Daten enthalten, auch wenn die CPU und Speicherkapazität auf ein niedriges Niveau herunterskalieren.
Anstelle der Bereitstellung und Verwaltung von Datenbankservern geben Sie die Datenbankkapazität an. Die tatsächliche Kapazität der serverlosen DocumentDB-Writer oder -Lesegeräte variiert je nach Arbeitslast im Laufe der Zeit. Details zu diesem Mechanismus finden Sie unter [Serverlose Skalierung von Amazon DocumentDB](#docdb-serverless-scaling).
## Konfigurationen für Amazon DocumentDB-Cluster
Für jeden Ihrer Amazon DocumentDB-Cluster können Sie eine beliebige Kombination aus serverloser DocumentDB-Kapazität, bereitgestellter Kapazität oder beidem wählen.
Sie können einen Cluster einrichten, der sowohl serverlose als auch bereitgestellte DocumentDB-Kapazität enthält. Dies wird als Cluster mit gemischter Konfiguration bezeichnet. Nehmen wir beispielsweise an, dass Sie mehr read/write Kapazität benötigen, als für einen serverlosen DocumentDB-Writer verfügbar ist. In diesem Fall können Sie den Cluster mit einem sehr großen bereitgestellten Writer einrichten. Dann können Sie DocumentDB weiterhin serverlos für die Leser verwenden. Oder nehmen Sie an, dass die Schreib-Workload für Ihren Cluster variiert, die Lese-Workload jedoch stabil ist. In diesem Fall können Sie Ihren Cluster mit einem serverlosen DocumentDB-Writer und einem oder mehreren bereitgestellten Lesegeräten einrichten.
Sie können auch einen Cluster einrichten, in dem die gesamte Kapazität von DocumentDB serverless verwaltet wird. Dazu können Sie einen neuen Cluster erstellen und DocumentDB von Anfang an serverless verwenden. Oder Sie können die gesamte bereitgestellte Kapazität in einem vorhandenen Cluster durch DocumentDB serverless ersetzen. Die Verfahren zum Erstellen eines neuen Clusters mit DocumentDB serverless oder zum Umstellen eines vorhandenen Clusters auf DocumentDB serverless finden Sie unter und. [Einen Cluster erstellen, der Amazon DocumentDB serverless verwendet](docdb-serverless-create-cluster.md) [Migration zu Amazon DocumentDB serverlos](docdb-serverless-migrating.md)
Wenn Sie DocumentDB in einem Cluster überhaupt nicht serverlos verwenden, werden alle Writer und Reader im Cluster bereitgestellt. Dies ist der häufigste Clustertyp, mit dem die meisten Benutzer vertraut sind. Die bereitgestellte Kapazität ist konstant. Die Gebühren sind relativ einfach zu prognostizieren. Sie müssen jedoch im Vorfeld prognostizieren, wie viel Kapazität Sie benötigen. In einigen Fällen sind Ihre Prognosen möglicherweise ungenau oder Ihr Kapazitätsbedarf kann sich ändern. In diesen Fällen kann Ihr Cluster unterprovisioniert (langsamer als gewünscht) oder überprovisioniert (teurer als gewünscht) werden.
## Serverlose Skalierungskapazität von Amazon DocumentDB
Die Maßeinheit für Amazon DocumentDB serverless ist die DocumentDB Capacity Unit (DCU). Die serverlose Skalierungskapazität von DocumentDB ist nicht an die Instanzklassen gebunden, die Sie für bereitgestellte Cluster verwenden.
Jede DCU ist eine Kombination aus ungefähr 2 Gibibyte (GiB) Arbeitsspeicher, entsprechender CPU und Netzwerk. Mit dieser Maßeinheit geben Sie den Kapazitätsbereich der Datenbank an. Die Metriken `ServerlessDatabaseCapacity` und `DCUUtilization` CloudWatch helfen Ihnen festzustellen, wie viel Kapazität Ihre Datenbank tatsächlich nutzt und wo diese Kapazität innerhalb des angegebenen Bereichs liegt.
Jeder serverlose DocumentDB-Writer oder -Leser verfügt zu jedem Zeitpunkt über eine Kapazität. Bei der Kapazität handelt es sich um eine Gleitkommazahl, die Folgendes darstellt: DCUs Die Kapazität steigt oder nimmt ab, sobald der Writer oder Reader skaliert. Dieser Wert wird jede Sekunde gemessen. Für jeden Cluster, in dem Sie DocumentDB serverless verwenden möchten, definieren Sie einen Kapazitätsbereich: die minimalen und maximalen Kapazitätswerte, zwischen denen jeder serverlose DocumentDB-Writer oder -Leser skalieren kann. Der Kapazitätsbereich ist für jeden serverlosen DocumentDB-Writer oder -Leser in einem Cluster derselbe. Jeder serverlose DocumentDB-Writer oder -Leser hat seine eigene Kapazität, die irgendwo in diesem Bereich liegt.
DocumentDB serverless wird nur auf DocumentDB 5.0.0 (nicht unterstützt auf 8.0) mit einem Kapazitätsbereich von 0,5 bis 256 unterstützt. DCUs
Die kleinste serverlose DocumentDB-Kapazität, die Sie definieren können, ist 0,5. DCUs Sie können eine höhere Zahl angeben, wenn sie kleiner oder gleich dem Wert für die maximal unterstützte Kapazität ist. Wenn Sie die Mindestkapazität auf einen kleinen Wert festlegen, verbrauchen leicht ausgelastete Cluster nur minimale Rechenressourcen. Gleichzeitig bleiben sie bereit, Verbindungen sofort anzunehmen und hochzuskalieren, wenn ihre Aktivität ansteigt.
Wir empfehlen, den Mindestwert auf einen Wert festzulegen, der es jedem Autor oder Leser ermöglicht, den Arbeitssatz der Anwendung im Pufferpool zu speichern. Auf diese Weise wird der Inhalt des Pufferpools in Zeiten geringer Aktivität nicht verworfen. Alle Überlegungen zur Auswahl des Skalierungskapazitätsbereichs finden Sie unter[Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](docdb-serverless-scaling-config.md#docdb-serverless-scaling-capacity-choosing).
Je nachdem, wie Sie die Reader in einer Multi-AZ-Bereitstellung konfigurieren, können die Kapazitäten an die Kapazität des Writers gebunden oder davon unabhängig sein. Weitere Informationen zur Vorgehensweise finden Sie unter [Die Promotion-Stufe für serverlose Lesegeräte anzeigen und ändern](docdb-serverless-managing.md#docdb-serverless-promo-tier).
Bei der serverlosen Überwachung von DocumentDB werden die Kapazitätswerte für den Writer und die Reader in Ihrem Cluster im Laufe der Zeit gemessen. Wenn Ihre Datenbank nicht auf die Mindestkapazität herunterskaliert, können Sie Maßnahmen ergreifen, z. B. den minimalen Wert anpassen und Ihre Datenbankanwendung optimieren. Wenn Ihre Datenbank ihre maximale Kapazität konsequent erreicht, können Sie Maßnahmen wie die Erhöhung des maximalen Werts ergreifen. Sie können auch Ihre Datenbankanwendung optimieren und die Abfragelast auf mehr Reader verteilen.
Die Gebühren für serverlose DocumentDB-Kapazitäten werden in DCU-Stunden gemessen. Informationen zur Berechnung der Gebühren für serverlose DocumentDB-Dienste finden Sie unter [Amazon DocumentDB DocumentDB-Preise](https://aws.amazon.com//documentdb/pricing). Nehmen wir an, dass die Gesamtzahl der Writer und Reader in Ihrem Cluster n beträgt. In diesem Fall verbraucht der Cluster mindestens n x, DCUs wenn Sie keine Datenbankoperationen ausführen. Amazon DocumentDB selbst führt möglicherweise Überwachungs- oder Wartungsvorgänge durch, die eine geringe Belastung verursachen. Dieser Cluster verbraucht maximal n x, DCUs wenn die Datenbank mit voller Kapazität läuft.
Weitere Informationen zur Auswahl geeigneter minimaler und maximaler DCU-Werte finden Sie unter. [Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](docdb-serverless-scaling-config.md#docdb-serverless-scaling-capacity-choosing) Die von Ihnen angegebenen minimalen und maximalen DCU-Werte wirken sich auch auf einige Amazon DocumentDB DocumentDB-Instance-Limits aus. Einzelheiten zur Interaktion zwischen dem Kapazitätsbereich und den Instance-Limits finden Sie unter. [Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md)
## Serverlose Skalierung von Amazon DocumentDB
Für jeden serverlosen DocumentDB-Writer oder -Leser verfolgt Amazon DocumentDB kontinuierlich die Nutzung von Ressourcen wie CPU, Arbeitsspeicher und Netzwerk. Diese Messungen werden zusammen als Last bezeichnet. Die Last umfasst die von Ihrer Anwendung ausgeführten Datenbankoperationen. Es umfasst auch die Hintergrundverarbeitung für den Datenbankserver und Verwaltungsaufgaben von Amazon DocumentDB. Wenn die Kapazität durch einen dieser Faktoren eingeschränkt wird, wird DocumentDB serverless skaliert. DocumentDB serverless skaliert auch, wenn es Leistungsprobleme erkennt, die es auf diese Weise lösen kann. Sie können die Ressourcennutzung und ihre Auswirkungen auf die serverlose Skalierung von DocumentDB überwachen, indem Sie die Verfahren unter verwenden. [Serverlose Überwachung von Amazon DocumentDB](docdb-serverless-monitoring.md)
Die Auslastung kann je nach Writer und Reader in Ihrem Cluster variieren. Der Writer verarbeitet Schreibvorgänge und führt alle Datenänderungen am Cluster-Volume durch. Leser können Anfragen nur mit Leserechten bearbeiten.
Skalierung ist der Vorgang, mit dem die serverlose Kapazität von DocumentDB für Ihre Datenbank erhöht oder verringert wird. Mit DocumentDB serverless hat jeder Writer und Reader seinen eigenen aktuellen Kapazitätswert, gemessen in. DCUs DocumentDB serverless skaliert einen Writer oder Reader auf eine höhere Kapazität, wenn die aktuelle Kapazität zu gering ist, um die Last zu bewältigen. Der Writer oder Reader wird auf eine geringere Kapazität skaliert, wenn seine aktuelle Kapazität höher als erforderlich ist.
DocumentDB serverless kann die Kapazität schrittweise erhöhen. Wenn Ihr Workload-Bedarf die aktuelle Datenbankkapazität eines Schreibers oder Lesers erreicht, erhöht DocumentDB serverless die Anzahl der DCUs für diesen Writer oder Reader. DocumentDB serverless skaliert die Kapazität in den Schritten, die erforderlich sind, um die beste Leistung für die verbrauchten Ressourcen zu erzielen. Die Skalierung erfolgt in Schritten von nur 0,5. DCUs Je größer die aktuelle Kapazität, desto größer ist das Skalierungsinkrement und desto schneller kann die Skalierung erfolgen.
Da die serverlose Skalierung von DocumentDB so häufig, detailliert und unterbrechungsfrei erfolgt, verursacht sie keine diskreten Ereignisse in der. AWS-Managementkonsole Stattdessen können Sie die CloudWatch Amazon-Metriken wie `serverlessDatabaseCapacity` und messen und `DCUUtilization` deren Mindest-, Höchst- und Durchschnittswerte im Zeitverlauf verfolgen. Weitere Informationen zur serverlosen Überwachung von DocumentDB finden Sie unter. [Serverlose Überwachung von Amazon DocumentDB](docdb-serverless-monitoring.md)
Das Hoch- oder Herunterskalieren kann folgende Ursachen haben:
+ Speichernutzung
+ CPU-Auslastung
+ Netzwerkauslastung
+ Speichernutzung
Sie können diese Ursachen der Skalierung up/down auf serverlosen DocumentDB-Instanzen überwachen. Weitere Informationen finden Sie unter [Serverlose Überwachung von Amazon DocumentDB](docdb-serverless-monitoring.md).
Sie können wählen, ob ein Reader gleichzeitig mit dem zugehörigen Writer oder unabhängig vom Writer skalieren soll. Dazu geben Sie die Hochstufungsstufe für diesen Reader an.
+ Serverlose DocumentDB-Lesegeräte der Promotion-Stufen 0 und 1 skalieren zur gleichen Zeit wie der Writer. Dieses Skalierungsverhalten macht Reader in den Prioritätsstufen 0 und 1 ideal verfügbar. Das liegt daran, dass sie immer auf die richtige Kapazität dimensioniert sind, um die Workload des Writers im Falle eines Failovers zu übernehmen.
+ Reader der Hochstufungsstufen 2 bis 15 skalieren unabhängig vom Writer. Jeder Leser bleibt innerhalb der minimalen und maximalen DCU-Werte, die Sie für Ihren Cluster angegeben haben. Wenn ein Reader unabhängig von der zugehörigen Writer-DB skaliert, kann er inaktiv werden und herunterskalieren, während der Writer weiterhin ein hohes Transaktionsvolumen verarbeitet. Er ist nach wie vor als Failover-Ziel verfügbar, wenn keine anderen Reader in niedrigeren Hochstufungsstufen zur Verfügung stehen. Wenn der Reader jedoch zum Writer hochgestuft wird, muss er möglicherweise hochskalieren, um die volle Workload des Writers zu bewältigen.
Weitere Informationen zum Anzeigen und Ändern von Promotion-Stufen für serverlose Instances finden Sie unter. [Die Promotion-Stufe für serverlose Lesegeräte anzeigen und ändern](docdb-serverless-managing.md#docdb-serverless-promo-tier)
Die serverlose Skalierung von DocumentDB kann erfolgen, während Datenbankverbindungen geöffnet sind, während Transaktionen ausgeführt werden usw. DocumentDB serverless wartet nicht auf einen ruhigen Punkt, um mit der Skalierung zu beginnen. Die Skalierung unterbricht keine laufenden Datenbankoperationen.
Wenn Ihr Workload mehr Lesekapazität benötigt, als mit einem einzelnen Writer und einem einzelnen Reader verfügbar ist, können Sie dem Cluster mehrere serverlose DocumentDB-Reader hinzufügen. Jeder serverlose DocumentDB-Reader kann innerhalb des Bereichs der Mindest- und Höchstkapazitätswerte skaliert werden, die Sie für Ihren Cluster angegeben haben. Sie können den Reader-Endpunkt des Clusters verwenden, um schreibgeschützte Sitzungen an die Reader zu leiten und die Last des Writers zu reduzieren.
Ob DocumentDB serverless die Skalierung durchführt und wie schnell die Skalierung nach dem Start erfolgt, hängt auch von den minimalen und maximalen DCU-Einstellungen für den Cluster ab. Darüber hinaus hängt es davon ab, ob ein Reader so konfiguriert ist, dass er zusammen mit dem Writer oder unabhängig davon skaliert wird. Einzelheiten zur Skalierungskonfiguration finden Sie unter. [Serverlose Skalierungskonfiguration von Amazon DocumentDB](docdb-serverless-scaling-config.md)
## Ruhezustand (0.5 DCUs)
Wenn serverlose Amazon DocumentDB DocumentDB-Writer oder -Lesegeräte inaktiv sind, unterstützen serverlose DocumentDB-Instances das Herunterskalieren auf einen Leerlaufstatus von 0,5, DCUs wenn der Cluster auf 0,5 konfiguriert MinCapacity ist.
Im Ruhezustand verfügen die serverlosen DocumentDB-Instanzen nicht über genügend CPU-Rechenkapazität, um die meisten Produktionsworkloads zu unterstützen, können aber schnell hochskaliert werden, um eine neue Arbeitslast zu unterstützen. In einem Zustand ohne Leerlauf benötigen serverlose DocumentDB-Instanzen in der Regel mindestens 1,0 bis 2,5. DCUs Wenn serverlose DocumentDB-Instanzen von einem Ruhezustand in einen Nicht-Ruhezustand hochskaliert werden, werden sie daher direkt auf 1,0 bis 2,5 DCUs (oder den Wert von, MaxCapacity falls dieser niedriger ist) hochskaliert.
Um das Herunterskalieren auf 0,5 DCUs im Leerlauf zu unterstützen, werden die Instanzlimits begrenzt, wenn der so konfiguriert MinCapacity ist, dass er kleiner oder gleich 1,0 ist. DCUs Weitere Informationen darüber, wie sich die MinCapacity Konfiguration auf die Limits auswirkt, finden Sie unter[Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md).
# Anforderungen und Einschränkungen für DocumentDB serverless
## Anforderungen an die Funktionen
### Verfügbarkeit in Regionen
Der serverlose Instance-Typ Amazon DocumentDB ist in den folgenden Regionen verfügbar:
Der folgende AWS CLI Befehl kann verwendet werden, um die genauen Optionen für serverlose DocumentDB-Instanzen zu überprüfen, die in einer bestimmten Region angeboten werden:
```
aws docdb describe-orderable-db-instance-options \
--region my_region \
--db-instance-class db.serverless \
--engine docdb
```
### Verfügbarkeit der Engine-Version
DocumentDB serverless wird nur von der Engine-Version Amazon DocumentDB 5.0.0 unterstützt. Sie ist in den Engine-Versionen 3.6, 4.0 oder 8.0 nicht verfügbar.
**Anmerkung**
DocumentDB serverless wird nur auf neueren Patch-Versionen von 5.0.0 unterstützt. Bitte stellen Sie sicher, dass Ihr Cluster auf eine aktuelle Engine-Patch-Version aktualisiert wurde. Weitere Informationen zur Verwaltung von Amazon DocumentDB-Clustern finden Sie unter [Wartung von Amazon DocumentDB](db-instance-maintain.md)
### Cluster-Konfiguration
Bevor Sie serverlose Amazon DocumentDB-Instances zu einem Amazon DocumentDB-Cluster hinzufügen, muss für den Cluster auch der `ServerlessV2ScalingConfiguration` Parameter festgelegt sein. Dies definiert den Kapazitätsbereich der serverlosen DocumentDB-Instanzen im Cluster. Weitere Informationen zur Skalierungskonfiguration finden Sie unter. [Serverlose Skalierungskonfiguration von Amazon DocumentDB](docdb-serverless-scaling-config.md)
### Einstellungen für den minimalen Skalierungskapazitätsbereich für bestimmte Amazon DocumentDB DocumentDB-Funktionen
Einige Amazon DocumentDB DocumentDB-Funktionen funktionieren mit DocumentDB serverlos, können jedoch Probleme verursachen, wenn Ihr Kapazitätsbereich für die Speicheranforderungen für diese Funktionen mit Ihrer spezifischen Arbeitslast geringer ist als erforderlich. In diesem Fall funktioniert Ihre Datenbank möglicherweise nicht so gut wie gewohnt oder es können Fehler auftreten. out-of-memory
Die folgenden Funktionen erfordern für einen optimalen Betrieb eine Konfiguration mit einem höheren `MinCapacity` and/or `MaxCapacity` Wert:
+ Performance Insights
+ Globale Cluster (gilt nur für die primären AWS-Region)
+ Serverlose Instanzerstellung auf einem Cluster mit einem großen Datenvolumen
Dies beinhaltet die serverlose Instanzerstellung im Rahmen einer Cluster-Wiederherstellung.
Empfehlungen zur Einstellung des geeigneten Kapazitätsbereichs (falls Sie diese Funktion verwenden) finden Sie unter[Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](docdb-serverless-scaling-config.md#docdb-serverless-scaling-capacity-choosing). Informationen zur Problembehandlung, wenn in Ihrer Datenbank aufgrund eines falsch konfigurierten Kapazitätsbereichs out-of-memory Fehler auftreten, finden Sie unter[Vermeiden von out-of-memory Fehlern](docdb-serverless-scaling-config.md#docdb-serverless-scaling-mem-errors).
# Einen Cluster erstellen, der Amazon DocumentDB serverless verwendet
## Einen serverlosen Amazon DocumentDB-Cluster erstellen
Mit Amazon DocumentDB serverlos sind Ihre Cluster mit bereitgestellten Clustern austauschbar. Sie können Cluster einrichten, in denen einige Instances serverless verwenden und einige Instances bereitgestellt werden.
Stellen Sie sicher, dass Ihre gewünschte Region und Engine-Version DocumentDB serverless unterstützen. Siehe [Anforderungen und Einschränkungen für DocumentDB serverless](docdb-serverless-limitations.md).
Um einen Amazon DocumentDB-Cluster zu erstellen, in dem Sie serverlose Instances hinzufügen können, gehen Sie genauso vor wie unter. [Einen Amazon DocumentDB-Cluster erstellen](db-cluster-create.md) Der einzige Unterschied besteht darin, dass das `ServerlessV2ScalingConfiguration` Argument ebenfalls angegeben werden muss.
Das `ServerlessV2ScalingConfiguration` Argument gibt den Skalierungskapazitätsbereich Ihrer serverlosen DocumentDB-Instances an. Sie besteht aus den minimalen und maximalen DCU (DocumentDB Capacity Unit) -Werten, die für alle serverlosen DocumentDB-Instanzen im Cluster gelten:
+ Der `MinCapacity` Wert gibt die minimale Skalierungskapazität an.
+ Der `MaxCapacity` Wert gibt die maximale Skalierungskapazität an.
Weitere Informationen zur Skalierung finden Sie unter [Serverlose Skalierungskonfiguration von Amazon DocumentDB](docdb-serverless-scaling-config.md).
------
#### [ Using the AWS-Managementkonsole ]
Das folgende AWS-Managementkonsole Konfigurationsbeispiel zeigt, wie ein serverloser DocumentDB-Cluster erstellt wird.
1. Melden Sie sich bei der Amazon DocumentDB DocumentDB-Konsole an [AWS-Managementkonsole](https://console.aws.amazon.com/docdb/home?region=us-east-1)und öffnen Sie sie.
1. Klicken Sie im Navigationsbereich auf **Cluster**.
**Tipp**
Wenn der Navigationsbereich auf der linken Seite des Bildschirms nicht angezeigt wird, wählen Sie links oben auf der Seite das Menüsymbol (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-menu-icon.png)) aus.
Die **Cluster-Tabelle** wird angezeigt.
1. Wählen Sie **Erstellen** aus.
Die Seite **Amazon DocumentDB-Cluster erstellen** wird angezeigt.
1. Wählen Sie auf der Seite Amazon DocumentDB-Cluster erstellen im Abschnitt **Clustertyp** die Option **Instance-based cluster** (dies ist die Standardoption).
1. Gehen Sie im Abschnitt **Cluster-Konfiguration** wie folgt vor:
1. Geben Sie als **Cluster-ID** einen eindeutigen Namen ein, z. **myserverlesscluster** B. Beachten Sie, dass die Konsole alle Clusternamen unabhängig von der Art der Eingabe in Kleinbuchstaben ändert.
1. Wählen Sie für **Engine-Version** **5.0.0** aus (dies ist die Standardoption).
1. Wählen Sie im Abschnitt **Cluster-Speicherkonfiguration** **Amazon DocumentDB Standard** (dies ist die Standardoption).
**Anmerkung**
Die andere Option in dieser Kategorie ist **Amazon DocumentDB I/O-Optimized**. Weitere Informationen zu den beiden Optionen finden Sie unter [Amazon DocumentDB-Cluster-Speicherkonfigurationen](db-cluster-storage-configs.md)
1. Im Abschnitt **Instanzkonfiguration**:
1. Wählen Sie die **DB-Instance-Klasse** **Serverless** aus.
1. Wählen Sie für **Anzahl der regulären Replikatinstanzen** die Option **3** aus (dies ist die Standardoption).
1. Behalten Sie im Abschnitt **Kapazitätsbereich** die Standardwerte für **Minimum DCUs** und **Maximum bei DCUs**. Informationen zum Einstellen dieser Parameter finden Sie unter[Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md).
![\[Konfigurationsformular für einen serverlosen Datenbankcluster mit Feldern für Instanzklasse, Replikatinstanzen und Kapazitätsbereich.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/instance-config-serverless.png)
1. Behalten Sie im Abschnitt **Konnektivität** die Standardeinstellung „**Keine Verbindung zu einer EC2-Rechenressource herstellen**“ bei.
1. Geben Sie im Abschnitt **Authentifizierung** einen Benutzernamen für den Hauptbenutzer ein und wählen Sie dann **Selbstverwaltet** aus. Geben Sie ein Passwort ein und bestätigen Sie es.
Wenn Sie stattdessen **Verwaltet in** wählen AWS Secrets Manager, finden Sie [Passwortverwaltung mit Amazon DocumentDB und AWS Secrets Manager](docdb-secrets-manager.md) weitere Informationen unter.
1. Behalten Sie alle anderen Optionen als Standard bei und wählen Sie **Cluster erstellen** aus.
------
#### [ Using the AWS CLI ]
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch Ihre eigenen Informationen oder Konfigurationsparameter.
Informationen zum Erstellen eines Clusters, das mit serverlosen DocumentDB-Instanzen kompatibel ist AWS CLI, finden Sie unter. [Erstellen eines Clusters mit dem AWS CLI](db-cluster-create.md#db-cluster-create-cli)
Nehmen Sie die folgenden zusätzlichen Parameter in Ihren `create-db-cluster` Befehl auf:
```
--serverless-v2-scaling-configuration
MinCapacity=minimum_capacity,MaxCapacity=maximum_capacity
```
Beispiel:
```
aws docdb create-db-cluster \
--db-cluster-identifier sample-cluster \
--engine docdb \
--engine-version 5.0.0 \
--serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=16 \
--master-username user-name \
--master-user-password password
```
------
## Hinzufügen einer serverlosen Amazon DocumentDB DocumentDB-Instance
Um eine serverlose DocumentDB-Instanz hinzuzufügen, gehen Sie genauso vor wie unter und achten Sie darauf[Hinzufügen einer Amazon DocumentDB DocumentDB-Instance zu einem Cluster](db-instance-add.md), db.serverless als Instanzklasse anzugeben.
### Hinzufügen einer serverlosen Instanz mithilfe der. AWS-Managementkonsole
Informationen zum Hinzufügen serverloser DocumentDB-Instanzen mithilfe der Konsole finden [Hinzufügen einer Amazon DocumentDB DocumentDB-Instance zu einem Cluster](db-instance-add.md) Sie unter **Verwenden der AWS-Managementkonsole Registerkarte Verwenden**.
### Hinzufügen einer serverlosen Instanz mithilfe der AWS CLI
Informationen zum Hinzufügen serverloser DocumentDB-Instanzen mithilfe von finden [Hinzufügen einer Amazon DocumentDB DocumentDB-Instance zu einem Cluster](db-instance-add.md) Sie unter Verwenden der Registerkarte **Verwenden**. AWS CLI AWS CLI
Verwenden Sie das folgende CLI-Argument für die Instanzklasse:
```
--db-instance-class db.serverless
```
Beispiel:
```
aws docdb create-db-instance \
--db-cluster-identifier sample-cluster \
--db-instance-identifier sample-instance \
--db-instance-class db.serverless \
--engine docdb
```
# Migration zu Amazon DocumentDB serverlos
**Topics**
+ [Migration vorhandener DocumentDB-Cluster auf Serverless](#w2aac41c19b5)
+ [Migration von MongoDB zu DocumentDB serverlos](#w2aac41c19b7)
## Migration vorhandener DocumentDB-Cluster auf Serverless
### Aktualisierung der Engine-Version eines Clusters
Wenn auf Ihrem bereitgestellten Cluster eine niedrigere Engine-Version ausgeführt wird, die DocumentDB serverless nicht unterstützt, müssen Sie den Cluster zunächst auf eine unterstützte Engine-Version aktualisieren. Weitere Informationen finden Sie unter [Direktes Upgrade der Hauptversion von Amazon DocumentDB](docdb-mvu.md).
### Migration eines bereitgestellten Clusters zu DocumentDB serverless
Gehen Sie wie folgt vor, um einen bereitgestellten Cluster auf die serverlose Verwendung von DocumentDB umzustellen:
1. Prüfen Sie, ob die Engine-Version des bereitgestellten Clusters aktualisiert werden muss, damit sie mit DocumentDB serverless verwendet werden kann. Siehe [Anforderungen und Einschränkungen für DocumentDB serverless](docdb-serverless-limitations.md).
**Anmerkung**
Wenn auf dem bereitgestellten Cluster eine Engine-Version ausgeführt wird, die für DocumentDB serverless nicht verfügbar ist, aktualisieren Sie die Engine-Version des Clusters. Siehe [Direktes Upgrade der Hauptversion von Amazon DocumentDB](docdb-mvu.md).
1. Konfigurieren Sie die Skalierungskonfiguration für den Cluster. Einzelheiten zur Auswahl der Skalierungskonfiguration finden Sie unter. [Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](docdb-serverless-scaling-config.md#docdb-serverless-scaling-capacity-choosing) Informationen zum Ändern der Skalierungskonfiguration für einen Cluster finden Sie unter[Die Konfiguration des Skalierungskapazitätsbereichs eines Clusters anzeigen und ändern](docdb-serverless-managing.md#docdb-serverless-range-config).
1. Konfigurieren Sie alle anderen Clustereigenschaften, um die serverlosen Anforderungen und Einschränkungen von DocumentDB zu berücksichtigen. [Anforderungen und Einschränkungen für DocumentDB serverless](docdb-serverless-limitations.md)
1. Fügen Sie dem Cluster eine oder mehrere serverlose DocumentDB-Instanzen hinzu. Folgen Sie dem Verfahren unter [Hinzufügen einer serverlosen Amazon DocumentDB DocumentDB-Instance](docdb-serverless-create-cluster.md#docdb-serverless-adding-instance).
**Anmerkung**
In einigen Fällen verfügen Sie möglicherweise bereits über eine oder mehrere bereitgestellte Reader-Instanzen im Cluster. In diesem Fall können Sie einen der Reader in eine serverlose DocumentDB-Instanz konvertieren, anstatt eine neue Instanz zu erstellen. Eine Schritt-für-Schritt-Anleitung hierzu finden Sie unter [Die Klasse einer Instance ändern](db-instance-classes.md#db-instance-class-changing).
1. (Optional) Führen Sie einen Failover-Vorgang durch, um eine serverlose DocumentDB-Instance zum Cluster-Writer zu machen. Siehe [Amazon DocumentDB-Failover](failover.md).
1. (Optional) Konvertieren Sie alle verbleibenden bereitgestellten Amazon DocumentDB DocumentDB-Instances in serverlose DocumentDB-Instances (siehe[Die Klasse einer Instance ändern](db-instance-classes.md#db-instance-class-changing)) oder entfernen Sie sie aus dem Cluster (siehe). [Löschen einer Amazon DocumentDB DocumentDB-Instance](db-instance-delete.md)
------
#### [ Using the AWS-Managementkonsole ]
Das folgende AWS-Managementkonsole Konfigurationsbeispiel zeigt den Migrationsprozess mithilfe eines von Amazon DocumentDB bereitgestellten Clusters, auf dem Amazon DocumentDB 5.0.0 ausgeführt wird. Für den Start der serverlosen Nutzung von DocumentDB ist kein Upgrade der Engine-Version erforderlich. Der Cluster hat einen Namen und beginnt mit drei bereitgestellten Instances namens`sample`, und. `sample` `sample2` `sample3` In diesem Beispiel werden diese drei Instanzen durch drei serverlose Instanzen ersetzt.
1. Melden Sie sich bei der Amazon DocumentDB DocumentDB-Konsole an [AWS-Managementkonsole](https://console.aws.amazon.com/docdb/home?region=us-east-1)und öffnen Sie sie.
1. Klicken Sie im Navigationsbereich auf **Cluster**.
**Tipp**
Wenn der Navigationsbereich auf der linken Seite des Bildschirms nicht angezeigt wird, wählen Sie links oben auf der Seite das Menüsymbol (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-menu-icon.png)) aus.
Die **Cluster-Tabelle** wird angezeigt.
1. Aktivieren Sie in der **Cluster-Tabelle** das Kontrollkästchen des Clusters, dem Sie eine serverlose Instance hinzufügen möchten.
1. Wählen Sie **Actions (Aktionen)** und dann **Add instances (Instances hinzufügen)** aus.
1. Wählen **Sie im Dialogfeld „Instanzen hinzufügen**“ im Abschnitt **DB-Instance-Klasse für jede neue **serverlose** Instance**, die Sie erstellen möchten, die Option Serverless aus.
1. Für **Einstellungen zur serverlosen Kapazität** legen Sie die Skalierungskonfiguration auf der Grundlage der Kapazitätsbeschreibung im Dialogfeld fest.
1. (Optional) Um eine weitere Instanz hinzuzufügen, wählen Sie **Instanz hinzufügen**. Fügen Sie weitere Instanzen hinzu, bis Sie die gewünschte Anzahl neuer Instanzen erreicht haben.
In diesem Beispiel werden drei neue serverlose Instanzen erstellt.
1. Wählen Sie **Erstellen** aus.
Es dauert einige Minuten, bis eine Instance erstellt ist. Sie können die Konsole oder die verwenden AWS CLI , um den Status der Instanz einzusehen. Weitere Informationen finden Sie unter [Überwachen des Status eines Amazon DocumentDB-Clusters](https://docs.aws.amazon.com//documentdb/latest/developerguide/monitoring_docdb-cluster_status.html).
1. Kehren Sie zur **Cluster-Tabelle** zurück und aktivieren Sie die Kontrollkästchen aller drei ursprünglich bereitgestellten Instances.
1. Wählen Sie **Aktionen** und anschließend **Löschen** aus.
Während des Löschvorgangs wird automatisch ein Failover durchgeführt, um eine der verbleibenden Instances zum Writer hochzustufen. Nach einigen Minuten ist der Löschvorgang abgeschlossen. Der bestehende Cluster enthält jetzt drei serverlose DocumentDB-Instanzen (wie in der Spalte **Größe** definiert).
------
#### [ Using the AWS CLI ]
Das folgende AWS CLI Konfigurationsbeispiel zeigt den Migrationsprozess mithilfe eines von Amazon DocumentDB bereitgestellten Clusters, auf dem Amazon DocumentDB 5.0.0 ausgeführt wird. Für den Start der serverlosen Nutzung von DocumentDB ist kein Upgrade der Engine-Version erforderlich. Der Cluster hat einen Namen und beginnt mit drei bereitgestellten Instances namens`sample`, und. `sample` `sample2` `sample3` In diesem Beispiel werden diese drei Instanzen durch drei serverlose Instanzen ersetzt. Der Cluster hat einen Namen `sample-cluster` und beginnt mit zwei bereitgestellten Instanzen namens `sample-provisioned-instance-1` und`sample-provisioned-instance-2`, einer Writer-Instanz und einer Reader-Instanz.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch Ihre eigenen Informationen oder Konfigurationsparameter.
Verwenden Sie den `aws docdb describe-db-clusters` Vorgang, um den Status eines Clusters zu ermitteln. Der folgende Code ermittelt den Status des Clusters `sample-cluster` und gibt die Ergebnisse in einer Tabelle aus:
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[*].DBClusterMembers' \
--output table
```
```
--------------------------------------------------------------------------------------------------------
| DescribeDBClusters |
+--------------------------------+---------------------------------+------------------+----------------+
| DBClusterParameterGroupStatus | DBInstanceIdentifier | IsClusterWriter | PromotionTier |
+--------------------------------+---------------------------------+------------------+----------------+
| in-sync | sample-provisioned-instance-2 | False | 1 |
| in-sync | sample-provisioned-instance-1 | True | 1 |
+--------------------------------+---------------------------------+------------------+----------------+
```
Fügen Sie die Skalierungskonfiguration für den Cluster hinzu:
```
aws docdb modify-db-cluster \
--db-cluster-identifier sample-cluster \
--serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=16
```
Fügen Sie die serverlosen Instanzen hinzu. In diesem Beispiel werden neue serverlose Instanzen benannt `sample-serverless-instance-1` und hinzugefügt`sample-serverless-instance-2`:
```
aws docdb create-db-instance \
--db-cluster-identifier sample-cluster \
--db-instance-identifier sample-serverless-instance-1 \
--db-instance-class db.serverless \
--engine docdb
aws docdb create-db-instance \
--db-cluster-identifier sample-cluster \
--db-instance-identifier sample-serverless-instance-2 \
--db-instance-class db.serverless \
--engine docdb
```
Geben Sie Folgendes ein, um zu warten, bis die serverlosen Instanzen verfügbar sind, bevor Sie fortfahren:
```
aws docdb wait db-instance-available \
--db-instance-identifier sample-serverless-instance-1
aws docdb wait db-instance-available \
--db-instance-identifier sample-serverless-instance-2
```
Führen Sie einen Failover durch, um die neue `sample-serverless-instance-1` Instanz zum Cluster-Writer zu machen:
```
aws docdb failover-db-cluster \
--db-cluster-identifier sample-cluster \
--target-db-instance-identifier sample-serverless-instance-1
```
Es dauert einige Sekunden, bis der Failover abgeschlossen ist. Danach wird sample-serverless-instance -1 zum Cluster-Writer. Überprüfen Sie dies mit der folgenden Eingabe:
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[*].DBClusterMembers' \
--output table
```
```
--------------------------------------------------------------------------------------------------------
| DescribeDBClusters |
+--------------------------------+---------------------------------+------------------+----------------+
| DBClusterParameterGroupStatus | DBInstanceIdentifier | IsClusterWriter | PromotionTier |
+--------------------------------+---------------------------------+------------------+----------------+
| in-sync | sample-provisioned-instance-2 | False | 1 |
| in-sync | sample-provisioned-instance-1 | False | 1 |
| in-sync | sample-serverless-instance-2 | False | 1 |
| in-sync | sample-serverless-instance-1 | True | 1 |
+--------------------------------+---------------------------------+------------------+----------------+
```
Löschen Sie abschließend die ursprünglich bereitgestellten Instanzen:
```
aws docdb delete-db-instance \
--db-instance-identifier sample-provisioned-instance-1
aws docdb delete-db-instance \
--db-instance-identifier sample-provisioned-instance-2
```
------
## Migration von MongoDB zu DocumentDB serverlos
Sie können Ihre MongoDB-Datenbanken zu DocumentDB serverless migrieren, genau wie bei der bereitgestellten Amazon DocumentDB. Weitere Informationen finden Sie unter [Migration zu Amazon DocumentDB](docdb-migration.md).
# Serverlose Verwaltung von Amazon DocumentDB
## Die Konfiguration des Skalierungskapazitätsbereichs eines Clusters anzeigen und ändern
Das `ServerlessV2ScalingConfiguration` Argument gibt den Skalierungskapazitätsbereich Ihrer serverlosen DocumentDB-Instances an. Sie besteht aus den minimalen und maximalen DCU (DocumentDB Capacity Unit) -Werten, die für alle serverlosen DocumentDB-Instanzen im Cluster gelten.
+ **`MinCapacity`**— Die minimale Skalierungskapazität aller serverlosen DocumentDB-Instanzen im Cluster.
+ **`MaxCapacity`**— Die maximale Skalierungskapazität aller serverlosen DocumentDB-Instanzen im Cluster.
**Anmerkung**
Die folgenden Änderungen an der Skalierungskonfiguration erfordern einen Neustart der Instanz, um die neuen Werte `MinCapacity` und `MaxCapacity` widerzuspiegeln:
Jegliche Änderungen am `MaxCapacity` Wert
Änderung des `MinCapacity` Werts von einem höheren Wert auf 1,0 oder niedriger
Änderung des `MinCapacity` Werts von einem niedrigeren Wert auf einen Wert über 1,0
Weitere Informationen zur Skalierungskonfiguration und zur Auswahl geeigneter Skalierungskapazitätsgrenzen finden Sie unter[Serverlose Skalierungskonfiguration von Amazon DocumentDB](docdb-serverless-scaling-config.md).
------
#### [ Using the AWS-Managementkonsole ]
Das folgende AWS-Managementkonsole Konfigurationsbeispiel zeigt, wie die Skalierungskonfigurationseinstellungen eines serverlosen DocumentDB-Clusters angezeigt und bearbeitet werden.
1. Melden Sie sich bei der Amazon DocumentDB DocumentDB-Konsole an [AWS-Managementkonsole](https://console.aws.amazon.com/docdb/home?region=us-east-1)und öffnen Sie sie.
1. Klicken Sie im Navigationsbereich auf **Cluster**.
**Tipp**
Wenn der Navigationsbereich auf der linken Seite des Bildschirms nicht angezeigt wird, wählen Sie links oben auf der Seite das Menüsymbol (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-menu-icon.png)) aus.
Die **Cluster-Tabelle** wird angezeigt.
1. Aktivieren Sie in der **Cluster-Tabelle** das Kontrollkästchen des Clusters, für den Sie die Skalierungskapazität ändern möchten.
1. Wählen Sie **Actions (Aktionen)** und dann **Modify (Ändern)** aus.
Das Dialogfeld „**Cluster ändern**“ wird angezeigt.
1. Suchen Sie den Abschnitt „**Einstellung der Kapazität ohne Server**“ und legen Sie die Skalierungskonfiguration (**Kapazitätsbereich**) auf der Grundlage der Kapazitätsbeschreibung im Dialogfeld fest.
Weitere Informationen zur Skalierung und zu Kapazitätsbereichen finden Sie unter[Serverlose Skalierungskonfiguration von Amazon DocumentDB](docdb-serverless-scaling-config.md).
1. Klicken Sie auf **Weiter**.
1. Wählen Sie für **Scheduling of modifications (Einplanung von Änderungen)** die Option **Apply immediately (Sofort anwenden)** aus.
1. Wählen Sie **Cluster bearbeiten** aus.
1. Sobald die Änderung abgeschlossen ist, sollte jede serverlose Instanz neu gestartet werden. Um die Nichtverfügbarkeit des Writers zu minimieren, führen Sie die folgende Abfolge von Vorgängen aus:
1. Starten Sie jede serverlose Reader-Instanz neu.
1. Wählen Sie die Reader-Instanz aus, klicken Sie auf **Aktionen** und anschließend auf **Neustart**.
1. Warten Sie, bis der Instanzstatus wieder **verfügbar ist**.
1. Führen Sie einen Failover auf eine neu gestartete serverlose Instanz durch.
1. **Wählen Sie den Cluster aus, klicken Sie auf **Aktionen** und dann auf Failover.**
1. Warten Sie, bis der Failover-Vorgang abgeschlossen ist.
1. Starten Sie die verbleibende serverlose Instanz neu.
1. Wählen Sie die verbleibende Instanz aus, klicken Sie auf **Aktionen** und anschließend auf **Neustart**.
1. Warten Sie, bis der Instanzstatus wieder **verfügbar ist**.
------
#### [ Using the AWS CLI ]
Das folgende AWS CLI Konfigurationsbeispiel zeigt die aktuelle Skalierungskonfiguration.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch Ihre eigenen Informationen oder Konfigurationsparameter.
Die aktuelle Skalierungskonfiguration des Clusters kann mit dem `describe-db-clusters` AWS CLI folgenden Befehl angezeigt werden:
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[0].ServerlessV2ScalingConfiguration'
```
Die Ausgabe dieses Befehls ist wie folgt:
```
{
"MinCapacity": 0.5,
"MaxCapacity": 16.0
}
```
Die Skalierungskonfiguration des Clusters kann mit dem `modify-db-cluster` folgenden Befehl geändert werden:
```
aws docdb modify-db-cluster \
--db-cluster-identifier sample-cluster \
--serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=32
```
Sobald der Vorgang abgeschlossen ist, sollte jede serverlose Instanz neu gestartet werden. Um die Nichtverfügbarkeit des Writers zu minimieren, können wir die folgende Abfolge von Vorgängen ausführen:
```
aws docdb reboot-db-instance \
--db-instance-identifier sample-serverless-instance-reader
aws docdb wait db-instance-available \
--db-instance-identifier sample-serverless-instance-reader
aws docdb failover-db-cluster \
--db-cluster-identifier sample-cluster \
--target-db-instance-identifier sample-serverless-instance-reader
aws docdb reboot-db-instance \
--db-instance-identifier sample-serverless-instance-writer
aws docdb wait db-instance-available \
--db-instance-identifier sample-serverless-instance-writer
aws docdb failover-db-cluster \
--db-cluster-identifier sample-cluster \
--target-db-instance-identifier sample-serverless-instance-writer
```
------
## Die Promotion-Stufe für serverlose Lesegeräte anzeigen und ändern
Achten Sie bei Clustern, die mehrere serverlose DocumentDB-Instanzen oder eine Mischung aus bereitgestellten und serverlosen Instanzen enthalten, auf die Einstellung der Promotion-Stufe für jede serverlose Instanz. Diese Einstellung steuert mehr Verhalten für serverlose Instanzen als für bereitgestellte Instanzen.
Bei bereitgestellten Instances bestimmt die Wahl der Stufen 0—15 nur die Reihenfolge, in der Amazon DocumentDB auswählt, welche Reader-Instance während eines Failover-Vorgangs zum Writer hochgestuft werden soll. Bei serverlosen Instances bestimmt die Tier-Nummer jedoch auch, ob die Instance entsprechend der Kapazität der Writer-Instance skaliert oder unabhängig von ihrer eigenen Arbeitslast skaliert wird. Serverlose Reader-Instanzen der Stufe 0 oder 1 verfügen über eine Mindestkapazität, die mindestens so hoch ist wie die der Writer-Instance. Auf diese Weise sind sie bereit, im Falle eines Failovers die Writer-Instanz zu übernehmen. Wenn es sich bei der Writer-Instance um eine bereitgestellte Instance handelt, schätzt Amazon DocumentDB die entsprechende serverlose DocumentDB-Kapazität. Es verwendet diese Schätzung als Mindestkapazität für die serverlose Reader-Instance.
Für serverlose DocumentDB-Reader-Instanzen der Stufen 2—15 gelten nicht dieselben Einschränkungen in Bezug auf ihre Mindestkapazität. Wenn sie inaktiv sind, können sie auf den Mindestwert der DocumentDB-Kapazitätseinheit (DCU) herunterskaliert werden, der im Kapazitätsbereich des Clusters angegeben ist.
------
#### [ Using the AWS-Managementkonsole ]
Das folgende AWS-Managementkonsole Konfigurationsbeispiel zeigt, wie Sie die Promotion-Tarif-Einstellungen eines serverlosen DocumentDB-Instance-Readers anzeigen und ändern können.
1. Melden Sie sich bei der Amazon DocumentDB DocumentDB-Konsole an [AWS-Managementkonsole](https://console.aws.amazon.com/docdb/home?region=us-east-1)und öffnen Sie sie.
Die Promotion-Stufen jeder Instance werden in der Spalte **Promotion-Stufe** im AWS-Managementkonsole angezeigt.
1. Klicken Sie im Navigationsbereich auf **Cluster**.
**Tipp**
Wenn der Navigationsbereich auf der linken Seite des Bildschirms nicht angezeigt wird, wählen Sie links oben auf der Seite das Menüsymbol (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-menu-icon.png)) aus.
Die **Cluster-Tabelle** wird angezeigt.
1. Aktivieren Sie in der **Cluster-Tabelle** das Kontrollkästchen der Instance, für die Sie die Promotion-Stufe ändern möchten.
1. Wählen Sie **Actions (Aktionen)** und dann **Modify (Ändern)** aus.
Das Dialogfeld „**Instanz ändern**“ wird angezeigt.
1. Suchen Sie den Abschnitt **Failover** und stellen Sie die **Stufe Promotion** auf die gewünschte Stufe ein.
1. Klicken Sie auf **Weiter**.
1. Wählen Sie für **Scheduling of modifications (Einplanung von Änderungen)** die Option **Apply immediately (Sofort anwenden)** aus.
1. Wählen Sie **Modify instance** (Instance ändern).
------
#### [ Using the AWS CLI ]
Das folgende AWS CLI Konfigurationsbeispiel zeigt die aktuelle Skalierungskonfiguration.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch Ihre eigenen Informationen oder Konfigurationsparameter.
Die Promotion-Stufen aller Instances in einem Cluster können mit dem `describe-db-clusters` AWS CLI folgenden Befehl angezeigt werden:
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[0].DBClusterMembers' \
--output table
```
Die Ausgabe dieses Befehls ist wie folgt:
```
--------------------------------------------------------------------------------------------------------
| DescribeDBClusters |
+--------------------------------+---------------------------------+------------------+----------------+
| DBClusterParameterGroupStatus | DBInstanceIdentifier | IsClusterWriter | PromotionTier |
+--------------------------------+---------------------------------+------------------+----------------+
| in-sync | sample-serverless-instance-2 | False | 1 |
| in-sync | sample-serverless-instance-1 | True | 1 |
+--------------------------------+---------------------------------+------------------+----------------+
```
Die Aufstiegsstufe einer bestimmten Instanz kann mit dem `modify-db-instance` folgenden Befehl geändert werden:
```
aws docdb modify-db-instance \
--db-instance-identifier sample-serverless-instance-2 \
--promotion-tier 3
```
------
# Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances
Für serverlose DocumentDB-Instances hängen die folgenden Grenzwerte pro Instanz von der aktuellen Skalierungskapazität der Instanz ab:
+ Instanzspeicher (GiB)
+ Verbindungen (alle)
+ Cursor-Limit
+ Transaktionen öffnen
+ Verbindungen (aktiv)
In den folgenden Tabellen wird beschrieben, wie die Grenzwerte für serverlose Instances pro Instanz im Verhältnis zur aktuellen Skalierungskapazität der Instance skaliert werden.
Beachten Sie, dass die Grenzwerte unterschiedlich sind, je nachdem, ob die `MinCapacity` Skalierungskonfiguration des Clusters auf mehr als zwei (2) festgelegt wurde. Wenn auf weniger als oder gleich 2 gesetzt `MinCapacity` ist, sind die Grenzwerte für Cursorlimit, offene Transaktionen und Verbindungen (aktiv) auf einen niedrigeren Maximalwert begrenzt. (Der technische Grund für die Obergrenze besteht darin, das Herunterskalieren in einen „inaktiven“ Zustand zu unterstützen. Weitere Informationen finden Sie unter [Ruhezustand (0.5 DCUs)](docdb-serverless-how-it-works.md#docdb-serverlerss-idle-state).
**db.serverless-Instanzlimits bei ≤1 MinCapacity **
| Aktuelle Kapazität (DCU) | Instanzspeicher (GiB) | Verbindungen (alle) | Cursor-Limit | Transaktionen öffnen | Verbindungen (aktiv) |
| --- | --- | --- | --- | --- | --- |
| 0.5 | 1 | 250 | 6 | 12 | 39 |
| 1 | 2 | 500 | 12 | 24 | 79 |
| 2 | 4 | 1000 | 24 | 48 | 173 |
| 4 | 8 | 2000 | 48 | 96 | 416 |
| 8 | 16 | 4000 | 96 | 192 | 1071 |
| 16 | 32 | 8000 | 132 | 264 | 1550 |
| 32 | 64 | 16000 | 132 | 264 | 1550 |
| 64 | 128 | 32000 | 132 | 264 | 1550 |
| 128 | 256 | 60000 | 132 | 264 | 1550 |
| 256 | 512 | 60000 | 132 | 264 | 1550 |
**db.serverless-Instanzlimits, wenn >1 MinCapacity **
| Aktuelle Kapazität (DCU) | Instanzspeicher (GiB) | Verbindungen (alle) | Cursor-Limit | Transaktionen öffnen | Verbindungen (aktiv) |
| --- | --- | --- | --- | --- | --- |
| 1.5 | 3 | 7250 | 18 | 36 | 124 |
| 2 | 4 | 1000 | 24 | 48 | 173 |
| 4 | 8 | 2000 | 48 | 96 | 416 |
| 8 | 16 | 4000 | 96 | 192 | 1071 |
| 16 | 32 | 8000 | 192 | 384 | 2709 |
| 32 | 64 | 16000 | 384 | 768 | 4500 |
| 64 | 128 | 32000 | 768 | 1536 | 4500 |
| 128 | 256 | 60000 | 1536 | 3072 | 4500 |
| 256 | 512 | 60000 | 3072 | 6144 | 4500 |
Mithilfe der folgenden CloudWatch Messwerte können Sie die Limits pro Instanz überwachen und Alarme ausgeben. Weitere Informationen zu Amazon CloudWatch DocumentDB-Metriken finden Sie unter[Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md).
| Ressource | CloudWatch Metrik einschränken | CloudWatch Nutzungsmetrik (max. 1 Minute) | CloudWatch Nutzungsmetrik |
| --- | --- | --- | --- |
| Instanzspeicher | - | - | FreeableMemory |
| Verbindungen (alle) | DatabaseConnectionsLimit | DatabaseConnectionsMax | DatabaseConnections |
| Cursor | DatabaseCursorsLimit | DatabaseCursorsMax | DatabaseCursors |
| Transaktionen | TransactionsOpenLimit | TransactionsOpenMax | TransactionsOpen |
# Serverlose Skalierungskonfiguration von Amazon DocumentDB
**Topics**
+ [Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](#docdb-serverless-scaling-capacity-choosing)
+ [`MinCapacity`Einstellung für einen serverlosen DocumentDB-Cluster auswählen](#docdb-serverless-scaling-mincapacity-choosing)
+ [`MaxCapacity`Einstellung für einen serverlosen DocumentDB-Cluster auswählen](#docdb-serverless-scaling-maxcapacity-choosing)
+ [Vermeiden von out-of-memory Fehlern](#docdb-serverless-scaling-mem-errors)
+ [Warum wird meine serverlose Instance nicht herunterskaliert?](#docdb-serverless-scaling-down)
## Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster
Bevor Sie serverlose DocumentDB-Instances zu einem Amazon DocumentDB-Cluster hinzufügen, muss für den Cluster auch der `ServerlessV2ScalingConfiguration` Parameter festgelegt sein.
Der `ServerlessV2ScalingConfiguration` Parameter besteht aus zwei Werten, die den Kapazitätsbereich für die serverlose Skalierung jeder serverlosen Instance im Cluster definieren:
+ **`MinCapacity`**— Die minimale Skalierungskapazität aller serverlosen DocumentDB-Instanzen im Cluster.
+ **`MaxCapacity`**— Die maximale Skalierungskapazität aller serverlosen DocumentDB-Instanzen im Cluster.
## `MinCapacity`Einstellung für einen serverlosen DocumentDB-Cluster auswählen
Es ist verlockend, immer 0,5 für zu wählen. `MinCapacity` Dieser Wert ermöglicht es der Instance, auf die kleinste Kapazität herunterzuskalieren, wenn sie vollständig inaktiv ist, und gleichzeitig aktiv bleibt. Je nachdem, wie Sie diesen Cluster verwenden und wie die anderen Einstellungen konfiguriert sind, ist jedoch eine andere Mindestkapazität ggf. am effektivsten. Berücksichtigen Sie bei der Auswahl der Mindestkapazitätseinstellung die folgenden Faktoren:
+ Die Skalierungsrate für eine serverlose DocumentDB-Instanz hängt von ihrer aktuellen Kapazität ab. Je höher die aktuelle Kapazität, desto schneller kann sie hochskalieren. Wenn Sie möchten, dass die Instance schnell auf eine sehr hohe Kapazität hochskaliert wird, sollten Sie die Mindestkapazität auf einen Wert festlegen, bei dem die Skalierungsrate Ihren Anforderungen entspricht.
+ Wenn Sie die Instanzklasse Ihrer Instances in der Regel in Erwartung einer besonders hohen oder niedrigen Arbeitslast ändern, können Sie diese Erfahrung nutzen, um eine grobe Schätzung des entsprechenden serverlosen Kapazitätsbereichs von DocumentDB vorzunehmen. Informationen zur Bestimmung der Speichergröße eines bereitgestellten Amazon DocumentDB DocumentDB-Instance-Typs finden Sie unter. [Instance-Limits](limits.md#limits.instance)
Nehmen wir beispielsweise an, Sie verwenden die `db.r6g.xlarge` Instance-Klasse, wenn Ihr Cluster eine geringe Arbeitslast hat. Diese Instanzklasse hat 32 GiB Speicher. Sie können also einen Wert `MinCapacity` von 16 angeben, um eine serverlose Instanz einzurichten, die auf ungefähr dieselbe Kapazität herunterskaliert werden kann. Das liegt daran, dass jede DCU ungefähr 2 GiB Speicher entspricht. Sie können einen etwas niedrigeren Wert angeben, um die Instance weiter herunterskalieren zu lassen, falls Ihre `db.r6g.xlarge` Instance manchmal nicht ausgelastet war.
+ Wenn Ihre Anwendung am effizientesten arbeitet, wenn die Instances über eine bestimmte Datenmenge im Puffercache verfügen, sollten Sie eine DCU-Mindesteinstellung angeben, bei der der Speicher groß genug ist, um die häufig aufgerufenen Daten aufzunehmen. Andernfalls werden einige Daten aus dem Puffercache entfernt, wenn die serverlosen Instanzen auf eine geringere Speichergröße herunterskaliert werden. Wenn die Instanzen dann wieder hochskaliert werden, werden die Informationen im Laufe der Zeit wieder in den Puffer-Cache eingelesen. Wenn die Menge, mit der I/O die Daten wieder in den Puffer-Cache zurückgebracht werden sollen, beträchtlich ist, ist es möglicherweise effektiver, einen höheren DCU-Mindestwert zu wählen. Weitere Informationen finden Sie unter [Dimensionierung der Instanzen](best_practices.md#best_practices-instance_sizing).
+ Wenn Ihre serverlosen DocumentDB-Instanzen die meiste Zeit mit einer bestimmten Kapazität ausgeführt werden, sollten Sie erwägen, eine Mindestkapazitätseinstellung anzugeben, die niedriger als diese Grundeinstellung, aber nicht zu viel niedriger ist. Serverlose Instances können am effektivsten abschätzen, wie viel und wie schnell eine Skalierung erforderlich ist, wenn die aktuelle Kapazität nicht drastisch unter der erforderlichen Kapazität liegt.
+ Wenn Ihr bereitgestellter Workload Speicheranforderungen hat, die für kleine Instance-Klassen wie T3 oder T4g zu hoch sind, wählen Sie eine DCU-Mindesteinstellung, die Speicherplatz bietet, der mit einer R5- oder R6g-Instance vergleichbar ist.
+ Insbesondere empfehlen wir die folgenden Mindestanforderungen `MinCapacity` für die Verwendung mit den angegebenen Funktionen (diese Empfehlungen können sich ändern):
+ Performance Insights — 2 DCUs
+ Globale Cluster — 8 DCUs (gilt nur für die primären AWS-Region)
+ In Amazon DocumentDB erfolgt die Replikation auf der Speicherebene, sodass sich die Lesekapazität nicht direkt auf die Replikation auswirkt. Stellen Sie bei serverlosen DocumentDB-Reader-Instances, die unabhängig skaliert werden, jedoch sicher, dass die Mindestkapazität ausreicht, um Workloads in schreibintensiven Zeiten zu bewältigen, um Abfragelatenz zu vermeiden. Wenn bei Reader-Instances der Promotion-Stufen 2—15 Leistungsprobleme auftreten, sollten Sie eine Erhöhung der Mindestkapazität des Clusters in Betracht ziehen. Einzelheiten dazu, wie Sie ändern können, ob Reader-Instances zusammen mit dem Autor oder unabhängig voneinander skaliert werden, finden Sie unter[Die Promotion-Stufe für serverlose Lesegeräte anzeigen und ändern](docdb-serverless-managing.md#docdb-serverless-promo-tier).
Wenn Sie einen Cluster mit serverlosen DocumentDB-Reader-Instances haben, skalieren die Reader nicht zusammen mit der Writer-Instanz, wenn die Promotion-Stufe der Reader nicht 0 oder 1 ist. In diesem Fall kann das Festlegen einer geringen Mindestkapazität zu einer übermäßigen Replikationsverzögerung führen. Das liegt daran, dass die Reader möglicherweise nicht genug Kapazität haben, um Änderungen vom Writer zu übernehmen, wenn die Datenbank ausgelastet ist. Es wird empfohlen, die Mindestkapazität auf einen Wert festzulegen, der einer mit der Writer-Instanz vergleichbaren Speicher- und CPU-Menge entspricht.
+ Die Zeit, die eine serverlose DocumentDB-Instanz benötigt, um von ihrer minimalen Kapazität zur maximalen Kapazität zu skalieren, hängt von der Differenz zwischen ihren minimalen und maximalen DCU-Werten ab. Wenn die aktuelle Kapazität der Instanz groß ist, wird DocumentDB serverless in größeren Schritten skaliert, als wenn die Instanz mit einer kleinen Kapazität gestartet wird. Wenn Sie also eine relativ große maximale Kapazität angeben und die Instance die meiste Zeit in der Nähe dieser Kapazität verbringt, sollten Sie erwägen, die minimale DCU-Einstellung zu erhöhen. Auf diese Weise kann eine Instance im Leerlauf schneller wieder auf die maximale Kapazität hochskaliert werden.
+ Bestimmte Instance-Limits werden durch die aktuelle Kapazität der serverlosen Instance bestimmt, z. B. Verbindungslimit, Cursorlimit und Limit für offene Transaktionen. Wenn die aktuelle Kapazität der Instance gering ist, sind auch die Grenzwerte entsprechend gering. Wenn diese Grenzwerte ein Problem darstellen, wenn Ihre serverlose Instance auf ihren `MinCapacity` Wert herunterskaliert wird, sollten Sie eine Erhöhung `MinCapacity` auf einen höheren Wert in Betracht ziehen. Weitere Informationen finden Sie unter [Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md).
+ Darüber hinaus gelten für bestimmte Instance-Limits ein niedrigerer Maximalwert, wenn dieser auf weniger als oder gleich 1,0 festgelegt `MinCapacity` ist DCUs, wie z. B. das Limit für aktive Verbindungen, das Cursorlimit und das Limit für offene Transaktionen. Wenn diese Obergrenzen für Ihre Arbeitslast nicht ausreichen, verwenden Sie bitte einen `MinCapacity` Wert von mindestens 1,5. DCUs Weitere Informationen finden Sie unter [Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md).
Anweisungen zum Ändern der Skalierungskonfiguration eines Clusters finden Sie unter[Serverlose Verwaltung von Amazon DocumentDB](docdb-serverless-managing.md).
## `MaxCapacity`Einstellung für einen serverlosen DocumentDB-Cluster auswählen
Es ist verlockend, immer einen hohen Wert für die maximale serverlose Kapazität von DocumentDB zu wählen. Eine große maximale Kapazität ermöglicht es der Instanz, am stärksten zu skalieren, wenn sie eine intensive Arbeitslast ausführt. Mit einem niedrigen Wert entfällt die Möglichkeit unerwarteter Gebühren. Je nachdem, wie Sie diesen Cluster verwenden und die anderen Einstellungen konfigurieren, kann der effektivste Wert höher oder niedriger sein, als Sie ursprünglich dachten. Berücksichtigen Sie bei der Auswahl der maximalen Kapazitätseinstellung die folgenden Faktoren:
+ Die maximale Kapazität muss mindestens so hoch sein wie die Mindestkapazität. Sie können die minimale und maximale Kapazität auf den gleichen Wert festlegen. In diesem Fall skaliert sich die Kapazität jedoch niemals hoch oder herunter. Daher ist die Verwendung identischer Werte für die minimale und maximale Kapazität außerhalb von Testsituationen nicht geeignet.
+ Die maximale Kapazität muss mindestens 1,0 DCUs und darf höchstens 256 betragen DCUs.
+ Wir empfehlen, die Skalierung und die Ressourcennutzung Ihrer serverlosen Instances zu überwachen. Wenn Ihre serverlose Instance häufig auf maximale Kapazität skaliert und dabei auf Ressourcenbeschränkungen stößt (z. B. wenn die `DCUUtilization` Metrik bei 100,0 liegt), empfehlen wir, einen höheren Wert auszuwählen. `MaxCapacity` Weitere Informationen finden Sie unter [Serverlose Überwachung von Amazon DocumentDB](docdb-serverless-monitoring.md).
+ Wenn Sie in der Regel die Instanzklasse Ihrer bereitgestellten Instanzen in Erwartung einer besonders hohen oder niedrigen Arbeitslast ändern, können Sie diese Erfahrung nutzen, um den entsprechenden serverlosen Kapazitätsbereich von DocumentDB abzuschätzen. Informationen zur Bestimmung der Speichergröße der bereitgestellten Amazon DocumentDB DocumentDB-Instances finden Sie unter. [Instance-Limits](limits.md#limits.instance)
Nehmen wir beispielsweise an, Sie verwenden die `db.r6g.4xlarge` Instance-Klasse, wenn Ihr Cluster eine hohe Arbeitslast hat. Diese Instanzklasse hat 128 GiB Arbeitsspeicher. Daher können Sie eine maximale DCU-Einstellung von 64 angeben, um eine serverlose Instanz einzurichten, die auf ungefähr dieselbe Kapazität skaliert werden kann. Das liegt daran, dass jede DCU ungefähr 2 GiB Speicher entspricht. Sie können einen etwas höheren Wert angeben, damit die Instance weiter skaliert werden kann, falls Ihre `db.r6g.4xlarge` Instance manchmal nicht über genügend Kapazität verfügt, um die Arbeitslast effektiv zu bewältigen.
+ Wenn Sie eine Budgetobergrenze für Ihre Datenbanknutzung haben, wählen Sie einen Wert, der innerhalb dieser Obergrenze bleibt, auch wenn all Ihre serverlosen Instances ständig mit maximaler Kapazität laufen. Denken Sie daran, dass, wenn Sie n serverlose Instances in Ihrem Cluster haben, die theoretische maximale serverlose Kapazität, die der Cluster zu einem beliebigen Zeitpunkt verbrauchen kann, das n-fache der maximalen DCU-Einstellung für den Cluster beträgt. (Der tatsächlich verbrauchte Betrag ist möglicherweise geringer, wenn beispielsweise einige Reader unabhängig vom Writer skalieren.)
+ Wenn Sie serverlose Reader-Instances verwenden, um einen Teil der schreibgeschützten Arbeitslast von der Writer-Instanz auszulagern, können Sie möglicherweise eine niedrigere Einstellung für die maximale Kapazität wählen. Sie tun dies, um zu berücksichtigen, dass nicht jede Reader-Instanz so hoch skaliert werden muss, als ob der Cluster nur eine einzige Instanz enthält.
+ Angenommen, Sie möchten sich vor übermäßiger Auslastung aufgrund falsch konfigurierter Datenbankparameter oder ineffizienter Abfragen in Ihrer Anwendung schützen. In diesem Fall können Sie eine versehentliche Überbeanspruchung vermeiden, indem Sie eine maximale Kapazitätseinstellung wählen, die niedriger ist als die absolut höchste, die Sie festlegen können.
+ Wenn Spitzen aufgrund realer Benutzeraktivitäten zwar selten sind, aber dennoch auftreten, können Sie diese Situationen bei der Auswahl der maximalen Kapazitätseinstellung berücksichtigen. Wenn die Priorität darin besteht, dass die Anwendung weiterhin mit voller Leistung und Skalierbarkeit ausgeführt wird, können Sie eine maximale Kapazitätseinstellung angeben, die höher ist, als Sie bei normaler Auslastung beobachten. Wenn es akzeptabel ist, dass die Anwendung bei sehr extremen Aktivitätsspitzen mit reduziertem Durchsatz ausgeführt wird, können Sie eine etwas niedrigere maximale Kapazitätseinstellung wählen. Stellen Sie sicher, dass Sie eine Einstellung auswählen, die immer noch über genügend Speicher- und CPU-Ressourcen verfügt, damit die Anwendung weiterhin ausgeführt wird.
+ Wenn Sie Einstellungen in Ihrem Cluster aktivieren, die die Speichernutzung für jede Instanz erhöhen, berücksichtigen Sie diesen Speicher, wenn Sie den maximalen DCU-Wert festlegen. Zu diesen Einstellungen gehören die Einstellungen für Performance Insights und globale Cluster. Stellen Sie sicher, dass der maximale DCU-Wert es den serverlosen Instances ermöglicht, so weit zu skalieren, dass sie die Arbeitslast bewältigen können, wenn diese Funktionen verwendet werden. Informationen zur Behebung von Problemen, die durch die Kombination einer niedrigen maximalen DCU-Einstellung und Amazon DocumentDB DocumentDB-Funktionen verursacht werden, die einen Speicheraufwand verursachen, finden Sie unter [Vermeiden von out-of-memory Fehlern](#docdb-serverless-scaling-mem-errors) (unten).
+ Insbesondere empfehlen wir die folgenden Mindestanforderungen `MaxCapacity` für die Verwendung mit den angegebenen Funktionen (diese Empfehlungen können sich ändern):
+ Serverlose Instanzerstellung auf einem Cluster mit einem großen Datenvolumen — 2 DCUs (dazu gehört auch die serverlose Instanzerstellung im Rahmen einer Cluster-Wiederherstellung.)
+ Bestimmte Instanzlimits werden durch die aktuelle Kapazität der Instanz bestimmt, z. B. das Verbindungslimit, das Cursorlimit und das Limit für offene Transaktionen. Achten Sie bei der Auswahl des `MaxCapacity` Werts für Ihren Workload darauf, diese Instance-Limits zu berücksichtigen, um zu vermeiden, dass Sie durch eines dieser Limits einen Engpass bekommen. Weitere Informationen finden Sie unter [Beschränkungen für serverlose Amazon DocumentDB DocumentDB-Instances](docdb-serverless-instance-limits.md).
Anweisungen zum Ändern der Skalierungskonfiguration eines Clusters finden Sie unter. [Serverlose Verwaltung von Amazon DocumentDB](docdb-serverless-managing.md)
## Vermeiden von out-of-memory Fehlern
**Wenn eine Ihrer serverlosen DocumentDB-Instances ständig die Grenze ihrer maximalen Kapazität erreicht, weist Amazon DocumentDB auf diesen Zustand hin, indem die Instance auf den Status inkompatibler Parameter gesetzt wird.** Die Instance hat zwar den Status **inkompatibler** Parameter, aber einige Operationen sind blockiert. Beispielsweise können Sie die Engine-Version nicht aktualisieren. Weitere Informationen zum Status einer Amazon DocumentDB DocumentDB-Instance finden Sie unter [Überwachen des Status einer Amazon DocumentDB DocumentDB-Instance](https://docs.aws.amazon.com//documentdb/latest/developerguide/monitoring_docdb-instance_status.html).
In der Regel nimmt Ihre Instance diesen Status an, wenn sie aufgrund von Fehlern häufig neu gestartet wird. out-of-memory Amazon DocumentDB zeichnet ein Ereignis auf, wenn diese Art von Neustart stattfindet. Informationen zum Anzeigen von Ressourcenereignissen finden Sie unter[Amazon DocumentDB DocumentDB-Ereignisse anzeigen](managing-events.md#viewing-events). Ein ungewöhnlich hoher Speicherverbrauch kann aufgrund des Mehraufwands beim Aktivieren von Einstellungen wie Performance Insights auftreten. Dies kann auch auf eine hohe Arbeitslast auf Ihrer Instanz oder auf die Verwaltung der Metadaten zurückzuführen sein, die mit einer großen Anzahl von Schemaobjekten verknüpft sind.
Wenn der Speicherdruck geringer wird, sodass die Instance ihre maximale Kapazität nicht sehr oft erreicht, ändert Amazon DocumentDB den Instance-Status automatisch wieder auf verfügbar.
Zur Wiederherstellung nach diesem Zustand können Sie einige oder alle der folgenden Aktionen ausführen:
+ Erhöhen Sie die untere Kapazitätsgrenze für serverlose Instances, indem Sie den Mindestwert der DocumentDB-Kapazitätseinheit (DCU) für den Cluster ändern. Dadurch werden Probleme vermieden, bei denen eine inaktive Datenbank auf eine Kapazität mit weniger Speicher herunterskaliert wird, als für die in Ihrem Cluster aktivierten Funktionen benötigt wird. Nachdem Sie die DCU-Einstellungen für den Cluster geändert haben, starten Sie die serverlose Instanz neu. Dadurch wird geprüft, ob Amazon DocumentDB den Status wieder auf verfügbar zurücksetzen kann.
+ Erhöhen Sie die Kapazitätsobergrenze für serverlose Instances, indem Sie den maximalen DCU-Wert für den Cluster ändern. Auf diese Weise werden Probleme vermieden, bei denen eine ausgelastete Datenbank nicht auf eine Kapazität mit genügend Speicher für die in Ihrem Cluster aktivierten Funktionen und die Datenbank-Workload hochskaliert werden kann. Nachdem Sie die DCU-Einstellungen für den Cluster geändert haben, starten Sie die serverlose Instanz neu. Dadurch wird geprüft, ob Amazon DocumentDB den Status wieder auf verfügbar zurücksetzen kann.
+ Deaktivieren Sie Konfigurationseinstellungen, die Speicher-Overhead erfordern. Angenommen, Sie haben eine Funktion wie Performance Insights aktiviert, verwenden sie aber nicht. Wenn ja, können Sie sie ausschalten. Oder Sie können die Mindest- und Höchstkapazitätswerte für den Cluster höher anpassen, um dem von diesen Funktionstypen verwendeten Speicher Rechnung zu tragen. Richtlinien zur Auswahl der minimalen und maximalen Kapazitätseinstellungen finden Sie unter [Auswahl des Skalierungskapazitätsbereichs für einen serverlosen DocumentDB-Cluster](#docdb-serverless-scaling-capacity-choosing).
+ Reduzieren Sie die Arbeitslast auf der Instanz. Sie können dem Cluster beispielsweise Reader-Instances hinzufügen, um die Last aus schreibgeschützten Abfragen auf mehrere Instanzen zu verteilen.
## Warum wird meine serverlose Instance nicht herunterskaliert?
In einigen Fällen lässt sich DocumentDB serverless nicht auf die Mindestkapazität herunterskalieren, selbst wenn die Datenbank nicht belastet wird. Dies kann aus einem der folgenden Gründe geschehen:
+ Performance Insights kann die Ressourcennutzung erhöhen und verhindern, dass die Datenbank auf die Mindestkapazität herunterskaliert wird. Nachstehend sind einige dieser Features aufgeführt:
+ Wenn eine Reader-Instance nicht auf das Minimum herunterskaliert wird und dieselbe oder eine höhere Kapazität als die Writer-Instance hat, überprüfen Sie die Prioritätsstufe der Reader-Instance. Serverlose DocumentDB-Reader-Instanzen der Stufe 0 oder 1 verfügen über eine Mindestkapazität, die mindestens so hoch ist wie die der Writer-Instanz. Ändern Sie die Prioritätsstufe der Reader-Instance in 2 oder höher, sodass sie unabhängig von der Writer-Instance hoch- und herunterskaliert wird. Weitere Informationen finden Sie unter [Serverlose Skalierung von Amazon DocumentDB](docdb-serverless-how-it-works.md#docdb-serverless-scaling).
+ Hohe Datenbank-Workloads können die Ressourcennutzung erhöhen.
+ Große Datenbank-Volumes können die Ressourcennutzung erhöhen. Amazon DocumentDB verwendet Speicher- und CPU-Ressourcen für die Clusterverwaltung. Amazon DocumentDB benötigt mehr CPU und Arbeitsspeicher, um Cluster mit größeren Datenbankvolumen zu verwalten. Wenn die Mindestkapazität Ihres Clusters unter der für die Clusterverwaltung erforderlichen Mindestkapazität liegt, skaliert Ihr Cluster nicht auf die Mindestkapazität herunter.
+ Wartungsaktivitäten im Hintergrund können die Ressourcennutzung regelmäßig erhöhen.
Wenn die Datenbank immer noch nicht auf die konfigurierte Mindestkapazität herunterskaliert wird, beenden Sie die Datenbank und starten Sie sie neu, um alle Speicherfragmente zurückzugewinnen, die sich im Laufe der Zeit angesammelt haben könnten. Das Stoppen und Starten einer Datenbank führt zu Ausfallzeiten, daher empfehlen wir, achtsam vorzugehen.
# Serverlose Überwachung von Amazon DocumentDB
Weitere Informationen zur Überwachung in Amazon DocumentDB finden Sie unter[Überwachung von Amazon DocumentDB](monitoring_docdb.md).
**Topics**
+ [Nicht genügend Arbeitsspeicher: Status inkompatibler Parameter](#w2aac41c27b7)
+ [CloudWatch Amazon-Metriken für DocumentDB serverlos](#w2aac41c27b9)
+ [Überwachung der serverlosen Leistung von DocumentDB mit Performance Insights](#w2aac41c27c11)
## Nicht genügend Arbeitsspeicher: Status inkompatibler Parameter
Wenn eine Ihrer serverlosen Instances ständig die Grenze ihrer maximalen Kapazität erreicht, weist Amazon DocumentDB auf diesen Zustand hin, indem die Instance auf den Status inkompatibler Parameter gesetzt wird. Weitere Informationen finden Sie unter [Vermeiden von out-of-memory Fehlern](docdb-serverless-scaling-config.md#docdb-serverless-scaling-mem-errors).
## CloudWatch Amazon-Metriken für DocumentDB serverlos
Weitere Informationen zur Verwendung CloudWatch mit Amazon DocumentDB finden Sie unter[Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md).
Sie können Ihre serverlosen Instances unter anzeigen CloudWatch , um die von jeder Instance verbrauchte Kapazität anhand der `ServerlessDatabaseCapacity` Metrik zu überwachen. Sie können auch alle CloudWatch Standardmetriken von DocumentDB überwachen, z. B. `DatabaseConnections` Abfragen. Die vollständige Liste der CloudWatch Metriken, die Sie für Amazon DocumentDB überwachen können, finden Sie unter[Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md). Es ist wichtig, die folgenden Metriken CloudWatch auf Instanzebene zu überwachen, damit Sie verstehen, wie Ihre serverlosen DocumentDB-Instances nach oben und unten skalieren. Alle diese Metriken werden jede Sekunde berechnet. Auf diese Weise können Sie den aktuellen Status Ihrer serverlosen Instances überwachen. Sie können Alarme einrichten, um Sie zu benachrichtigen, wenn sich eine serverlose Instanz einem Schwellenwert für Kapazitätsmetriken nähert. Sie können feststellen, ob die minimalen und maximalen Kapazitätseinstellungen angemessen sind oder ob Sie sie anpassen müssen. Sie können bestimmen, worauf Sie sich konzentrieren müssen, um die Effizienz Ihrer Datenbank zu optimieren.
+ **`ServerlessDatabaseCapacity`**— Als Metrik auf Instanzebene gibt sie die Anzahl der Instanzen an, die durch die aktuelle Instanzkapazität DCUs repräsentiert wird. Als Metrik auf Clusterebene stellt sie den Durchschnitt der `ServerlessDatabaseCapacity` Werte aller serverlosen DocumentDB-Instances im Cluster dar.
+ **`DCUUtilization.`**— Diese Metrik ist neu in DocumentDB serverless. Dieser Wert wird als Prozentsatz dargestellt. Sie wird berechnet als der Wert der `ServerlessDatabaseCapacity` Metrik geteilt durch den maximalen DCU-Wert des Clusters. Beachten Sie die folgenden Richtlinien, um diese Metrik zu interpretieren und Maßnahmen zu ergreifen:
+ Wenn sich diese Metrik einem Wert von nähert`100.0`, wurde die Instance so weit wie möglich hochskaliert. Erwägen Sie, die maximale DCU-Einstellung für den Cluster zu erhöhen. Auf diese Weise können sowohl Writer- als auch Reader-Instances auf eine höhere Kapazität skaliert werden.
+ Nehmen wir an, dass sich eine Reader-Instance aufgrund eines Nur-Lese-Workloads einem Wert `DCUUtilization` von `100.0` annähert, während die Writer-Instanz nicht annähernd ihre maximale Kapazität erreicht. In diesem Fall sollten Sie erwägen, dem Cluster zusätzliche Reader-Instanzen hinzuzufügen. Auf diese Weise können Sie den schreibgeschützten Teil der Arbeitslast auf mehrere Instanzen verteilen und so die Belastung der einzelnen Reader-Instances reduzieren.
+ Angenommen, Sie führen eine Produktionsanwendung aus, bei der Leistung und Skalierbarkeit die Hauptüberlegungen sind. In diesem Fall können Sie den maximalen DCU-Wert für den Cluster auf einen hohen Wert festlegen. Ihr Ziel ist es, dass die `DCUUtilization` Metrik immer unter 100,0 liegt. Bei einem hohen maximalen DCU-Wert können Sie sicher sein, dass genügend Spielraum für den Fall vorhanden ist, dass unerwartete Spitzen bei der Datenbankaktivität auftreten. Berechnet wird Ihnen nur die tatsächlich verbrauchte Datenbankkapazität.
+ **`CPUUtilization`**— Diese Metrik wird in DocumentDB serverless anders interpretiert als in bereitgestellten Instanzen. Für DocumentDB serverless ist dieser Wert ein Prozentsatz, der als die Menge der aktuell verwendeten CPU geteilt durch die CPU-Kapazität berechnet wird, die unter dem maximalen DCU-Wert des Clusters verfügbar ist. Amazon DocumentDB überwacht diesen Wert automatisch und skaliert Ihre serverlose Instance, wenn die Instance durchweg einen hohen Anteil ihrer CPU-Kapazität nutzt.
Wenn sich diese Metrik einem Wert von nähert`100.0`, hat die Instance ihre maximale CPU-Kapazität erreicht. Erwägen Sie, die maximale DCU-Einstellung für den Cluster zu erhöhen. Wenn sich diese Metrik einem Wert von `100.0` auf einer Reader-Instance nähert, sollten Sie erwägen, dem Cluster weitere Reader-Instances hinzuzufügen. Auf diese Weise können Sie den schreibgeschützten Teil der Arbeitslast auf mehrere Instances verteilen und so die Belastung der einzelnen Reader-Instances reduzieren.
+ **`FreeableMemory`**— Dieser Wert stellt die Menge an ungenutztem Speicher dar, der verfügbar ist, wenn die serverlose DocumentDB-Instanz auf ihre maximale Kapazität skaliert wird. Für jede DCU, bei der die aktuelle Kapazität unter der maximalen Kapazität liegt, erhöht sich dieser Wert um etwa 2 GiB. Somit nähert sich diese Metrik erst Null, wenn die Instance so weit wie möglich hochskaliert wurde.
Wenn sich diese Metrik einem Wert von Null nähert, hat die Instance so weit wie möglich hochskaliert und nähert sich der Grenze ihres verfügbaren Speichers. Erwägen Sie, die maximale DCU-Einstellung für den Cluster zu erhöhen. Wenn sich diese Metrik auf einer Reader-Instance einem Wert von Null nähert, sollten Sie erwägen, dem Cluster weitere Reader-Instances hinzuzufügen. Auf diese Weise kann der schreibgeschützte Teil der Arbeitslast auf mehrere Instanzen verteilt werden, wodurch der Speicherverbrauch auf jeder Reader-Instance reduziert wird.
+ **`TempStorageIops`**— Die Anzahl der IOPS, die auf dem mit der Instanz verbundenen lokalen Speicher ausgeführt wurden. Dabei sind IOPS für Lese- und Schreibvorgänge enthalten. Diese Metrik stellt eine Zählung dar und wird einmal pro Sekunde gemessen. Dies ist eine neue Metrik für DocumentDB serverless. Details hierzu finden Sie unter [Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md).
+ **`TempStorageThroughput`**— Die Datenmenge, die zum und vom lokalen Speicher übertragen wird, der der Instanz zugeordnet ist. Diese Metrik wird in Byte angegeben und einmal pro Sekunde gemessen. Dies ist eine neue Metrik für DocumentDB serverless. Details hierzu finden Sie unter [Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md).
In der Regel werden die meisten Skalierungen für serverlose DocumentDB-Instanzen durch Speichernutzung und CPU-Aktivität verursacht. Mithilfe der `TempStorageThroughput` Metriken `TempStorageIops` und können Sie die seltenen Fälle diagnostizieren, in denen Netzwerkaktivitäten für Übertragungen zwischen Ihrer Instance und lokalen Speichergeräten für unerwartete Kapazitätssteigerungen verantwortlich sind. Wenn Sie andere Netzwerkaktivitäten überwachen möchten, können Sie diese vorhandenen Metriken verwenden:
+ `NetworkReceiveThroughput`
+ `NetworkThroughput`
+ `NetworkTransmitThroughput`
+ `StorageNetworkReceiveThroughput`
+ `StorageNetworkThroughput`
+ `StorageNetworkTransmitThroughput`
### Wie sich die serverlosen CloudWatch DocumentDB-Metriken auf Ihre Rechnung auswirken AWS
Die Gebühren für serverloses DocumentDB auf Ihrer AWS Rechnung werden auf der Grundlage derselben `ServerlessDatabaseCapacity` Metrik berechnet, die Sie überwachen können. In Fällen, in denen Sie die serverlose Kapazität von DocumentDB nur für einen Teil einer Stunde nutzen, kann der Abrechnungsmechanismus vom berechneten CloudWatch Durchschnitt für diese Metrik abweichen. Es kann auch anders sein, wenn die CloudWatch Metrik aufgrund von Systemproblemen für kurze Zeit nicht verfügbar ist. Daher wird auf Ihrer Rechnung möglicherweise ein etwas anderer Wert für DCU-Stunden angezeigt, als wenn Sie die Zahl anhand des Durchschnittswerts selbst berechnen würden. `ServerlessDatabaseCapacity`
### Beispiele für Amazon CloudWatch CLI-Befehle für serverlose DocumentDB-Metriken
Die folgenden AWS CLI Beispiele zeigen, wie Sie die wichtigsten CloudWatch Metriken im Zusammenhang mit DocumentDB serverless überwachen können. Ersetzen Sie in jedem Fall die `Value=` Zeichenfolge für den `--dimensions` Parameter durch den Bezeichner Ihrer eigenen serverlosen DocumentDB-Instanz.
Das folgende Linux-Beispiel zeigt die minimalen, maximalen und durchschnittlichen Kapazitätswerte für eine Instanz, gemessen alle 10 Minuten über eine Stunde. Die Linux-Datumsbefehle geben die Start- und Endzeit relativ zum aktuellen Datum und zur aktuellen Uhrzeit an. Die `sort_by`-Funktion im `--query`-Parameter sortiert die Ergebnisse chronologisch basierend auf dem Feld `Timestamp`.
```
aws cloudwatch get-metric-statistics \
--metric-name "ServerlessDatabaseCapacity" \
--start-time "$(date -d '1 hour ago')" \
--end-time "$(date -d 'now')" \
--period 600 \
--namespace "AWS/DocDB" \
--statistics Minimum Maximum Average \
--dimensions Name=DBInstanceIdentifier,Value=my_instance \
--query 'sort_by(Datapoints[*].{min:Minimum,max:Maximum,avg:Average,ts:Timestamp},&ts)' \
--output table
```
Das folgende Linux-Beispiel zeigt die Überwachung der Kapazität einer Instanz in einem Cluster. Es misst die minimale, maximale und durchschnittliche Kapazitätsauslastung einer Instanz. Die Messungen werden einmal pro Stunde über einen Zeitraum von drei Stunden durchgeführt. In diesen Beispielen wird die `DCUUtilization` Metrik verwendet, die einen Prozentsatz der Obergrenze `ServerlessDatabaseCapacity` darstellt DCUs, anstatt eine feste Zahl von DCUs. Auf diese Weise müssen Sie die tatsächlichen Zahlen für die minimalen und maximalen DCU-Werte im Kapazitätsbereich nicht kennen. Sie können Prozentsätze zwischen 0 und 100 sehen.
```
aws cloudwatch get-metric-statistics \
--metric-name "DCUUtilization" \
--start-time "$(date -d '3 hours ago')" \
--end-time "$(date -d 'now')" \
--period 3600 \
--namespace "AWS/DocDB" \
--statistics Minimum Maximum Average \
--dimensions Name=DBInstanceIdentifier,Value=my_instance \
--query 'sort_by(Datapoints[*].{min:Minimum,max:Maximum,avg:Average,ts:Timestamp},&ts)' \
--output table
```
Im folgenden Linux-Beispiel werden ähnliche Messungen wie die vorherigen ausgeführt. In diesem Fall gelten die Messungen für die `CPUUtilization`-Metrik Die Messungen werden alle zehn Minuten über einen Zeitraum von einer Stunde durchgeführt. Die Zahlen stellen den Prozentsatz der verfügbaren CPU-Auslastung dar, basierend auf den CPU-Ressourcen, die bei der Einstellung für die maximale Kapazität für die Instanz verfügbar sind.
```
aws cloudwatch get-metric-statistics \
--metric-name "CPUUtilization" \
--start-time "$(date -d '1 hour ago')" \
--end-time "$(date -d 'now')" \
--period 600 \
--namespace "AWS/DocDB" \
--statistics Minimum Maximum Average \
--dimensions Name=DBInstanceIdentifier,Value=my_instance \
--query 'sort_by(Datapoints[*].{min:Minimum,max:Maximum,avg:Average,ts:Timestamp},&ts)' \
--output table
```
Im folgenden Linux-Beispiel werden ähnliche Messungen wie die vorherigen ausgeführt. In diesem Fall gelten die Messungen für die `FreeableMemory`-Metrik Die Messungen werden alle zehn Minuten über einen Zeitraum von einer Stunde durchgeführt.
```
aws cloudwatch get-metric-statistics \
--metric-name "FreeableMemory" \
--start-time "$(date -d '1 hour ago')" \
--end-time "$(date -d 'now')" \
--period 600 \
--namespace "AWS/DocDB" \
--statistics Minimum Maximum Average \
--dimensions Name=DBInstanceIdentifier,Value=my_instance \
--query 'sort_by(Datapoints[*].{min:Minimum,max:Maximum,avg:Average,ts:Timestamp},&ts)' \
--output table
```
## Überwachung der serverlosen Leistung von DocumentDB mit Performance Insights
Sie können Performance Insights verwenden, um die Leistung von serverlosen DocumentDB-Instanzen zu überwachen. Informationen zu Performance-Insights-Verfahren finden Sie unter [Überwachung mit Performance Insights](performance-insights.md).
Die folgenden neuen Performance Insights Insights-Zähler gelten für serverlose DocumentDB-Instanzen:
+ **`os.general.serverlessDBCapacity`**— Die aktuelle Kapazität der Instanz in. DCUs Der Wert entspricht der `ServerlessDatabaseCapacity` CloudWatch Metrik für die Instance.
+ **`os.general.dcuUtilization`**— Der prozentuale Anteil der aktuellen Kapazität an der konfigurierten Maximalkapazität. Der Wert entspricht der `DCUUtilization` CloudWatch Metrik für die Instance.
+ **`os.general.maxConfiguredDcu`**— Die maximale Kapazität, die Sie für diese serverlose DocumentDB-Instanz konfiguriert haben. Sie wird gemessen in. DCUs
+ **`os.general.minConfiguredDcu`**— Die Mindestkapazität, die Sie für diese serverlose DocumentDB-Instanz konfiguriert haben. Sie wird gemessen in. DCUs
Eine vollständige Liste der Performance-Insights-Zähler finden Sie unter [Performance Insights für Zählermetriken](performance-insights-counter-metrics.md).
Wenn vCPU-Werte für eine serverlose DocumentDB-Instance in Performance Insights angezeigt werden, stellen diese Werte Schätzungen dar, die auf dem DCU-Wert für die Instanz basieren. Im Standardintervall von einer Minute werden alle fraktionierten vCPU-Werte auf die nächste ganze Zahl aufgerundet. Für längere Intervalle ist der angezeigte vCPU-Wert der Durchschnitt der ganzzahligen vCPU-Werte für jede Minute.