Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d'un profil de configuration d'indicateur de fonctionnalité dans AWS AppConfig
Vous pouvez utiliser des indicateurs de fonctionnalité pour activer ou désactiver des fonctionnalités au sein de vos applications ou pour configurer différentes caractéristiques des fonctionnalités de vos applications à l'aide d'attributs d'indicateur. AWS AppConfig stocke les configurations d'indicateurs de fonctionnalités dans le magasin de configuration AWS AppConfig hébergé dans un format d'indicateur de fonctionnalité qui contient des données et des métadonnées relatives à vos indicateurs et aux attributs des indicateurs.
**Note**
Lorsque vous créez un profil de configuration d'indicateur de fonctionnalité, vous pouvez créer un indicateur de fonctionnalité de base dans le cadre du flux de travail du profil de configuration. AWS AppConfig prend également en charge les drapeaux de fonctionnalités à variantes multiples. *Les indicateurs de fonctionnalités à variantes multiples* vous permettent de définir un ensemble de valeurs d'indicateurs possibles à renvoyer pour une demande. Lorsque vous demandez un indicateur configuré avec des variantes, votre application fournit un contexte qui est AWS AppConfig évalué par rapport à un ensemble de règles définies par l'utilisateur. En fonction du contexte spécifié dans la demande et des règles définies pour la variante, AWS AppConfig renvoie différentes valeurs d'indicateur à l'application.
Pour créer des indicateurs de fonctionnalités à variantes multiples, créez d'abord un profil de configuration, puis modifiez les indicateurs du profil de configuration pour ajouter des variantes. Pour de plus amples informations, veuillez consulter [Création d'indicateurs de fonctionnalités à variantes multiples](appconfig-creating-multi-variant-feature-flags.md).
**Topics**
+ [
## Comprendre les attributs des indicateurs de fonctionnalité
](#appconfig-creating-configuration-profile-feature-flag-attributes)
+ [
# Création d'un profil de configuration d'indicateur de fonctionnalité (console)
](appconfig-creating-feature-flag-configuration-create-console.md)
+ [
# Création d'un profil de configuration d'indicateur de fonctionnalité (ligne de commande)
](appconfig-creating-feature-flag-configuration-commandline.md)
+ [
# Création d'indicateurs de fonctionnalités à variantes multiples
](appconfig-creating-multi-variant-feature-flags.md)
+ [
# Comprendre la référence de type pour AWS.AppConfig.FeatureFlags
](appconfig-type-reference-feature-flags.md)
+ [
# Enregistrer une version précédente d'un indicateur de fonctionnalité dans une nouvelle version
](appconfig-creating-configuration-profile-feature-flags-editing-version.md)
## Comprendre les attributs des indicateurs de fonctionnalité
Lorsque vous créez un profil de configuration d'indicateur de fonctionnalité, ou que vous créez un nouvel indicateur dans un profil de configuration existant, vous pouvez spécifier les attributs et les contraintes correspondantes pour l'indicateur. Un attribut est un champ que vous associez à votre indicateur d'entité pour exprimer les propriétés associées à votre indicateur d'entité. Les attributs sont fournis à votre application avec votre clé de drapeau et la `disable` valeur `enable` ou du drapeau.
Les contraintes garantissent que les valeurs d'attribut inattendues ne sont pas déployées dans votre application. L'image suivante illustre cet affichage :
![\[Exemple d'attributs d'indicateur pour un indicateur de AWS AppConfig fonctionnalité\]](http://docs.aws.amazon.com/fr_fr/appconfig/latest/userguide/images/appconfig-flag-attributes.png)
**Note**
Notez les informations suivantes concernant les attributs des drapeaux.
Pour les noms d'attributs, le mot « activé » est réservé. Vous ne pouvez pas créer un attribut d'indicateur de fonctionnalité appelé « activé ». Il n'y a pas d'autres mots réservés.
Les attributs d'un indicateur de fonctionnalité ne sont inclus dans la `GetLatestConfiguration` réponse que si cet indicateur est activé.
Les clés d'attribut d'un drapeau donné doivent être uniques.
AWS AppConfig prend en charge les types d'attributs de drapeau suivants et les contraintes correspondantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/appconfig/latest/userguide/appconfig-creating-configuration-and-profile-feature-flags.html)
# Création d'un profil de configuration d'indicateur de fonctionnalité (console)
Utilisez la procédure suivante pour créer un profil de configuration d'indicateur de AWS AppConfig fonctionnalité à l'aide de la AWS AppConfig console. Au moment de créer le profil de configuration, vous pouvez également créer un indicateur de fonctionnalité de base.
**Pour créer un profil de configuration**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Dans le volet de navigation, choisissez **Applications**, puis choisissez une application que vous avez créée dans[Création d'un espace de noms pour votre application dans AWS AppConfig](appconfig-creating-namespace.md).
1. Dans l'onglet **Profils de configuration et indicateurs de fonctionnalités**, choisissez **Créer une configuration**.
1. Dans la section **Options de configuration**, choisissez **Feature flag**.
1. Dans la section **Profil de configuration**, pour **Nom du profil de configuration**, entrez un nom.
1. (Facultatif) Développez la **description** et entrez une description.
1. (Facultatif) Développez **les options supplémentaires** et effectuez les opérations suivantes, si nécessaire.
1. Dans la liste **Chiffrement**, choisissez une clé AWS Key Management Service (AWS KMS) dans la liste. Cette clé gérée par le client vous permet de chiffrer les nouvelles versions des données de configuration dans le magasin de configuration AWS AppConfig hébergé. Pour plus d'informations sur cette clé, consultez la section **AWS AppConfig Supporte les touches du gestionnaire de clientèle**[Sécurité dans AWS AppConfig](appconfig-security.md).
1. Dans la section **Balises**, choisissez **Ajouter une nouvelle balise**, puis spécifiez une clé et une valeur facultative.
1. Choisissez **Suivant**.
1. Dans la section **Définition du drapeau de fonctionnalité**, pour **Nom du drapeau**, entrez un nom.
1. Pour la **touche Drapeau**, entrez un identifiant de drapeau pour distinguer les indicateurs au sein d'un même profil de configuration. Les drapeaux d'un même profil de configuration ne peuvent pas avoir la même clé. Une fois le drapeau créé, vous pouvez modifier le nom du drapeau, mais pas la clé du drapeau.
1. (Facultatif) Développez **la description** et entrez les informations relatives à cet indicateur.
1. Sélectionnez **Ceci est un drapeau à court terme** et choisissez éventuellement une date à laquelle le drapeau doit être désactivé ou supprimé. AWS AppConfig ne désactive *pas* le drapeau à la date d'obsolescence.
1. (Facultatif) Dans la section **Attributs du drapeau de fonction**, sélectionnez **Définir l'attribut**. Les attributs vous permettent de fournir des valeurs supplémentaires dans votre drapeau. Pour plus d'informations sur les attributs et les contraintes, consultez[Comprendre les attributs des indicateurs de fonctionnalité](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Pour **Clé**, spécifiez une touche indicateur et choisissez son type dans la liste **Type**. Pour plus d'informations sur les options prises en charge pour les champs **Valeur** et **Contraintes**, consultez la section précédemment référencée sur les attributs.
1. Sélectionnez **Valeur requise** pour indiquer si une valeur d'attribut est requise.
1. Choisissez **Définir un attribut** pour ajouter des attributs supplémentaires.
1. Dans la section **Valeur de l'indicateur de fonctionnalité**, choisissez **Activé** pour activer l'indicateur. Utilisez cette même option pour désactiver un indicateur lorsqu'il atteint une date de dépréciation spécifiée, le cas échéant.
1. Choisissez **Suivant**.
1. Sur la page **Réviser et enregistrer**, vérifiez les détails de l'indicateur, puis **enregistrez et poursuivez le déploiement**.
Passez à [Déploiement d'indicateurs de fonctionnalités et de données de configuration dans AWS AppConfig](deploying-feature-flags.md).
# Création d'un profil de configuration d'indicateur de fonctionnalité (ligne de commande)
La procédure suivante décrit comment utiliser le AWS Command Line Interface (sous Linux ou Windows) ou les outils pour Windows PowerShell pour créer un profil de configuration avec indicateur de AWS AppConfig fonctionnalité. Au moment de créer le profil de configuration, vous pouvez également créer un indicateur de fonctionnalité de base.
**Pour créer une configuration d'indicateur de fonctionnalité**
1. Ouvrez le AWS CLI.
1. Créez un profil de configuration d'indicateur de fonctionnalité en spécifiant son **type** comme`AWS.AppConfig.FeatureFlags`. Le profil de configuration doit être utilisé `hosted` comme URI de localisation.
------
#### [ 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. Créez les données de configuration de votre indicateur de fonctionnalité. Vos données doivent être au format JSON et conformes au schéma `AWS.AppConfig.FeatureFlags` JSON. Pour plus d'informations sur le schéma, consultez[Comprendre la référence de type pour AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md).
1. Utilisez l'`CreateHostedConfigurationVersion`API pour enregistrer les données de configuration de votre indicateur de fonctionnalité dans 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
```
------
La commande charge le contenu spécifié pour le `Content` paramètre à partir du disque. Le contenu doit être similaire à celui de l'exemple suivant.
```
{
"flags": {
"ui_refresh": {
"name": "UI Refresh"
}
},
"values": {
"ui_refresh": {
"enabled": false,
"attributeValues": {
"dark_mode_support": true
}
}
},
"version": "1"
}
```
Le système retourne des informations telles que les suivantes.
------
#### [ 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
```
------
Le `service_returned_content_file` contient vos données de configuration, y compris certaines métadonnées AWS AppConfig générées.
**Note**
Lorsque vous créez la version de configuration hébergée AWS AppConfig , vérifiez que vos données sont conformes au schéma `AWS.AppConfig.FeatureFlags` JSON. AWS AppConfig confirme également que chaque attribut d'indicateur d'entité de vos données répond aux contraintes que vous avez définies pour ces attributs.
# Création d'indicateurs de fonctionnalités à variantes multiples
Les variantes d'indicateurs de fonctionnalité vous permettent de définir un ensemble de valeurs d'indicateur possibles à renvoyer pour une demande. Vous pouvez également configurer différents statuts (activé ou désactivé) pour les indicateurs à variantes multiples. Lorsque vous demandez un indicateur configuré avec des variantes, votre application fournit un contexte qui est AWS AppConfig évalué par rapport à un ensemble de règles définies par l'utilisateur. En fonction du contexte spécifié dans la demande et des règles définies pour la variante, AWS AppConfig renvoie différentes valeurs d'indicateur à l'application.
La capture d'écran suivante montre un exemple d'indicateur de fonctionnalité avec trois variantes définies par l'utilisateur et la variante par défaut.
![\[Exemple de capture d'écran d'un indicateur de fonctionnalité avec des variantes.\]](http://docs.aws.amazon.com/fr_fr/appconfig/latest/userguide/images/flag-variant-example.png)
**Topics**
+ [
# Comprendre les concepts d'indicateurs de fonctionnalités à variantes multiples et les cas d'utilisation courants
](appconfig-creating-multi-variant-feature-flags-concepts.md)
+ [
# Comprendre les règles relatives aux indicateurs de fonctionnalités à variantes multiples
](appconfig-creating-multi-variant-feature-flags-rules.md)
+ [
# Création d'un indicateur de fonctionnalité à variantes multiples
](appconfig-creating-multi-variant-feature-flags-procedures.md)
# Comprendre les concepts d'indicateurs de fonctionnalités à variantes multiples et les cas d'utilisation courants
Pour vous aider à mieux comprendre les variantes d'indicateurs de fonctionnalités, cette section explique les concepts des variantes d'indicateur et les cas d'utilisation courants.
**Concepts**
+ **Indicateur de fonctionnalité** : type de AWS AppConfig configuration utilisé pour contrôler le comportement d'une fonctionnalité dans une application. Un indicateur possède un statut (activé ou désactivé) et un ensemble facultatif d'attributs contenant des valeurs de chaîne, numériques, booléennes ou matricielles arbitraires.
+ **Variante d'indicateur d'entité** : combinaison spécifique de valeurs d'état et d'attribut appartenant à un indicateur d'entité. Un indicateur de fonctionnalité peut avoir plusieurs variantes.
+ **Règle de variante** : expression définie par l'utilisateur utilisée pour sélectionner une variante d'indicateur de fonctionnalité. Chaque variante possède sa propre règle qui AWS AppConfig évalue si elle doit être renvoyée ou non.
+ **Variante par défaut** : variante spéciale renvoyée lorsqu'aucune autre variante n'est sélectionnée. Tous les indicateurs de fonctionnalités à variantes multiples ont une variante par défaut.
Notez que la variante par défaut doit être la dernière de votre commande de variantes et qu'aucune règle ne peut lui être associée. S'il n'est pas défini en dernier, AWS AppConfig renvoie un `BadRequestException` lorsque vous essayez de créer l'indicateur multivariant.
+ **Contexte** : clés et valeurs définies par l'utilisateur transmises au AWS AppConfig moment de la récupération de la configuration. Les valeurs de contexte sont utilisées lors de l'évaluation des règles pour sélectionner la variante d'indicateur de fonctionnalité à renvoyer.
**Note**
AWS AppConfig l'agent évalue les règles de variante et détermine quelle règle s'applique à la demande en fonction du contexte fourni. Pour plus d'informations sur la récupération d'indicateurs de fonctionnalités à plusieurs variantes, consultez. [Récupération des indicateurs de fonctionnalités de base et multivariantes](appconfig-integration-retrieving-feature-flags.md)
**Cas d'utilisation courants**
Cette section décrit deux cas d'utilisation courants pour les variantes d'indicateurs de fonctionnalité.
*Segmentation des utilisateurs*
La segmentation des utilisateurs est le processus qui consiste à diviser les utilisateurs en fonction de certains attributs. Par exemple, vous pouvez utiliser des variantes de drapeau pour présenter une fonctionnalité à certains utilisateurs, mais pas à d'autres en fonction de leur nom d'utilisateur, de leur situation géographique, de leur type d'appareil ou de leur fréquence d'achat.
À l'aide de l'exemple de la fréquence des achats, supposons que votre application de commerce propose une fonctionnalité visant à fidéliser les clients. Vous pouvez utiliser des variantes de drapeau pour configurer différents types d'incitations à afficher à un utilisateur en fonction de la date de son dernier achat. Un nouvel utilisateur peut bénéficier d'une petite réduction pour l'encourager à devenir client, tandis qu'un client régulier peut bénéficier d'une réduction plus importante s'il achète quelque chose d'une nouvelle catégorie.
*Répartition du trafic*
Le fractionnement du trafic consiste à sélectionner une variante d'indicateur aléatoire mais cohérente en fonction d'une valeur de contexte que vous définissez. Par exemple, vous souhaiterez peut-être réaliser un test dans le cadre duquel un petit pourcentage de vos utilisateurs (identifiés par leur nom d'utilisateur) voit une variante particulière. Vous pouvez également exécuter un déploiement progressif des fonctionnalités dans le cadre duquel une fonctionnalité est d'abord exposée à 5 % de vos utilisateurs, puis à 15 %, puis à 40 %, puis à 100 %, tout en maintenant une expérience utilisateur cohérente tout au long du déploiement.
À l'aide de l'exemple d'expérimentation, vous pouvez utiliser des variantes de drapeau pour tester un nouveau style de bouton pour l'action principale sur la page d'accueil de votre application afin de déterminer s'il génère plus de clics. Pour votre expérience, vous pouvez créer une variante de drapeau avec une règle de répartition du trafic qui sélectionne 5 % des utilisateurs pour voir le nouveau style, tandis que la variante par défaut indique les utilisateurs qui devraient continuer à voir le style existant. Si l'expérience est réussie, vous pouvez augmenter la valeur en pourcentage ou même faire de cette variante la variante par défaut.
# Comprendre les règles relatives aux indicateurs de fonctionnalités à variantes multiples
Lorsque vous créez une variante d'indicateur de fonctionnalité, vous spécifiez une règle pour celle-ci. Les règles sont des expressions qui prennent des valeurs de contexte en entrée et produisent un résultat booléen en sortie. Par exemple, vous pouvez définir une règle pour sélectionner une variante d'indicateur pour les utilisateurs bêta, identifiés par leur identifiant de compte, afin de tester une actualisation de l'interface utilisateur. Pour ce scénario, vous devez effectuer les opérations suivantes :
1. Créez un nouveau profil de configuration d'indicateur de fonctionnalité appelé *UI Refresh*.
1. Créez un nouvel indicateur de fonctionnalité appelé *ui\$1refresh*.
1. Modifiez l'indicateur de fonctionnalité après l'avoir créé pour ajouter des variantes.
1. Créez et activez une nouvelle variante appelée *BetaUsers*.
1. Définissez une règle *BetaUsers*qui sélectionne la variante si l'identifiant du compte indiqué dans le contexte de la demande figure dans une liste de comptes IDs approuvés pour accéder à la nouvelle expérience bêta.
1. Vérifiez que le statut de la variante par défaut est défini sur **Désactivé**.
**Note**
Les variantes sont évaluées sous forme de liste ordonnée en fonction de l'ordre dans lequel elles sont définies dans la console. La variante en haut de la liste est évaluée en premier. Si aucune règle ne correspond au contexte fourni, AWS AppConfig renvoie la variante par défaut.
Lors du AWS AppConfig traitement de la demande d'indicateur de fonctionnalité, il compare le contexte fourni, qui inclut d'abord l'AccountID (pour cet exemple), à BetaUsers la variante. Si le contexte correspond à la règle de BetaUsers, AWS AppConfig renvoie les données de configuration pour l'expérience bêta. Si le contexte n'inclut pas d'identifiant de compte ou si l'identifiant de compte se termine par une valeur autre que 123, AWS AppConfig renvoie les données de configuration pour la règle par défaut, ce qui signifie que l'utilisateur visualise l'expérience actuelle en production.
**Note**
Pour plus d'informations sur la récupération d'indicateurs de fonctionnalités à variantes multiples, consultez. [Récupération des indicateurs de fonctionnalités de base et multivariantes](appconfig-integration-retrieving-feature-flags.md)
# Définition de règles pour les indicateurs de fonctionnalités à variantes multiples
Une règle de variante est une expression composée d'un ou de plusieurs opérandes et d'un opérateur. Un opérande est une valeur spécifique utilisée lors de l'évaluation d'une règle. Les valeurs des opérandes peuvent être statiques, telles qu'un nombre littéral ou une chaîne, ou variables, telles que la valeur trouvée dans un contexte ou le résultat d'une autre expression. Un opérateur, tel que « supérieur à », est un test ou une action appliqué à ses opérandes qui produit une valeur. Une expression de règle variante doit produire un « vrai » ou un « faux » pour être valide.
**Opérandes**
****
| Type | Description | Exemple |
| --- | --- | --- |
| String | Séquence de caractères UTF-8, entre guillemets. | "apple", "Ḽơᶉëᶆ ȋṕšᶙṁ"
|
| Entier | Une valeur entière de 64 bits. | -7, 42
|
| Float | Une valeur à virgule flottante IEEE-754 64 bits. | 3.14, 1.234e-5
|
| Horodatage | Un moment précis tel que décrit dans la [note du W3C sur les formats de date et d'heure](https://www.w3.org/TR/NOTE-datetime). | 2012-03-04T05:06:07-08:00, 2024-01
|
| Booléen | Une valeur vraie ou fausse. | true, false
|
| Valeur contextuelle | Une valeur paramétrée sous la forme de \$1 *key* qui est extraite du contexte lors de l'évaluation des règles. | $country, $userId
|
**Opérateurs de comparaison**
****
| Opérateur | Description | Exemple |
| --- | --- | --- |
| eq | Détermine si une valeur de contexte est égale à une valeur donnée. | (eq $state "Virginia")
|
| gt | Détermine si une valeur de contexte est supérieure à une valeur donnée. | (gt $age 65)
|
| gte | Détermine si une valeur de contexte est supérieure ou égale à une valeur donnée. | (gte $age 65)
|
| lt | Détermine si une valeur de contexte est inférieure à une valeur donnée. | (lt $age 65)
|
| lte | Détermine si une valeur de contexte est inférieure ou égale à une valeur donnée. | (lte $age 65)
|
**Opérateurs logiques**
****
| Opérateur | Description | Exemple |
| --- | --- | --- |
| and | Détermine si les deux opérandes sont vrais. | (and
(eq $state "Virginia")
(gt $age 65)
)
|
| or | Détermine si au moins un des opérandes est vrai. | (or
(eq $state "Virginia")
(gt $age 65)
)
|
| not | Inverse la valeur d'une expression. | (not (eq $state "Virginia"))
|
**Opérateurs personnalisés**
****
| Opérateur | Description | Exemple |
| --- | --- | --- |
| commence\$1par | Détermine si une valeur de contexte commence par un préfixe donné. | (begins_with $state "A")
|
| se termine\$1par | Détermine si une valeur de contexte se termine par un préfixe donné. | (ends_with $email "amazon.com")
|
| contient | Détermine si une valeur de contexte contient une sous-chaîne donnée. | (contains $promoCode "WIN")
|
| in | Détermine si une valeur de contexte est contenue dans une liste de constantes. | (in $userId ["123", "456"])
|
| allumettes | Détermine si une valeur de contexte correspond à un modèle d'expression régulière donné. | (matches in::$greeting pattern::"h.*y")
|
| exists | Détermine si une valeur a été fournie pour une clé de contexte. | (exists key::"country")
|
| split | Est évalué à `true` pour un pourcentage donné du trafic sur la base d'un hachage cohérent des valeurs contextuelles fournies. Pour une explication détaillée de son `split` fonctionnement, reportez-vous à la section suivante de cette rubrique,[Comprendre l'opérateur de division](appconfig-creating-multi-variant-feature-flags-rules.md#appconfig-creating-multi-variant-feature-flags-rules-operators-split). Notez qu'il `seed` s'agit d'une propriété facultative. Si vous ne le spécifiez pas`seed`, le hachage est cohérent *localement*, ce qui signifie que le trafic sera réparti de manière cohérente pour cet indicateur, mais les autres indicateurs recevant la même valeur de contexte peuvent répartir le trafic différemment. Si elle `seed` est fournie, chaque valeur unique est garantie pour répartir le trafic de manière cohérente entre les indicateurs de fonctionnalités, les profils de configuration et Comptes AWS. | (split pct::10 by::$userId seed::"abc")
|
## Comprendre l'opérateur de division
La section suivante décrit le comportement de l'`split`opérateur lorsqu'il est utilisé dans différents scénarios. Pour rappel, est `split` évalué à `true` pour un pourcentage donné du trafic sur la base d'un hachage cohérent de la valeur de contexte fournie. Pour mieux comprendre cela, considérez le scénario de référence suivant qui utilise le fractionnement avec deux variantes :
```
A: (split by::$uniqueId pct::20)
C:
```
Comme prévu, la fourniture d'un ensemble aléatoire de `uniqueId` valeurs produit une distribution approximativement égale à :
```
A: 20%
C: 80%
```
Si vous ajoutez une troisième variante, mais que vous utilisez le même pourcentage de partage, comme suit :
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::20)
C:
```
Vous vous retrouvez avec la distribution suivante :
```
A: 20%
B: 0%
C: 80%
```
Cette distribution potentiellement inattendue se produit parce que chaque règle de variante est évaluée dans l'ordre et que la première correspondance détermine la variante renvoyée. Lorsque la règle A est évaluée, 20 % des `uniqueId` valeurs y correspondent, de sorte que la première variante est renvoyée. Ensuite, la règle B est évaluée. Cependant, toutes les `uniqueId` valeurs qui auraient correspondu à la deuxième instruction fractionnée correspondaient déjà à la règle de variante A, donc aucune valeur ne correspond à B. La variante par défaut est renvoyée à la place.
Prenons maintenant un troisième exemple.
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::25)
C:
```
Comme dans l'exemple précédent, les 20 % premiers des `uniqueId` valeurs correspondent à la règle A. Pour la variante de la règle B, 25 % de toutes les `uniqueId` valeurs correspondraient, mais la plupart des valeurs précédemment correspondantes correspondent à la règle A. Cela laisse 5 % du total pour la variante B, le reste recevant la variante C. La distribution serait la suivante :
```
A: 20%
B: 5%
C: 75%
```
**Utilisation de la `seed` propriété**
Vous pouvez utiliser cette `seed` propriété pour vous assurer que le trafic est réparti de manière cohérente pour une valeur de contexte donnée, quel que soit l'endroit où l'opérateur de division est utilisé. Si vous ne le spécifiez pas`seed`, le hachage est cohérent *localement*, ce qui signifie que le trafic sera réparti de manière cohérente pour cet indicateur, mais les autres indicateurs recevant la même valeur de contexte peuvent répartir le trafic différemment. Si elle `seed` est fournie, chaque valeur unique est garantie pour répartir le trafic de manière cohérente entre les indicateurs de fonctionnalités, les profils de configuration et Comptes AWS.
Généralement, les clients utilisent la même `seed` valeur pour toutes les variantes d'un drapeau lorsqu'ils répartissent le trafic sur la même propriété de contexte. Cependant, il peut parfois être judicieux d'utiliser une valeur de départ différente. Voici un exemple qui utilise des valeurs de départ différentes pour les règles A et B :
```
A: (split by::$uniqueId pct::20 seed::"seed_one")
B: (split by::$uniqueId pct::25 seed::"seed_two")
C:
```
Comme auparavant, 20 % des `uniqueId` valeurs correspondantes correspondent à la règle A. Cela signifie que 80 % des valeurs sont rejetées et testées par rapport à la règle de variante B. Comme le point de départ est différent, il n'y a aucune corrélation entre les valeurs correspondant à A et les valeurs correspondantes B. Il n'y a cependant que 80 % de `uniqueId` valeurs en moins à diviser, 25 % de ce nombre correspondant à la règle B et 75 % non. Cela correspond à la distribution suivante :
```
A: 20%
B: 20% (25% of what falls through from A, or 25% of 80%)
C: 60%
```
# Création d'un indicateur de fonctionnalité à variantes multiples
Utilisez les procédures décrites dans cette section pour créer des variantes d'un indicateur de fonctionnalité.
**Avant de commencer**
Notez les informations importantes suivantes.
+ Vous pouvez créer des variantes d'indicateurs de fonctionnalités existants en les modifiant. Vous ne pouvez pas créer de variantes d'un nouvel indicateur de fonctionnalité *lorsque vous créez un nouveau profil de configuration*. Vous devez d'abord terminer le processus de création du nouveau profil de configuration. Après avoir créé le profil de configuration, vous pouvez ajouter des variantes à n'importe quel indicateur du profil de configuration. Pour plus d'informations sur la création d'un nouveau profil de configuration, consultez[Création d'un profil de configuration d'indicateur de fonctionnalité dans AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Pour récupérer les données des variantes des indicateurs de fonctionnalité pour les plateformes de calcul Amazon EC2, Amazon ECS et Amazon EKS, vous devez utiliser la version 2.0.4416 ou ultérieure de AWS AppConfig l'agent.
+ Pour des raisons de performances, AWS CLI et pour des raisons de performance, le SDK appelle à AWS AppConfig ne pas récupérer les données des variantes. Pour plus d'informations sur AWS AppConfig l'agent, consultez[Comment utiliser l' AWS AppConfig agent pour récupérer les données de configuration](appconfig-agent-how-to-use.md).
+ Lorsque vous créez une variante d'indicateur de fonctionnalité, vous spécifiez une règle pour celle-ci. Les règles sont des expressions qui prennent le contexte de la demande en entrée et produisent un résultat booléen en sortie. Avant de créer des variantes, vérifiez les opérandes et les opérateurs pris en charge pour connaître les règles relatives aux variantes de marquage. Vous pouvez créer des règles avant de créer des variantes. Pour de plus amples informations, veuillez consulter [Comprendre les règles relatives aux indicateurs de fonctionnalités à variantes multiples](appconfig-creating-multi-variant-feature-flags-rules.md).
**Topics**
+ [
## Création d'un indicateur de fonctionnalité à plusieurs variantes (console)
](#appconfig-creating-multi-variant-feature-flags-procedures-console)
+ [
## Création d'un indicateur de fonctionnalité multivariant (ligne de commande)
](#appconfig-creating-multi-variant-feature-flags-procedures-commandline)
## Création d'un indicateur de fonctionnalité à plusieurs variantes (console)
La procédure suivante explique comment créer un indicateur de fonctionnalité multivariant pour un profil de configuration existant à l'aide de la AWS AppConfig console. Vous pouvez également modifier les indicateurs de fonction existants pour créer des variantes.
**Pour créer un indicateur de fonctionnalité à plusieurs variantes**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Dans le volet de navigation, choisissez **Applications**, puis choisissez une application.
1. Dans l'onglet **Profils de configuration et indicateurs de fonctionnalités**, choisissez un profil de configuration d'indicateur de fonctionnalité existant.
1. Dans la section **Drapeaux**, choisissez **Ajouter un nouveau drapeau**.
1. Dans la section **Définition du drapeau de fonctionnalité**, pour **Nom du drapeau**, entrez un nom.
1. Pour la **touche Drapeau**, entrez un identifiant de drapeau pour distinguer les indicateurs au sein d'un même profil de configuration. Les drapeaux d'un même profil de configuration ne peuvent pas avoir la même clé. Une fois le drapeau créé, vous pouvez modifier le nom du drapeau, mais pas la clé du drapeau.
1. (Facultatif) Dans le champ **Description**, entrez les informations relatives à cet indicateur.
1. Dans la section **Variantes**, choisissez **Drapeau à variantes multiples**.
1. (Facultatif) Dans la section **Attributs du drapeau de fonction**, sélectionnez **Définir l'attribut**. Les attributs vous permettent de fournir des valeurs supplémentaires dans votre drapeau. Pour plus d'informations sur les attributs et les contraintes, consultez[Comprendre les attributs des indicateurs de fonctionnalité](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Pour **Clé**, spécifiez une touche indicateur et choisissez son type dans la liste **Type**. Pour plus d'informations sur les options prises en charge pour les champs **Valeur** et **Contraintes**, consultez la section précédemment référencée sur les attributs.
1. Sélectionnez **Valeur requise** pour indiquer si une valeur d'attribut est requise.
1. Choisissez **Définir un attribut** pour ajouter des attributs supplémentaires.
1. Choisissez **Appliquer** pour enregistrer les modifications d'attributs.
1. Dans la section **Variantes du drapeau de fonctionnalité**, choisissez **Créer une variante**.
1. **Dans Nom de la variante**, entrez un nom.
1. Utilisez le bouton **Valeur activée** pour activer la variante.
1. Dans la zone de texte **Règle**, entrez une règle.
1. Utilisez les options **Créer une variante** > **Créer une variante ci-dessus** ou **Créer une variante ci-dessous** pour créer des variantes supplémentaires pour cet indicateur.
1. Dans la section **Variante par défaut**, utilisez le bouton **Valeur activée** pour activer la variante par défaut. Vous pouvez éventuellement fournir des valeurs pour les attributs définis à l'étape 10.
1. Cliquez sur **Appliquer**.
1. Vérifiez les détails du drapeau et de ses variantes, puis choisissez **Créer un drapeau**.
Pour plus d'informations sur le déploiement de votre nouvel indicateur de fonctionnalité avec des variantes, consultez[Déploiement d'indicateurs de fonctionnalités et de données de configuration dans AWS AppConfig](deploying-feature-flags.md).
## Création d'un indicateur de fonctionnalité multivariant (ligne de commande)
La procédure suivante décrit comment utiliser le AWS Command Line Interface (sous Linux ou Windows) ou les Outils pour Windows PowerShell afin de créer un indicateur de fonctionnalité à plusieurs variantes pour un profil de configuration existant. Vous pouvez également modifier les indicateurs de fonction existants pour créer des variantes.
**Avant de commencer**
Effectuez les tâches suivantes avant de créer un indicateur de fonctionnalité à variantes multiples à l'aide du AWS CLI.
+ Créez un profil de configuration d'indicateur de fonctionnalité. Pour de plus amples informations, veuillez consulter [Création d'un profil de configuration d'indicateur de fonctionnalité dans AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Effectuez une mise à jour vers la dernière version du AWS CLI. Pour plus d’informations, consultez [Installation ou mise à jour de la dernière version de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dans le *Guide de l’utilisateur de l’AWS Command Line Interface *.
**Pour créer un indicateur de fonctionnalité à plusieurs variantes**
1. Créez un fichier de configuration sur votre machine locale qui spécifie les détails de l'indicateur multivariant que vous souhaitez créer. Enregistrez le fichier avec une extension de `.json` fichier. Le fichier doit respecter le schéma [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. Le contenu du schéma de votre fichier de configuration sera similaire à ce qui suit.
```
{
"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"
}
```
Voici un exemple avec trois variantes et la variante par défaut.
```
{
"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. Utilisez l'`CreateHostedConfigurationVersion`API pour enregistrer les données de configuration de votre indicateur de fonctionnalité dans 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
```
------
Le `service_returned_content_file` contient vos données de configuration, y compris certaines métadonnées AWS AppConfig générées.
**Note**
Lorsque vous créez la version de configuration hébergée AWS AppConfig , vérifiez que vos données sont conformes au schéma [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. AWS AppConfig confirme également que chaque attribut d'indicateur d'entité de vos données répond aux contraintes que vous avez définies pour ces attributs.
# Comprendre la référence de type pour AWS.AppConfig.FeatureFlags
Utilisez le schéma `AWS.AppConfig.FeatureFlags` JSON comme référence pour créer les données de configuration de vos indicateurs de fonctionnalité.
```
{
"$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
}
```
**Important**
Pour récupérer les données de configuration des indicateurs de fonctionnalité, votre application doit appeler l'`GetLatestConfiguration`API. Vous ne pouvez pas récupérer les données de configuration des indicateurs de fonctionnalité en appelant`GetConfiguration`, ce qui est obsolète. Pour plus d’informations, consultez [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html) dans la *Référence d’API AWS AppConfig *.
Lorsque votre application appelle [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html)et reçoit une configuration nouvellement déployée, les informations qui définissent vos indicateurs et attributs de fonctionnalités sont supprimées. Le JSON simplifié contient une carte de clés correspondant à chacune des clés d'indicateur que vous avez spécifiées. Le JSON simplifié contient également des valeurs mappées de `true` ou `false` pour l'`enabled`attribut. Si un drapeau est `enabled` défini sur`true`, tous les attributs du drapeau seront également présents. Le schéma JSON suivant décrit le format de la sortie JSON.
```
{
"$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
}
}
}
```
# Enregistrer une version précédente d'un indicateur de fonctionnalité dans une nouvelle version
Lorsque vous mettez à jour un indicateur de fonctionnalité, vos modifications AWS AppConfig sont automatiquement enregistrées dans une nouvelle version. Si vous souhaitez utiliser une version précédente de l'indicateur de fonctionnalité, vous devez la copier dans une version préliminaire, puis l'enregistrer. Vous ne pouvez pas modifier et enregistrer les modifications apportées à une version précédente d'un drapeau sans l'enregistrer dans une nouvelle version.
**Pour modifier une version précédente d'un indicateur de fonctionnalité et l'enregistrer dans une nouvelle version**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Dans le volet de navigation, choisissez **Applications**, puis choisissez l'application avec l'indicateur de fonctionnalité que vous souhaitez modifier et enregistrer dans une nouvelle version.
1. Dans l'onglet **Profils de configuration et indicateurs de fonctionnalité**, choisissez le profil de configuration avec l'indicateur de fonctionnalité que vous souhaitez modifier et enregistrer dans une nouvelle version.
1. Dans l'onglet **Feature flags**, utilisez la liste des **versions** pour choisir la version que vous souhaitez modifier et enregistrer dans une nouvelle version.
1. Choisissez **Copier vers une version brouillon**.
1. Dans le champ **Libellé de version**, entrez un nouveau libellé (facultatif, mais recommandé).
1. Dans le champ **Description de la version**, entrez une nouvelle description (facultatif, mais recommandé).
1. Choisissez **Enregistrer la version**.
1. Choisissez **Démarrer le déploiement** pour déployer la nouvelle version.