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.
# Erstellen eines Feature-Flag-Konfigurationsprofils in AWS AppConfig
Sie können Feature-Flags verwenden, um Funktionen in Ihren Anwendungen zu aktivieren oder zu deaktivieren oder um verschiedene Eigenschaften Ihrer Anwendungsfunktionen mithilfe von Flag-Attributen zu konfigurieren. AWS AppConfig speichert Feature-Flag-Konfigurationen im AWS AppConfig gehosteten Konfigurationsspeicher in einem Feature-Flag-Format, das Daten und Metadaten zu Ihren Flags und den Flag-Attributen enthält.
**Anmerkung**
Wenn Sie ein Feature-Flag-Konfigurationsprofil erstellen, können Sie im Rahmen des Konfigurationsprofil-Workflows ein grundlegendes Feature-Flag erstellen. AWS AppConfig unterstützt auch Feature-Flags mit mehreren Varianten. *Feature-Flags mit mehreren Varianten* ermöglichen es Ihnen, eine Reihe möglicher Flag-Werte zu definieren, die für eine Anfrage zurückgegeben werden sollen. Wenn Sie ein mit Varianten konfiguriertes Kennzeichen anfordern, stellt Ihre Anwendung einen Kontext bereit, der anhand einer Reihe von benutzerdefinierten Regeln AWS AppConfig ausgewertet wird. Abhängig vom in der Anfrage angegebenen Kontext und den für die Variante definierten Regeln werden unterschiedliche Flagwerte an die Anwendung AWS AppConfig zurückgegeben.
Um Feature-Flags mit mehreren Varianten zu erstellen, erstellen Sie zuerst ein Konfigurationsprofil und bearbeiten Sie dann alle Flags innerhalb des Konfigurationsprofils, um Varianten hinzuzufügen. Weitere Informationen finden Sie unter [Feature-Flags mit mehreren Varianten erstellen](appconfig-creating-multi-variant-feature-flags.md).
**Topics**
+ [Die Attribute von Feature-Flags verstehen](#appconfig-creating-configuration-profile-feature-flag-attributes)
+ [Erstellen eines Feature-Flag-Konfigurationsprofils (Konsole)](appconfig-creating-feature-flag-configuration-create-console.md)
+ [Erstellen eines Feature-Flag-Konfigurationsprofils (Befehlszeile)](appconfig-creating-feature-flag-configuration-commandline.md)
+ [Feature-Flags mit mehreren Varianten erstellen](appconfig-creating-multi-variant-feature-flags.md)
+ [Grundlegendes zur Typenreferenz für AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md)
+ [Speichern einer früheren Feature-Flag-Version in einer neuen Version](appconfig-creating-configuration-profile-feature-flags-editing-version.md)
## Die Attribute von Feature-Flags verstehen
Wenn Sie ein Feature-Flag-Konfigurationsprofil oder ein neues Flag in einem vorhandenen Konfigurationsprofil erstellen, können Sie Attribute und entsprechende Einschränkungen für das Flag angeben. Ein Attribut ist ein Feld, das Sie Ihrem Feature-Flag zuordnen, um Eigenschaften auszudrücken, die sich auf Ihr Feature-Flag beziehen. Attribute werden zusammen mit Ihrem Flaggenschlüssel und dem `disable` Wert `enable` oder der Markierung an Ihre Anwendung übermittelt.
Einschränkungen stellen sicher, dass keine unerwarteten Attributwerte in Ihrer Anwendung bereitgestellt werden. In der folgenden Abbildung sehen Sie ein Beispiel.
![\[Beispiel für Flag-Attribute für ein AWS AppConfig Feature-Flag\]](http://docs.aws.amazon.com/de_de/appconfig/latest/userguide/images/appconfig-flag-attributes.png)
**Anmerkung**
Beachten Sie die folgenden Informationen zu Flaggenattributen.
Für Attributnamen ist das Wort „aktiviert“ reserviert. Sie können kein Feature-Flag-Attribut mit dem Namen „aktiviert“ erstellen. Es gibt keine anderen reservierten Wörter.
Die Attribute eines Feature-Flags sind nur dann in der `GetLatestConfiguration` Antwort enthalten, wenn dieses Flag aktiviert ist.
Flaggenattributschlüssel für eine bestimmte Flagge müssen eindeutig sein.
AWS AppConfig unterstützt die folgenden Typen von Flaggenattributen und die entsprechenden Einschränkungen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/appconfig/latest/userguide/appconfig-creating-configuration-and-profile-feature-flags.html)
# Erstellen eines Feature-Flag-Konfigurationsprofils (Konsole)
Gehen Sie wie folgt vor, um mithilfe der AWS AppConfig Konsole ein AWS AppConfig Feature-Flag-Konfigurationsprofil zu erstellen. Wenn Sie das Konfigurationsprofil erstellen, können Sie auch ein grundlegendes Feature-Flag erstellen.
**So erstellen Sie ein Konfigurationsprofil**
1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Wählen Sie im Navigationsbereich **Anwendungen** und dann eine Anwendung aus, in der Sie sie erstellt haben. [Erstellen Sie einen Namespace für Ihre Anwendung in AWS AppConfig](appconfig-creating-namespace.md)
1. Wählen Sie auf der Registerkarte **Konfigurationsprofile und Feature-Flags** die Option **Konfiguration erstellen** aus.
1. Wählen Sie im Abschnitt **Konfigurationsoptionen** die Option **Feature-Flag** aus.
1. Geben Sie im Abschnitt **Konfigurationsprofil** für den **Namen des Konfigurationsprofils** einen Namen ein.
1. (Optional) Erweitern Sie **Beschreibung** und geben Sie eine Beschreibung ein.
1. (Optional) Erweitern Sie **Zusätzliche Optionen** und füllen Sie bei Bedarf die folgenden Schritte aus.
1. Wählen Sie in der **Verschlüsselungsliste** einen AWS Key Management Service (AWS KMS) Schlüssel aus der Liste aus. Mit diesem vom Kunden verwalteten Schlüssel können Sie neue Versionen von Konfigurationsdaten im AWS AppConfig gehosteten Konfigurationsspeicher verschlüsseln. Weitere Informationen zu diesem Schlüssel finden Sie unter **AWS AppConfig Unterstützt Schlüssel für Kundenmanager** in[Sicherheit in AWS AppConfig](appconfig-security.md).
1. Wählen Sie im Abschnitt **Tags** die Option **Neues Tag hinzufügen** aus und geben Sie dann einen Schlüssel und einen optionalen Wert an.
1. Wählen Sie **Weiter** aus.
1. Geben Sie im Abschnitt **Feature-Flag-Definition** für **Flagname** einen Namen ein.
1. Geben Sie **unter Flag-Schlüssel** eine Flag-ID ein, um Flags innerhalb desselben Konfigurationsprofils voneinander zu unterscheiden. Flags innerhalb desselben Konfigurationsprofils können nicht denselben Schlüssel haben. Nachdem das Flag erstellt wurde, können Sie den Flag-Namen bearbeiten, aber nicht den Flaggenschlüssel.
1. (Optional) Erweitern Sie **Beschreibung** und geben Sie Informationen zu dieser Flagge ein.
1. Wählen Sie „**Dies ist eine kurzfristige Kennzeichnung**“ und wählen Sie optional ein Datum aus, an dem die Kennzeichnung deaktiviert oder gelöscht werden soll. AWS AppConfig deaktiviert die Markierung am Verfallsdatum *nicht*.
1. (Optional) Wählen Sie im Abschnitt **Feature-Flag-Attribute** die Option Attribut **definieren** aus. Mithilfe von Attributen können Sie zusätzliche Werte in Ihrer Flagge angeben. Weitere Informationen zu Attributen und Einschränkungen finden Sie unter[Die Attribute von Feature-Flags verstehen](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Geben Sie für **Schlüssel** einen Flaggenschlüssel an und wählen Sie seinen Typ aus der Liste **Typ** aus. Informationen zu den unterstützten Optionen für die Felder **Wert** und **Einschränkungen** finden Sie im Abschnitt über Attribute, auf den zuvor verwiesen wurde.
1. Wählen Sie **Erforderlicher Wert** aus, um anzugeben, ob ein Attributwert erforderlich ist.
1. Wählen Sie **Attribut definieren**, um weitere Attribute hinzuzufügen.
1. Wählen Sie im Abschnitt **Feature-Flag-Wert** die Option **Aktiviert** aus, um die Markierung zu aktivieren. Verwenden Sie denselben Schalter, um eine Markierung zu deaktivieren, wenn sie ein bestimmtes Verfallsdatum erreicht, falls zutreffend.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie auf der Seite **Überprüfen und speichern** die Details der Markierung und klicken Sie dann auf **Speichern und mit der Bereitstellung fortfahren**.
Fahren Sie mit [Bereitstellung von Feature-Flags und Konfigurationsdaten in AWS AppConfig](deploying-feature-flags.md) fort.
# Erstellen eines Feature-Flag-Konfigurationsprofils (Befehlszeile)
Im folgenden Verfahren wird beschrieben, wie Sie mithilfe von AWS Command Line Interface (unter Linux oder Windows) oder Tools für Windows PowerShell ein AWS AppConfig Feature-Flag-Konfigurationsprofil erstellen. Wenn Sie das Konfigurationsprofil erstellen, können Sie auch ein grundlegendes Feature-Flag erstellen.
**Um eine Feature-Flag-Konfiguration zu erstellen**
1. Öffnen Sie das AWS CLI.
1. Erstellen Sie ein Konfigurationsprofil für Feature-Flags und geben Sie dessen **Typ** als an`AWS.AppConfig.FeatureFlags`. Das Konfigurationsprofil muss den URI `hosted` für den Standort verwenden.
------
#### [ Linux ]
```
aws appconfig create-configuration-profile \
--application-id APPLICATION_ID \
--name CONFIGURATION_PROFILE_NAME \
--location-uri hosted \
--type AWS.AppConfig.FeatureFlags
```
------
#### [ Windows ]
```
aws appconfig create-configuration-profile ^
--application-id APPLICATION_ID ^
--name CONFIGURATION_PROFILE_NAME ^
--location-uri hosted ^
--type AWS.AppConfig.FeatureFlags
```
------
#### [ PowerShell ]
```
New-APPCConfigurationProfile `
-Name CONFIGURATION_PROFILE_NAME `
-ApplicationId APPLICATION_ID `
-LocationUri hosted `
-Type AWS.AppConfig.FeatureFlags
```
------
1. Erstellen Sie Ihre Feature-Flag-Konfigurationsdaten. Ihre Daten müssen in einem JSON-Format vorliegen und dem `AWS.AppConfig.FeatureFlags` JSON-Schema entsprechen. Weitere Informationen zum Schema finden Sie unter[Grundlegendes zur Typenreferenz für AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md).
1. Verwenden Sie die `CreateHostedConfigurationVersion` API, um Ihre Feature-Flag-Konfigurationsdaten zu speichern AWS AppConfig.
------
#### [ Linux ]
```
aws appconfig create-hosted-configuration-version \
--application-id APPLICATION_ID \
--configuration-profile-id CONFIGURATION_PROFILE_ID \
--content-type "application/json" \
--content file://path/to/feature_flag_configuration_data.json \
--cli-binary-format raw-in-base64-out
```
------
#### [ Windows ]
```
aws appconfig create-hosted-configuration-version ^
--application-id APPLICATION_ID ^
--configuration-profile-id CONFIGURATION_PROFILE_ID ^
--content-type "application/json" ^
--content file://path/to/feature_flag_configuration_data.json ^
--cli-binary-format raw-in-base64-out
```
------
#### [ PowerShell ]
```
New-APPCHostedConfigurationVersion `
-ApplicationId APPLICATION_ID `
-ConfigurationProfileId CONFIGURATION_PROFILE_ID `
-ContentType "application/json" `
-Content file://path/to/feature_flag_configuration_data.json
```
------
Der Befehl lädt den für den `Content` Parameter angegebenen Inhalt von der Festplatte. Der Inhalt muss dem folgenden Beispiel ähneln.
```
{
"flags": {
"ui_refresh": {
"name": "UI Refresh"
}
},
"values": {
"ui_refresh": {
"enabled": false,
"attributeValues": {
"dark_mode_support": true
}
}
},
"version": "1"
}
```
Das System gibt unter anderem folgende Informationen zurück
------
#### [ Linux ]
```
{
"ApplicationId" : "ui_refresh",
"ConfigurationProfileId" : "UI Refresh",
"VersionNumber" : "1",
"ContentType" : "application/json"
}
```
------
#### [ Windows ]
```
{
"ApplicationId" : "ui_refresh",
"ConfigurationProfileId" : "UI Refresh",
"VersionNumber" : "1",
"ContentType" : "application/json"
}
```
------
#### [ PowerShell ]
```
ApplicationId : ui_refresh
ConfigurationProfileId : UI Refresh
VersionNumber : 1
ContentType : application/json
```
------
Das `service_returned_content_file` enthält Ihre Konfigurationsdaten, die einige AWS AppConfig generierte Metadaten enthalten.
**Anmerkung**
Wenn Sie die gehostete Konfigurationsversion erstellen, wird AWS AppConfig überprüft, ob Ihre Daten dem `AWS.AppConfig.FeatureFlags` JSON-Schema entsprechen. AWS AppConfig überprüft außerdem, ob jedes Feature-Flag-Attribut in Ihren Daten die Einschränkungen erfüllt, die Sie für diese Attribute definiert haben.
# Feature-Flags mit mehreren Varianten erstellen
Mit Feature-Flag-Varianten können Sie eine Reihe möglicher Flag-Werte definieren, die bei einer Anfrage zurückgegeben werden sollen. Sie können auch verschiedene Status (aktiviert oder deaktiviert) für Flags mit mehreren Varianten konfigurieren. Wenn Sie ein mit Varianten konfiguriertes Kennzeichen anfordern, stellt Ihre Anwendung einen Kontext bereit, der anhand einer Reihe von benutzerdefinierten Regeln AWS AppConfig ausgewertet wird. Abhängig vom in der Anfrage angegebenen Kontext und den für die Variante definierten Regeln werden unterschiedliche Flagwerte an die Anwendung AWS AppConfig zurückgegeben.
Der folgende Screenshot zeigt ein Beispiel für ein Feature-Flag mit drei benutzerdefinierten Varianten und der Standardvariante.
![\[Ein Beispiel-Screenshot einer Feature-Flag mit Varianten.\]](http://docs.aws.amazon.com/de_de/appconfig/latest/userguide/images/flag-variant-example.png)
**Topics**
+ [Grundlegendes zu Konzepten von Feature-Flags mit mehreren Varianten und zu häufigen Anwendungsfällen](appconfig-creating-multi-variant-feature-flags-concepts.md)
+ [Grundlegendes zu Feature-Flag-Regeln mit mehreren Varianten](appconfig-creating-multi-variant-feature-flags-rules.md)
+ [Erstellen eines Feature-Flags mit mehreren Varianten](appconfig-creating-multi-variant-feature-flags-procedures.md)
# Grundlegendes zu Konzepten von Feature-Flags mit mehreren Varianten und zu häufigen Anwendungsfällen
Um Ihnen zu helfen, Feature-Flag-Varianten besser zu verstehen, werden in diesem Abschnitt die Konzepte von Flag-Varianten und allgemeine Anwendungsfälle erläutert.
**Konzepte**
+ **Feature-Flag**: Ein AWS AppConfig Konfigurationstyp, der verwendet wird, um das Verhalten einer Funktion in einer Anwendung zu steuern. Ein Flag hat einen Status (aktiviert oder deaktiviert) und einen optionalen Satz von Attributen, die beliebige Zeichenketten-, numerische, boolesche oder Array-Werte enthalten.
+ **Feature-Flag-Variante**: Eine spezifische Kombination von Status- und Attributwerten, die zu einem Feature-Flag gehören. Ein Feature-Flag kann mehrere Varianten haben.
+ **Variantenregel**: Ein benutzerdefinierter Ausdruck, der zur Auswahl einer Feature-Flag-Variante verwendet wird. Jede Variante hat ihre eigene Regel, die AWS AppConfig auswertet, um zu bestimmen, ob sie zurückgegeben werden soll oder nicht.
+ **Standardvariante**: Eine spezielle Variante, die zurückgegeben wird, wenn keine andere Variante ausgewählt wurde. Alle Feature-Flags mit mehreren Varianten haben eine Standardvariante.
Beachten Sie, dass die Standardvariante in Ihrer Reihenfolge der Varianten an letzter Stelle stehen muss und dass ihr keine Regeln zugeordnet sein dürfen. Wenn sie nicht zuletzt definiert wurde, wird a AWS AppConfig zurückgegeben, `BadRequestException` wenn Sie versuchen, das Kennzeichen für mehrere Varianten zu erstellen.
+ **Kontext**: Benutzerdefinierte Schlüssel und Werte, an die AWS AppConfig beim Abrufen der Konfiguration übergeben wurde. Kontextwerte werden bei der Regelauswertung verwendet, um die Feature-Flag-Variante auszuwählen, die zurückgegeben werden soll.
**Anmerkung**
AWS AppConfig Der Agent bewertet Variantenregeln und bestimmt anhand des bereitgestellten Kontextes, welche Regel für die Anfrage gilt. Weitere Informationen zum Abrufen von Feature-Flags mit mehreren Varianten finden Sie unter. [Feature-Flags für grundlegende und variantenreiche Funktionen werden abgerufen](appconfig-integration-retrieving-feature-flags.md)
**Allgemeine Anwendungsfälle**
In diesem Abschnitt werden zwei häufige Anwendungsfälle für Feature-Flag-Varianten beschrieben.
*Benutzersegmentierung*
Bei der Benutzersegmentierung werden Benutzer anhand bestimmter Attribute aufgeteilt. Sie könnten beispielsweise Flaggenvarianten verwenden, um eine Funktion einigen Benutzern zugänglich zu machen, anderen jedoch nicht, basierend auf ihrer Benutzer-ID, ihrem geografischen Standort, ihrem Gerätetyp oder ihrer Kaufhäufigkeit.
Nehmen wir am Beispiel der Kaufhäufigkeit an, dass Ihre E-Commerce-Anwendung eine Funktion zur Steigerung der Kundenbindung unterstützt. Sie können Flaggenvarianten verwenden, um verschiedene Arten von Anreizen zu konfigurieren, die einem Nutzer angezeigt werden, je nachdem, wann er zuletzt etwas gekauft hat. Einem neuen Benutzer kann ein kleiner discount angeboten werden, um ihn zu ermutigen, Kunde zu werden, wohingegen einem Stammkunden möglicherweise ein größerer discount gewährt wird, wenn er etwas aus einer neuen Kategorie kauft.
*Datenverkehrsaufteilung*
Beim Traffic Splitting wird eine zufällige, aber konsistente Flaggenvariante ausgewählt, die auf einem von Ihnen definierten Kontextwert basiert. Möglicherweise möchten Sie ein Experiment durchführen, bei dem ein kleiner Prozentsatz Ihrer Benutzer (identifiziert anhand ihrer Benutzer-ID) eine bestimmte Variante sieht. Oder Sie möchten eine schrittweise Einführung einer Funktion durchführen, bei der eine Funktion zunächst für 5% Ihrer Benutzer verfügbar ist, dann für 15%, dann für 40% und dann für 100%, wobei während der gesamten Einführung ein einheitliches Benutzererlebnis gewährleistet ist.
Anhand des Versuchsbeispiels könnten Sie Flaggenvarianten verwenden, um einen neuen Schaltflächenstil für die primäre Aktion auf der Startseite Ihrer Anwendung zu testen, um festzustellen, ob er zu mehr Klicks führt. Für Ihr Experiment könnten Sie eine Flaggenvariante mit einer Regel zur Aufteilung des Datenverkehrs erstellen, bei der 5% der Benutzer ausgewählt werden, um den neuen Stil zu sehen, während die Standardvariante die Benutzer angibt, denen der bestehende Stil weiterhin angezeigt werden soll. Wenn das Experiment erfolgreich ist, können Sie den Prozentwert erhöhen oder diese Variante sogar zur Standardvariante machen.
# Grundlegendes zu Feature-Flag-Regeln mit mehreren Varianten
Wenn Sie eine Feature-Flag-Variante erstellen, geben Sie eine Regel dafür an. Regeln sind Ausdrücke, die Kontextwerte als Eingabe verwenden und als Ausgabe ein boolesches Ergebnis erzeugen. Sie könnten beispielsweise eine Regel definieren, um eine Flag-Variante für Beta-Benutzer auszuwählen, die anhand ihrer Konto-ID identifiziert werden, um eine Aktualisierung der Benutzeroberfläche zu testen. Für dieses Szenario gehen Sie wie folgt vor:
1. Erstellen Sie ein neues Feature-Flag-Konfigurationsprofil mit dem Namen *UI Refresh*.
1. Erstellen Sie ein neues Feature-Flag namens *ui\$1refresh*.
1. Bearbeiten Sie das Feature-Flag, nachdem Sie es erstellt haben, um Varianten hinzuzufügen.
1. Erstellen und aktivieren Sie eine neue Variante namens *BetaUsers*.
1. Definieren Sie eine Regel, die die Variante auswählt *BetaUsers*, wenn die Konto-ID aus dem Anforderungskontext in einer Liste von Konten enthalten ist, die für die Nutzung der neuen Beta-Version IDs zugelassen sind.
1. Vergewissern Sie sich, dass der Status der Standardvariante auf **Deaktiviert** gesetzt ist.
**Anmerkung**
Varianten werden anhand der Reihenfolge, in der sie in der Konsole definiert sind, als geordnete Liste bewertet. Die Variante ganz oben in der Liste wird zuerst ausgewertet. Wenn keine Regeln mit dem angegebenen Kontext übereinstimmen, wird die Standardvariante AWS AppConfig zurückgegeben.
Bei AWS AppConfig der Verarbeitung der Feature-Flag-Anforderung wird der angegebene Kontext, der die AccountID (für dieses Beispiel) enthält, zuerst mit der BetaUsers Variante verglichen. Wenn der Kontext der Regel für entspricht BetaUsers, werden die Konfigurationsdaten für das Beta-Erlebnis AWS AppConfig zurückgegeben. Wenn der Kontext keine Konto-ID enthält oder wenn die Konto-ID auf etwas anderes als 123 endet, werden Konfigurationsdaten für die Standardregel AWS AppConfig zurückgegeben, was bedeutet, dass der Benutzer das aktuelle Erlebnis in der Produktionsumgebung aufruft.
**Anmerkung**
Informationen zum Abrufen von Feature-Flags mit mehreren Varianten finden Sie unter. [Feature-Flags für grundlegende und variantenreiche Funktionen werden abgerufen](appconfig-integration-retrieving-feature-flags.md)
# Definieren von Regeln für Feature-Flags mit mehreren Varianten
Eine Variantenregel ist ein Ausdruck, der aus einem oder mehreren Operanden und einem Operator besteht. Ein Operand ist ein bestimmter Wert, der bei der Auswertung einer Regel verwendet wird. Operandenwerte können entweder statisch sein, z. B. eine Literalzahl oder Zeichenfolge, oder variabel, z. B. der in einem Kontext gefundene Wert oder das Ergebnis eines anderen Ausdrucks. Ein Operator, z. B. „größer als“, ist ein Test oder eine Aktion, die auf seine Operanden angewendet wird und einen Wert erzeugt. Ein Variantenregelausdruck muss entweder „wahr“ oder „falsch“ ergeben, um gültig zu sein.
**Operanden**
****
| Typ | Description | Beispiel |
| --- | --- | --- |
| Zeichenfolge | Eine Folge von UTF-8-Zeichen, eingeschlossen in doppelte Anführungszeichen. | "apple", "Ḽơᶉëᶆ ȋṕšᶙṁ"
|
| Ganzzahl | Ein 64-Bit-Ganzzahlwert. | -7, 42
|
| Gleitkommazahl | Ein 64-Bit-IEEE-754-Gleitkommawert. | 3.14, 1.234e-5
|
| Zeitstempel | Ein bestimmter Zeitpunkt, wie in der [W3C-Anmerkung](https://www.w3.org/TR/NOTE-datetime) zu Datums- und Uhrzeitformaten beschrieben. | 2012-03-04T05:06:07-08:00, 2024-01
|
| Boolesch | Ein wahrer oder falscher Wert. | true, false
|
| Kontextwert | Ein parametrisierter Wert in Form von \$1*key*, der während der Regelauswertung aus dem Kontext abgerufen wird. | $country, $userId
|
**Vergleichsoperatoren**
****
| Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| eq | Ermittelt, ob ein Kontextwert einem bestimmten Wert entspricht. | (eq $state "Virginia")
|
| gt | Ermittelt, ob ein Kontextwert größer als ein bestimmter Wert ist. | (gt $age 65)
|
| gte | Ermittelt, ob ein Kontextwert größer oder gleich einem bestimmten Wert ist. | (gte $age 65)
|
| lt | Ermittelt, ob ein Kontextwert kleiner als ein bestimmter Wert ist. | (lt $age 65)
|
| lte | Ermittelt, ob ein Kontextwert kleiner oder gleich einem bestimmten Wert ist. | (lte $age 65)
|
**Logische Operatoren**
****
| Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| und | Ermittelt, ob beide Operanden wahr sind. | (and
(eq $state "Virginia")
(gt $age 65)
)
|
| oder | Ermittelt, ob mindestens einer der Operanden wahr ist. | (or
(eq $state "Virginia")
(gt $age 65)
)
|
| not | Kehrt den Wert eines Ausdrucks um. | (not (eq $state "Virginia"))
|
**Benutzerdefinierte Operatoren**
****
| Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| Beginnt mit | Bestimmt, ob ein Kontextwert mit einem bestimmten Präfix beginnt. | (begins_with $state "A")
|
| ends\$1with | Bestimmt, ob ein Kontextwert mit einem bestimmten Präfix endet. | (ends_with $email "amazon.com")
|
| enthält | Ermittelt, ob ein Kontextwert eine bestimmte Teilzeichenfolge enthält. | (contains $promoCode "WIN")
|
| in | Ermittelt, ob ein Kontextwert in einer Liste von Konstanten enthalten ist. | (in $userId ["123", "456"])
|
| Streichhölzer | Ermittelt, ob ein Kontextwert einem bestimmten Regex-Muster entspricht. | (matches in::$greeting pattern::"h.*y")
|
| exists | Ermittelt, ob ein Wert für einen Kontextschlüssel angegeben wurde. | (exists key::"country")
|
| split | Berechnet bis `true` für einen bestimmten Prozentsatz des Datenverkehrs auf der Grundlage eines konsistenten Hashwerts der angegebenen Kontextwerte. Eine ausführliche Erläuterung der `split` Funktionsweise finden Sie im nächsten Abschnitt dieses Themas,[Den Split-Operator verstehen](appconfig-creating-multi-variant-feature-flags-rules.md#appconfig-creating-multi-variant-feature-flags-rules-operators-split). Beachten Sie, dass `seed` es sich um eine optionale Eigenschaft handelt. Wenn Sie nichts angeben`seed`, ist der Hash *lokal* konsistent, was bedeutet, dass der Verkehr für dieses Flag konsistent aufgeteilt wird, aber andere Flags, die denselben Kontextwert erhalten, den Verkehr möglicherweise anders aufteilen. Wenn angegeben, `seed` wird garantiert, dass jeder eindeutige Wert den Datenverkehr konsistent auf Feature-Flags, Konfigurationsprofile und aufteilt AWS-Konten. | (split pct::10 by::$userId seed::"abc")
|
## Den Split-Operator verstehen
Im folgenden Abschnitt wird beschrieben, wie sich der `split` Operator verhält, wenn er in verschiedenen Szenarien verwendet wird. Zur Erinnerung: Es wird `true` für einen bestimmten Prozentsatz des Datenverkehrs auf der Grundlage eines konsistenten Hashwerts des angegebenen Kontextwerts `split` ausgewertet. Um dies besser zu verstehen, stellen Sie sich das folgende Basisszenario vor, das Split mit zwei Varianten verwendet:
```
A: (split by::$uniqueId pct::20)
C:
```
Erwartungsgemäß ergibt die Bereitstellung einer zufälligen Menge von `uniqueId` Werten eine Verteilung, die ungefähr:
```
A: 20%
C: 80%
```
Wenn Sie eine dritte Variante hinzufügen, aber denselben aufgeteilten Prozentsatz wie folgt verwenden:
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::20)
C:
```
Am Ende erhalten Sie die folgende Verteilung:
```
A: 20%
B: 0%
C: 80%
```
Diese potenziell unerwartete Verteilung tritt auf, weil jede Variantenregel der Reihe nach ausgewertet wird und die erste Übereinstimmung die zurückgegebene Variante bestimmt. Wenn Regel A ausgewertet wird, stimmen 20% der `uniqueId` Werte mit ihr überein, sodass die erste Variante zurückgegeben wird. Als Nächstes wird Regel B ausgewertet. Alle `uniqueId` Werte, die mit der zweiten Split-Anweisung übereinstimmen würden, wurden jedoch bereits durch Variantenregel A abgeglichen, sodass keine Werte mit B übereinstimmen. Stattdessen wird die Standardvariante zurückgegeben.
Betrachten Sie nun ein drittes Beispiel.
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::25)
C:
```
Wie im vorherigen Beispiel entsprechen die ersten 20% der `uniqueId` Werte Regel A. Bei Variante B würden 25% aller `uniqueId` Werte übereinstimmen, aber die meisten der Werte, die zuvor mit Regel A übereinstimmten, so dass 5% der Gesamtsumme für Variante B übrig bleiben und der Rest Variante C erhält. Die Verteilung würde wie folgt aussehen:
```
A: 20%
B: 5%
C: 75%
```
**Verwendung der `seed` Eigenschaft**
Sie können die `seed` Eigenschaft verwenden, um sicherzustellen, dass der Datenverkehr für einen bestimmten Kontextwert konsistent aufgeteilt wird, unabhängig davon, wo der Split-Operator verwendet wird. Wenn Sie nichts angeben`seed`, ist der Hash *lokal* konsistent, was bedeutet, dass der Verkehr für dieses Flag konsistent aufgeteilt wird, aber andere Flags, die denselben Kontextwert erhalten, den Verkehr möglicherweise anders aufteilen. Wenn angegeben, `seed` wird garantiert, dass jeder eindeutige Wert den Datenverkehr konsistent auf Feature-Flags, Konfigurationsprofile und aufteilt AWS-Konten.
In der Regel verwenden Kunden denselben `seed` Wert für alle Varianten innerhalb eines Flags, wenn sie den Traffic auf dieselbe Kontexteigenschaft aufteilen. Gelegentlich kann es jedoch sinnvoll sein, einen anderen Startwert zu verwenden. Hier ist ein Beispiel, das unterschiedliche Ausgangswerte für die Regeln A und B verwendet:
```
A: (split by::$uniqueId pct::20 seed::"seed_one")
B: (split by::$uniqueId pct::25 seed::"seed_two")
C:
```
Wie zuvor entsprechen 20% der übereinstimmenden `uniqueId` Werte Regel A. Das bedeutet, dass 80% der Werte durchfallen und anhand der Variantenregel B getestet werden. Da der Ausgangswert unterschiedlich ist, besteht keine Korrelation zwischen den Werten, die mit A übereinstimmen, und den Werten, die B entsprechen. Es müssen jedoch nur 80% so viele `uniqueId` Werte aufgeteilt werden, wobei 25% dieser Zahl Regel B entsprechen und 75% nicht. Das ergibt die folgende Verteilung:
```
A: 20%
B: 20% (25% of what falls through from A, or 25% of 80%)
C: 60%
```
# Erstellen eines Feature-Flags mit mehreren Varianten
Verwenden Sie die Verfahren in diesem Abschnitt, um Varianten eines Feature-Flags zu erstellen.
**Bevor Sie beginnen**
Notieren Sie die folgenden wichtigen Informationen.
+ Sie können Varianten vorhandener Feature-Flags erstellen, indem Sie sie bearbeiten. Sie können keine Varianten eines neuen Feature-Flags *erstellen, wenn Sie ein neues Konfigurationsprofil* erstellen. Sie müssen zuerst den Arbeitsablauf zur Erstellung des neuen Konfigurationsprofils abschließen. Nachdem Sie das Konfigurationsprofil erstellt haben, können Sie jeder Markierung innerhalb des Konfigurationsprofils Varianten hinzufügen. Informationen zum Erstellen eines neuen Konfigurationsprofils finden Sie unter[Erstellen eines Feature-Flag-Konfigurationsprofils in AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Um Feature-Flag-Variantendaten für Amazon EC2-, Amazon ECS- und Amazon EKS-Rechenplattformen abzurufen, müssen Sie AWS AppConfig Agent Version 2.0.4416 oder höher verwenden.
+ Aus Leistungsgründen AWS CLI und aus SDK-Aufrufen werden AWS AppConfig keine Variantendaten abgerufen. Weitere Informationen zu AWS AppConfig Agent finden Sie unter[Wie benutzt man den AWS AppConfig Agenten zum Abrufen von Konfigurationsdaten](appconfig-agent-how-to-use.md).
+ Wenn Sie eine Feature-Flag-Variante erstellen, geben Sie eine Regel dafür an. Regeln sind Ausdrücke, die den Anforderungskontext als Eingabe verwenden und als Ausgabe ein boolesches Ergebnis erzeugen. Bevor Sie Varianten erstellen, überprüfen Sie die unterstützten Operanden und Operatoren für Flag-Variantenregeln. Sie können Regeln erstellen, bevor Sie Varianten erstellen. Weitere Informationen finden Sie unter [Grundlegendes zu Feature-Flag-Regeln mit mehreren Varianten](appconfig-creating-multi-variant-feature-flags-rules.md).
**Topics**
+ [Feature-Flag mit mehreren Varianten erstellen (Konsole)](#appconfig-creating-multi-variant-feature-flags-procedures-console)
+ [Ein Feature-Flag mit mehreren Varianten erstellen (Befehlszeile)](#appconfig-creating-multi-variant-feature-flags-procedures-commandline)
## Feature-Flag mit mehreren Varianten erstellen (Konsole)
Im folgenden Verfahren wird beschrieben, wie Sie mithilfe der Konsole ein Feature-Flag mit mehreren Varianten für ein vorhandenes Konfigurationsprofil erstellen. AWS AppConfig Sie können auch vorhandene Feature-Flags bearbeiten, um Varianten zu erstellen.
**Um ein Feature-Flag mit mehreren Varianten zu erstellen**
1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Wählen Sie im Navigationsbereich **Anwendungen** und dann eine Anwendung aus.
1. Wählen Sie auf der Registerkarte **Konfigurationsprofile und Feature-Flags** ein vorhandenes Feature-Flag-Konfigurationsprofil aus.
1. Wählen Sie im Abschnitt **Flags** die Option **Neue Flagge hinzufügen** aus.
1. Geben Sie im Abschnitt **Feature-Flag-Definition** für **Flagname** einen Namen ein.
1. Geben Sie **unter Flag-Schlüssel** eine Flag-ID ein, um Flags innerhalb desselben Konfigurationsprofils voneinander zu unterscheiden. Flags innerhalb desselben Konfigurationsprofils können nicht denselben Schlüssel haben. Nachdem das Flag erstellt wurde, können Sie den Flag-Namen bearbeiten, aber nicht den Flaggenschlüssel.
1. (Optional) Geben Sie im Feld **Beschreibung** Informationen zu dieser Flagge ein.
1. Wählen Sie im Abschnitt **Varianten** die Option **Flagge mit mehreren Varianten** aus.
1. (Optional) Wählen Sie im Abschnitt **Feature-Flag-Attribute** die Option **Attribut definieren** aus. Mithilfe von Attributen können Sie zusätzliche Werte in Ihrer Flagge angeben. Weitere Informationen zu Attributen und Einschränkungen finden Sie unter[Die Attribute von Feature-Flags verstehen](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Geben Sie für **Schlüssel** einen Flaggenschlüssel an und wählen Sie seinen Typ aus der Liste **Typ** aus. Informationen zu den unterstützten Optionen für die Felder **Wert** und **Einschränkungen** finden Sie im Abschnitt über Attribute, auf den zuvor verwiesen wurde.
1. Wählen Sie **Erforderlicher Wert** aus, um anzugeben, ob ein Attributwert erforderlich ist.
1. Wählen Sie **Attribut definieren**, um weitere Attribute hinzuzufügen.
1. Wählen Sie **Anwenden**, um die Attributänderungen zu speichern.
1. Wählen Sie im Abschnitt **Feature-Flag-Varianten** die Option **Variante erstellen** aus.
1. Geben Sie **unter Variantenname** einen Namen ein.
1. Verwenden Sie den Schalter **Aktivierter Wert**, um die Variante zu aktivieren.
1. Geben Sie im Textfeld **Regel** eine Regel ein.
1. Verwenden Sie die Optionen **Variante erstellen** **> Variante oben** **erstellen oder Variante unten** erstellen, um zusätzliche Varianten für dieses Kennzeichen zu erstellen.
1. Verwenden Sie im Abschnitt **Standardvariante** den Schalter **Aktivierter Wert**, um die Standardvariante zu aktivieren. Geben Sie optional Werte für die in Schritt 10 definierten Attribute an.
1. Wählen Sie **Anwenden** aus.
1. Überprüfen Sie die Details der Markierung und ihrer Varianten und wählen Sie **Flagge erstellen** aus.
Informationen zur Bereitstellung Ihres neuen Feature-Flags mit Varianten finden Sie unter[Bereitstellung von Feature-Flags und Konfigurationsdaten in AWS AppConfig](deploying-feature-flags.md).
## Ein Feature-Flag mit mehreren Varianten erstellen (Befehlszeile)
Das folgende Verfahren beschreibt, wie Sie das AWS Command Line Interface (unter Linux oder Windows) oder Tools für Windows verwenden, PowerShell um ein multivariantes Feature-Flag für ein vorhandenes Konfigurationsprofil zu erstellen. Sie können auch vorhandene Feature-Flags bearbeiten, um Varianten zu erstellen.
**Bevor Sie beginnen**
Führen Sie die folgenden Aufgaben aus, bevor Sie ein Feature-Flag mit mehreren Varianten mithilfe von erstellen. AWS CLI
+ Erstellen Sie ein Feature-Flag-Konfigurationsprofil. Weitere Informationen finden Sie unter [Erstellen eines Feature-Flag-Konfigurationsprofils in AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Aktualisieren Sie auf die neueste Version von AWS CLI. Weitere Informationen finden Sie unter [Installieren oder Aktualisieren auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) im *AWS Command Line Interface -Benutzerhandbuch*.
**Um ein Feature-Flag mit mehreren Varianten zu erstellen**
1. Erstellen Sie auf Ihrem lokalen Computer eine Konfigurationsdatei, die die Details des Flag mit mehreren Varianten angibt, das Sie erstellen möchten. Speichern Sie die Datei mit einer `.json` Dateierweiterung. Die Datei muss dem [https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-type-reference-feature-flags.html](https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-type-reference-feature-flags.html)JSON-Schema entsprechen. Der Schemainhalt Ihrer Konfigurationsdatei wird dem Folgenden ähneln.
```
{
"flags": {
"FLAG_NAME": {
"attributes": {
"ATTRIBUTE_NAME": {
"constraints": {
"type": "CONSTRAINT_TYPE"
}
}
},
"description": "FLAG_DESCRIPTION",
"name": "VARIANT_NAME"
}
},
"values": {
"VARIANT_VALUE_NAME": {
"_variants": [
{
"attributeValues": {
"ATTRIBUTE_NAME": BOOLEAN
},
"enabled": BOOLEAN,
"name": "VARIANT_NAME",
"rule": "VARIANT_RULE"
},
{
"attributeValues": {
"ATTRIBUTE_NAME": BOOLEAN
},
"enabled": BOOLEAN,
"name": "VARIANT_NAME",
"rule": "VARIANT_RULE"
},
{
"attributeValues": {
"ATTRIBUTE_NAME": BOOLEAN
},
"enabled": BOOLEAN,
"name": "VARIANT_NAME",
"rule": "VARIANT_RULE"
},
{
"attributeValues": {
"ATTRIBUTE_NAME": BOOLEAN
},
"enabled": BOOLEAN,
"name": "VARIANT_NAME",
"rule": "VARIANT_RULE"
}
]
}
},
"version": "VERSION_NUMBER"
}
```
Hier ist ein Beispiel mit drei Varianten und der Standardvariante.
```
{
"flags": {
"ui_refresh": {
"attributes": {
"dark_mode_support": {
"constraints": {
"type": "boolean"
}
}
},
"description": "A release flag used to release a new UI",
"name": "UI Refresh"
}
},
"values": {
"ui_refresh": {
"_variants": [
{
"attributeValues": {
"dark_mode_support": true
},
"enabled": true,
"name": "QA",
"rule": "(ends_with $email \"qa-testers.mycompany.com\")"
},
{
"attributeValues": {
"dark_mode_support": true
},
"enabled": true,
"name": "Beta Testers",
"rule": "(exists key::\"opted_in_to_beta\")"
},
{
"attributeValues": {
"dark_mode_support": false
},
"enabled": true,
"name": "Sample Population",
"rule": "(split pct::10 by::$email)"
},
{
"attributeValues": {
"dark_mode_support": false
},
"enabled": false,
"name": "Default Variant"
}
]
}
},
"version": "1"
}
```
1. Verwenden Sie die `CreateHostedConfigurationVersion` API, um Ihre Feature-Flag-Konfigurationsdaten zu speichern AWS AppConfig.
------
#### [ Linux ]
```
aws appconfig create-hosted-configuration-version \
--application-id APPLICATION_ID \
--configuration-profile-id CONFIGURATION_PROFILE_ID \
--content-type "application/json" \
--content file://path/to/feature_flag_configuration_data.json \
--cli-binary-format raw-in-base64-out \
outfile
```
------
#### [ Windows ]
```
aws appconfig create-hosted-configuration-version ^
--application-id APPLICATION_ID ^
--configuration-profile-id CONFIGURATION_PROFILE_ID ^
--content-type "application/json" ^
--content file://path/to/feature_flag_configuration_data.json ^
--cli-binary-format raw-in-base64-out ^
outfile
```
------
#### [ PowerShell ]
```
New-APPCHostedConfigurationVersion `
-ApplicationId APPLICATION_ID `
-ConfigurationProfileId CONFIGURATION_PROFILE_ID `
-ContentType "application/json" `
-Content file://path/to/feature_flag_configuration_data.json `
-Raw
```
------
Das `service_returned_content_file` enthält Ihre Konfigurationsdaten, die einige AWS AppConfig generierte Metadaten enthalten.
**Anmerkung**
Wenn Sie die gehostete Konfigurationsversion erstellen, wird AWS AppConfig überprüft, ob Ihre Daten dem [https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-type-reference-feature-flags.html](https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-type-reference-feature-flags.html)JSON-Schema entsprechen. AWS AppConfig überprüft außerdem, ob jedes Feature-Flag-Attribut in Ihren Daten die Einschränkungen erfüllt, die Sie für diese Attribute definiert haben.
# Grundlegendes zur Typenreferenz für AWS.AppConfig.FeatureFlags
Verwenden Sie das `AWS.AppConfig.FeatureFlags` JSON-Schema als Referenz, um Ihre Feature-Flag-Konfigurationsdaten zu erstellen.
```
{
"$schema": "http://json-schema.org/draft-07/schema#",
"definitions": {
"flagSetDefinition": {
"type": "object",
"properties": {
"version": {
"$ref": "#/definitions/flagSchemaVersions"
},
"flags": {
"$ref": "#/definitions/flagDefinitions"
},
"values": {
"$ref": "#/definitions/flagValues"
}
},
"required": ["version"],
"additionalProperties": false
},
"flagDefinitions": {
"type": "object",
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/flagDefinition"
}
},
"additionalProperties": false
},
"flagDefinition": {
"type": "object",
"properties": {
"name": {
"$ref": "#/definitions/customerDefinedName"
},
"description": {
"$ref": "#/definitions/customerDefinedDescription"
},
"_createdAt": {
"type": "string"
},
"_updatedAt": {
"type": "string"
},
"_deprecation": {
"type": "object",
"properties": {
"status": {
"type": "string",
"enum": ["planned"]
},
"date": {
"type": "string",
"format": "date"
}
},
"additionalProperties": false
},
"attributes": {
"$ref": "#/definitions/attributeDefinitions"
}
},
"additionalProperties": false
},
"attributeDefinitions": {
"type": "object",
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/attributeDefinition"
}
},
"maxProperties": 25,
"additionalProperties": false
},
"attributeDefinition": {
"type": "object",
"properties": {
"description": {
"$ref": "#/definitions/customerDefinedDescription"
},
"constraints": {
"oneOf": [
{ "$ref": "#/definitions/numberConstraints" },
{ "$ref": "#/definitions/stringConstraints" },
{ "$ref": "#/definitions/arrayConstraints" },
{ "$ref": "#/definitions/boolConstraints" }
]
}
},
"additionalProperties": false
},
"flagValues": {
"type": "object",
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/flagValue"
}
},
"additionalProperties": false
},
"flagValue": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean"
},
"_createdAt": {
"type": "string"
},
"_updatedAt": {
"type": "string"
},
"_variants": {
"type": "array",
"maxLength": 32,
"items": {
"$ref": "#/definitions/variant"
}
}
},
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/attributeValue",
"maxProperties": 25
}
},
"additionalProperties": false
},
"attributeValue": {
"oneOf": [
{ "type": "string", "maxLength": 1024 },
{ "type": "number" },
{ "type": "boolean" },
{
"type": "array",
"oneOf": [
{
"items": {
"type": "string",
"maxLength": 1024
}
},
{
"items": {
"type": "number"
}
}
]
}
],
"additionalProperties": false
},
"stringConstraints": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["string"]
},
"required": {
"type": "boolean"
},
"pattern": {
"type": "string",
"maxLength": 1024
},
"enum": {
"type": "array",
"maxLength": 100,
"items": {
"oneOf": [
{
"type": "string",
"maxLength": 1024
},
{
"type": "integer"
}
]
}
}
},
"required": ["type"],
"not": {
"required": ["pattern", "enum"]
},
"additionalProperties": false
},
"numberConstraints": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["number"]
},
"required": {
"type": "boolean"
},
"minimum": {
"type": "integer"
},
"maximum": {
"type": "integer"
}
},
"required": ["type"],
"additionalProperties": false
},
"arrayConstraints": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["array"]
},
"required": {
"type": "boolean"
},
"elements": {
"$ref": "#/definitions/elementConstraints"
}
},
"required": ["type"],
"additionalProperties": false
},
"boolConstraints": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["boolean"]
},
"required": {
"type": "boolean"
}
},
"required": ["type"],
"additionalProperties": false
},
"elementConstraints": {
"oneOf": [
{ "$ref": "#/definitions/numberConstraints" },
{ "$ref": "#/definitions/stringConstraints" }
]
},
"variant": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean"
},
"name": {
"$ref": "#/definitions/customerDefinedName"
},
"rule": {
"type": "string",
"maxLength": 16384
},
"attributeValues": {
"type": "object",
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/attributeValue"
}
},
"maxProperties": 25,
"additionalProperties": false
}
},
"required": ["name", "enabled"],
"additionalProperties": false
},
"customerDefinedName": {
"type": "string",
"pattern": "^[^\\n]{1,64}$"
},
"customerDefinedDescription": {
"type": "string",
"maxLength": 1024
},
"flagSchemaVersions": {
"type": "string",
"enum": ["1"]
}
},
"type": "object",
"$ref": "#/definitions/flagSetDefinition",
"additionalProperties": false
}
```
**Wichtig**
Um Feature-Flag-Konfigurationsdaten abzurufen, muss Ihre Anwendung die `GetLatestConfiguration` API aufrufen. Sie können die Konfigurationsdaten für Feature-Flags nicht durch einen Aufruf abrufen`GetConfiguration`, was veraltet ist. Weitere Informationen finden Sie unter [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html) in der *AWS AppConfig -API-Referenz*.
Wenn Ihre Anwendung eine neu bereitgestellte Konfiguration aufruft [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html)und empfängt, werden die Informationen, die Ihre Feature-Flags und -Attribute definieren, entfernt. Das vereinfachte JSON enthält eine Zuordnung von Schlüsseln, die mit jedem der von Ihnen angegebenen Flaggenschlüssel übereinstimmen. Das vereinfachte JSON enthält auch zugeordnete Werte von `true` oder `false` für das `enabled` Attribut. Wenn ein Flag `enabled` auf gesetzt ist`true`, sind alle Attribute des Flags ebenfalls vorhanden. Das folgende JSON-Schema beschreibt das Format der JSON-Ausgabe.
```
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/attributeValuesMap"
}
},
"additionalProperties": false,
"definitions": {
"attributeValuesMap": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean"
}
},
"required": ["enabled"],
"patternProperties": {
"^[a-z][a-zA-Z\\d_-]{0,63}$": {
"$ref": "#/definitions/attributeValue"
}
},
"maxProperties": 25,
"additionalProperties": false
},
"attributeValue": {
"oneOf": [
{ "type": "string","maxLength": 1024 },
{ "type": "number" },
{ "type": "boolean" },
{
"type": "array",
"oneOf": [
{
"items": {
"oneOf": [
{
"type": "string",
"maxLength": 1024
}
]
}
},
{
"items": {
"oneOf": [
{
"type": "number"
}
]
}
}
]
}
],
"additionalProperties": false
}
}
}
```
# Speichern einer früheren Feature-Flag-Version in einer neuen Version
Wenn Sie ein Feature-Flag aktualisieren, AWS AppConfig werden Ihre Änderungen automatisch in einer neuen Version gespeichert. Wenn Sie eine frühere Feature-Flag-Version verwenden möchten, müssen Sie sie in eine Entwurfsversion kopieren und dann speichern. Sie können Änderungen an einer früheren Flag-Version nicht bearbeiten und speichern, ohne sie in einer neuen Version zu speichern.
**Um eine frühere Feature-Flag-Version zu bearbeiten und sie in einer neuen Version zu speichern**
1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Wählen Sie im Navigationsbereich **Anwendungen** und dann die Anwendung mit dem Feature-Flag aus, die Sie bearbeiten und in einer neuen Version speichern möchten.
1. Wählen Sie auf der Registerkarte **Konfigurationsprofile und Feature-Flags** das Konfigurationsprofil mit dem Feature-Flag aus, das Sie bearbeiten und in einer neuen Version speichern möchten.
1. Wählen Sie auf der Registerkarte **Feature-Flags** in der **Versionsliste** die Version aus, die Sie bearbeiten und in einer neuen Version speichern möchten.
1. Wählen Sie In **Entwurfsversion kopieren** aus.
1. Geben Sie im Feld **Versionsbezeichnung** eine neue Bezeichnung ein (optional, aber empfohlen).
1. Geben Sie im Feld **Versionsbeschreibung** eine neue Beschreibung ein (optional, aber empfohlen).
1. Wählen Sie **Version speichern**.
1. Wählen Sie **Bereitstellung starten**, um die neue Version bereitzustellen.