Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Creazione di un profilo di configurazione del feature flag in AWS AppConfig
È possibile utilizzare i flag di funzionalità per abilitare o disabilitare funzionalità all'interno delle applicazioni o per configurare caratteristiche diverse delle funzionalità dell'applicazione utilizzando gli attributi dei flag. AWS AppConfig archivia le configurazioni dei flag di funzionalità nell'archivio di configurazione AWS AppConfig ospitato in un formato di feature flag che contiene dati e metadati sui flag e sugli attributi dei flag.
**Nota**
Quando create un profilo di configurazione dei feature flag, potete creare un feature flag di base come parte del flusso di lavoro del profilo di configurazione. AWS AppConfig supporta anche i flag di funzionalità multivarianti. *I flag di funzionalità multivarianti* consentono di definire una serie di possibili valori di flag da restituire per una richiesta. Quando si richiede un flag configurato con varianti, l'applicazione fornisce un contesto che AWS AppConfig valuta in base a una serie di regole definite dall'utente. A seconda del contesto specificato nella richiesta e delle regole definite per la variante, AWS AppConfig restituisce valori di flag diversi all'applicazione.
Per creare flag di funzionalità multivarianti, create prima un profilo di configurazione, quindi modificate tutti i flag all'interno del profilo di configurazione per aggiungere varianti. Per ulteriori informazioni, consulta [Creazione di flag di funzionalità multivarianti](appconfig-creating-multi-variant-feature-flags.md).
**Topics**
+ [
## Comprensione degli attributi dei feature flag
](#appconfig-creating-configuration-profile-feature-flag-attributes)
+ [
# Creazione di un profilo di configurazione del feature flag (console)
](appconfig-creating-feature-flag-configuration-create-console.md)
+ [
# Creazione di un profilo di configurazione del feature flag (riga di comando)
](appconfig-creating-feature-flag-configuration-commandline.md)
+ [
# Creazione di flag di funzionalità multivarianti
](appconfig-creating-multi-variant-feature-flags.md)
+ [
# Comprensione del tipo di riferimento per AWS.AppConfig.FeatureFlags
](appconfig-type-reference-feature-flags.md)
+ [
# Salvataggio di una versione precedente di Feature Flag in una nuova versione
](appconfig-creating-configuration-profile-feature-flags-editing-version.md)
## Comprensione degli attributi dei feature flag
Quando create un profilo di configurazione del feature flag o create un nuovo flag all'interno di un profilo di configurazione esistente, potete specificare gli attributi e i vincoli corrispondenti per il flag. Un attributo è un campo che si associa al feature flag per esprimere le proprietà relative al feature flag. Gli attributi vengono forniti all'applicazione con la chiave flag e il `disable` valore `enable` or del flag.
I vincoli assicurano che nell'applicazione non vengano distribuiti valori di attributo imprevisti. Un esempio è illustrato nell'immagine seguente.
![\[Esempio di attributi di bandiera per un flag di funzionalità AWS AppConfig\]](http://docs.aws.amazon.com/it_it/appconfig/latest/userguide/images/appconfig-flag-attributes.png)
**Nota**
Notate le seguenti informazioni sugli attributi dei flag.
Per i nomi degli attributi, la parola «abilitato» è riservata. Non è possibile creare un attributo di feature flag chiamato «enabled». Non ci sono altre parole riservate.
Gli attributi di un flag di funzionalità sono inclusi nella `GetLatestConfiguration` risposta solo se tale flag è abilitato.
Le chiavi degli attributi Flag per un determinato flag devono essere univoche.
AWS AppConfig supporta i seguenti tipi di attributi di bandiera e i vincoli corrispondenti.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/appconfig/latest/userguide/appconfig-creating-configuration-and-profile-feature-flags.html)
# Creazione di un profilo di configurazione del feature flag (console)
Utilizzate la seguente procedura per creare un profilo di configurazione dei AWS AppConfig feature flag utilizzando la AWS AppConfig console. Al momento della creazione del profilo di configurazione, è anche possibile creare un feature flag di base.
**Come creare un profilo di configurazione**
1. Apri la AWS Systems Manager console all'indirizzo [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Nel riquadro di navigazione, scegli **Applicazioni**, quindi scegli un'applicazione in cui hai creato. [Creazione di uno spazio dei nomi per l'applicazione in AWS AppConfig](appconfig-creating-namespace.md)
1. Nella scheda **Profili di configurazione e bandiere di funzionalità**, scegli **Crea configurazione**.
1. Nella sezione **Opzioni di configurazione**, scegliete **Feature flag**.
1. Nella sezione **Profilo di configurazione**, per **Nome del profilo di configurazione**, inserisci un nome.
1. (Facoltativo) Espandi **Descrizione** e inserisci una descrizione.
1. (Facoltativo) **Espandi Opzioni aggiuntive** e completa quanto segue, se necessario.
1. Nell'elenco **Crittografia**, scegliete una chiave AWS Key Management Service (AWS KMS) dall'elenco. Questa chiave gestita dal cliente consente di crittografare le nuove versioni dei dati di configurazione nell'archivio di configurazione AWS AppConfig ospitato. Per ulteriori informazioni su questa chiave, consulta **AWS AppConfig Supporta le chiavi di Customer Manager** in[Sicurezza in AWS AppConfig](appconfig-security.md).
1. Nella sezione **Tag**, scegli **Aggiungi nuovo tag**, quindi specifica una chiave e un valore opzionale.
1. Scegli **Next (Successivo)**.
1. Nella sezione **Definizione del flag di funzionalità**, per **Nome bandiera**, inserisci un nome.
1. Per la **chiave Flag**, inserite un identificatore di bandiera per distinguere i flag all'interno dello stesso profilo di configurazione. I flag all'interno dello stesso profilo di configurazione non possono avere la stessa chiave. Dopo aver creato il flag, è possibile modificare il nome del flag, ma non la chiave del flag.
1. (Facoltativo) Espandi la **descrizione** e inserisci le informazioni su questo contrassegno.
1. Seleziona **Questo è un contrassegno a breve termine** e, facoltativamente, scegli una data in cui disattivare o eliminare il contrassegno. AWS AppConfig *non* disabilita il flag alla data di obsolescenza.
1. **(Facoltativo) Nella sezione **Attributi del flag Feature, scegliete Definisci attributo**.** Gli attributi consentono di fornire valori aggiuntivi all'interno della bandiera. Per ulteriori informazioni su attributi e vincoli, vedere. [Comprensione degli attributi dei feature flag](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes)
1. Per **Key**, specificate una chiave di bandiera e sceglietene il tipo dall'elenco **Tipo**. Per informazioni sulle opzioni supportate per i campi **Valore** e **Vincoli**, consultate la sezione precedentemente citata sugli attributi.
1. Seleziona **Valore richiesto per specificare se il valore** di un attributo è obbligatorio.
1. Scegliete **Definisci attributo** per aggiungere altri attributi.
1. Nella sezione **Feature flag value**, scegliete **Enabled** per abilitare il flag. Usa lo stesso interruttore per disabilitare un flag quando raggiunge una data di deprecazione specificata, se applicabile.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e salva**, verifica i dettagli del flag, quindi **Salva** e continua la distribuzione.
Passa a [Distribuzione di flag di funzionalità e dati di configurazione in AWS AppConfig](deploying-feature-flags.md).
# Creazione di un profilo di configurazione del feature flag (riga di comando)
La procedura seguente descrive come utilizzare AWS Command Line Interface (su Linux o Windows) o Tools for Windows per PowerShell creare un profilo di configurazione dei AWS AppConfig feature flag. Al momento della creazione del profilo di configurazione, è anche possibile creare un flag di funzionalità di base.
**Per creare una configurazione di feature flag**
1. Aprire il AWS CLI.
1. Crea un profilo di configurazione del feature flag specificandone il **tipo** come`AWS.AppConfig.FeatureFlags`. Il profilo di configurazione deve utilizzare `hosted` l'URI della posizione.
------
#### [ 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. Crea i dati di configurazione del tuo feature flag. I tuoi dati devono essere in formato JSON e conformi allo schema `AWS.AppConfig.FeatureFlags` JSON. Per ulteriori informazioni sullo schema, vedere. [Comprensione del tipo di riferimento per AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md)
1. Utilizza l'`CreateHostedConfigurationVersion`API per salvare i dati di configurazione del feature flag in 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
```
------
Il comando carica il contenuto specificato per il `Content` parametro dal disco. Il contenuto deve essere simile all'esempio seguente.
```
{
"flags": {
"ui_refresh": {
"name": "UI Refresh"
}
},
"values": {
"ui_refresh": {
"enabled": false,
"attributeValues": {
"dark_mode_support": true
}
}
},
"version": "1"
}
```
Il sistema restituisce informazioni simili alle seguenti.
------
#### [ 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
```
------
`service_returned_content_file`Contiene i dati di configurazione che includono alcuni metadati AWS AppConfig generati.
**Nota**
Quando crei la versione di configurazione ospitata, AWS AppConfig verifica che i dati siano conformi allo `AWS.AppConfig.FeatureFlags` schema JSON. AWS AppConfig verifica inoltre che ogni attributo feature flag presente nei dati soddisfi i vincoli definiti per tali attributi.
# Creazione di flag di funzionalità multivarianti
Le varianti dei flag di funzionalità consentono di definire una serie di possibili valori di flag da restituire per una richiesta. È inoltre possibile configurare diversi stati (abilitati o disabilitati) per i flag multivarianti. Quando si richiede un flag configurato con varianti, l'applicazione fornisce un contesto che AWS AppConfig valuta in base a una serie di regole definite dall'utente. A seconda del contesto specificato nella richiesta e delle regole definite per la variante, AWS AppConfig restituisce valori di flag diversi all'applicazione.
La schermata seguente mostra un esempio di feature flag con tre varianti definite dall'utente e la variante predefinita.
![\[Uno screenshot di esempio di un flag di funzionalità con varianti.\]](http://docs.aws.amazon.com/it_it/appconfig/latest/userguide/images/flag-variant-example.png)
**Topics**
+ [
# Comprensione dei concetti dei feature flag multivarianti e dei casi d'uso comuni
](appconfig-creating-multi-variant-feature-flags-concepts.md)
+ [
# Comprensione delle regole del feature flag multivariante
](appconfig-creating-multi-variant-feature-flags-rules.md)
+ [
# Creazione di un flag di funzionalità multivariante
](appconfig-creating-multi-variant-feature-flags-procedures.md)
# Comprensione dei concetti dei feature flag multivarianti e dei casi d'uso comuni
Per aiutarti a comprendere meglio le varianti dei flag di funzionalità, questa sezione spiega i concetti relativi alle varianti dei flag e i casi d'uso più comuni.
**Concetti**
+ **Feature flag**: un tipo di AWS AppConfig configurazione utilizzato per controllare il comportamento di una funzionalità in un'applicazione. Un flag ha uno stato (abilitato o disabilitato) e un set opzionale di attributi contenenti valori arbitrari di stringa, numerici, booleani o matrici.
+ **Variante del flag di funzionalità**: una combinazione specifica di valori di status e di attributo appartenenti a un flag di funzionalità. Un feature flag può avere più varianti.
+ **Regola di variante**: espressione definita dall'utente utilizzata per selezionare una variante del feature flag. Ogni variante ha una propria regola che AWS AppConfig valuta se restituirla o meno.
+ **Variante predefinita**: una variante speciale che viene restituita quando non viene selezionata nessun'altra variante. Tutti i flag di funzionalità multivarianti hanno una variante predefinita.
Nota, la variante predefinita deve essere l'ultima nell'ordine delle varianti e non può avere regole associate. Se non è definita per ultima, AWS AppConfig restituisce a `BadRequestException` quando si tenta di creare il flag multivariante.
+ **Contesto**: chiavi e valori definiti dall'utente passati al AWS AppConfig momento del recupero della configurazione. I valori di contesto vengono utilizzati durante la valutazione delle regole per selezionare la variante del feature flag da restituire.
**Nota**
AWS AppConfig l'agente valuta le regole delle varianti e determina quale regola si applica alla richiesta in base al contesto fornito. Per ulteriori informazioni sul recupero dei flag di funzionalità multivarianti, vedere. [Recupero dei flag delle funzionalità di base e multivarianti](appconfig-integration-retrieving-feature-flags.md)
**Casi d'uso comuni**
Questa sezione descrive due casi d'uso comuni per le varianti dei feature flag.
*Segmentazione degli utenti*
La segmentazione degli utenti è il processo di divisione degli utenti in base a determinati attributi. Ad esempio, puoi utilizzare le varianti flag per esporre una funzionalità ad alcuni utenti ma non ad altri in base all'ID utente, alla posizione geografica, al tipo di dispositivo o alla frequenza di acquisto.
Utilizzando l'esempio della frequenza di acquisto, supponiamo che l'applicazione di commercio supporti una funzionalità per aumentare la fidelizzazione dei clienti. Puoi utilizzare le varianti di bandiera per configurare diversi tipi di incentivi da mostrare a un utente in base all'ultima volta che ha acquistato qualcosa. A un nuovo utente potrebbe essere offerto un piccolo sconto per incoraggiarlo a diventare cliente, mentre a un cliente abituale potrebbe essere concesso uno sconto maggiore se acquista qualcosa da una nuova categoria.
*Suddivisione del traffico*
La suddivisione del traffico è il processo di selezione di una variante di bandiera casuale ma coerente in base a un valore di contesto definito dall'utente. Ad esempio, potresti voler eseguire un esperimento in cui una piccola percentuale dei tuoi utenti (identificati dal loro ID utente) vede una particolare variante. In alternativa, potresti voler eseguire un'implementazione graduale delle funzionalità in cui una funzionalità venga esposta prima al 5% degli utenti, poi al 15%, quindi al 40%, quindi al 100%, mantenendo un'esperienza utente coerente durante l'implementazione.
Utilizzando l'esempio di sperimentazione, potreste utilizzare le varianti dei flag per testare un nuovo stile di pulsante per l'azione principale sulla home page dell'applicazione e vedere se genera più clic. Per il vostro esperimento, potreste creare una variante di bandiera con una regola di suddivisione del traffico che indichi il 5% degli utenti a visualizzare il nuovo stile, mentre la variante predefinita indica gli utenti che dovrebbero continuare a vedere lo stile esistente. Se l'esperimento ha esito positivo, puoi aumentare il valore percentuale o persino impostare la variante come predefinita.
# Comprensione delle regole del feature flag multivariante
Quando crei una variante del feature flag, specifichi una regola per essa. Le regole sono espressioni che accettano valori di contesto come input e producono un risultato booleano come output. Ad esempio, è possibile definire una regola per selezionare una variante di bandiera per gli utenti beta, identificata dall'ID dell'account, testando un aggiornamento dell'interfaccia utente. In questo scenario, procedi come segue:
1. Create un nuovo profilo di configurazione del feature flag chiamato *UI Refresh*.
1. Crea un nuovo flag di funzionalità chiamato *ui\$1refresh*.
1. Modifica il flag della funzionalità dopo averlo creato per aggiungere varianti.
1. Crea e abilita una nuova variante chiamata *BetaUsers*.
1. Definisci una regola per selezionare *BetaUsers*la variante se l'ID dell'account dal contesto della richiesta si trova in un elenco di account IDs approvati per visualizzare la nuova esperienza beta.
1. Verifica che lo stato della variante predefinita sia impostato su **Disabilitato**.
**Nota**
Le varianti vengono valutate come un elenco ordinato in base all'ordine in cui sono definite nella console. La variante in cima all'elenco viene valutata per prima. Se nessuna regola corrisponde al contesto fornito, AWS AppConfig restituisce la variante predefinita.
Quando AWS AppConfig elabora la richiesta del feature flag, confronta prima il contesto fornito, che include l'AccountID (in questo esempio) con BetaUsers la variante. Se il contesto corrisponde alla regola per BetaUsers, AWS AppConfig restituisce i dati di configurazione per l'esperienza beta. Se il contesto non include un ID account o se l'ID dell'account termina con un valore diverso da 123, AWS AppConfig restituisce i dati di configurazione per la regola predefinita, il che significa che l'utente visualizza l'esperienza corrente in produzione.
**Nota**
Per informazioni sul recupero dei flag di funzionalità multivarianti, consulta. [Recupero dei flag delle funzionalità di base e multivarianti](appconfig-integration-retrieving-feature-flags.md)
# Definizione delle regole per i flag di funzionalità multivarianti
Una regola variante è un'espressione composta da uno o più operandi e un operatore. Un operando è un valore specifico utilizzato durante la valutazione di una regola. I valori degli operandi possono essere statici, ad esempio un numero letterale o una stringa, o variabili, ad esempio il valore trovato in un contesto o il risultato di un'altra espressione. Un operatore, ad esempio «maggiore di», è un test o un'azione applicata ai relativi operandi che produce un valore. Un'espressione di regola variante deve produrre un «vero» o un «falso» per essere valida.
**Operandi**
****
| Tipo | Description | Esempio |
| --- | --- | --- |
| Stringa | Una sequenza di caratteri UTF-8, racchiusa tra virgolette doppie. | "apple", "Ḽơᶉëᶆ ȋṕšᶙṁ"
|
| Numero intero | Un valore intero a 64 bit. | -7, 42
|
| Float | Un valore a virgola mobile IEEE-754 a 64 bit. | 3.14, 1.234e-5
|
| Time stamp | Un momento temporale specifico, come descritto dalla nota del [W3C](https://www.w3.org/TR/NOTE-datetime) sui formati di data e ora. | 2012-03-04T05:06:07-08:00, 2024-01
|
| Booleano | Un valore vero o falso. | true, false
|
| Valore di contesto | Un valore parametrizzato sotto forma di \$1 *key* che viene recuperato dal contesto durante la valutazione della regola. | $country, $userId
|
**Operatori di confronto**
****
| Operatore | Description | Esempio |
| --- | --- | --- |
| eq | Determina se un valore di contesto è uguale a un determinato valore. | (eq $state "Virginia")
|
| gt | Determina se un valore di contesto è maggiore di un determinato valore. | (gt $age 65)
|
| gte | Determina se un valore di contesto è maggiore o uguale a un determinato valore. | (gte $age 65)
|
| lt | Determina se un valore di contesto è inferiore a un determinato valore. | (lt $age 65)
|
| lte | Determina se un valore di contesto è minore o uguale a un determinato valore. | (lte $age 65)
|
**Operatori logici**
****
| Operatore | Description | Esempio |
| --- | --- | --- |
| and | Determina se entrambi gli operandi sono veri. | (and
(eq $state "Virginia")
(gt $age 65)
)
|
| or | Determina se almeno uno degli operandi è vero. | (or
(eq $state "Virginia")
(gt $age 65)
)
|
| not | Inverte il valore di un'espressione. | (not (eq $state "Virginia"))
|
**Operatori personalizzati**
****
| Operatore | Description | Esempio |
| --- | --- | --- |
| inizia\$1con | Determina se un valore di contesto inizia con un determinato prefisso. | (begins_with $state "A")
|
| termina\$1con | Determina se un valore di contesto termina con un determinato prefisso. | (ends_with $email "amazon.com")
|
| contiene | Determina se un valore di contesto contiene una determinata sottostringa. | (contains $promoCode "WIN")
|
| in | Determina se un valore di contesto è contenuto in un elenco di costanti. | (in $userId ["123", "456"])
|
| fiammiferi | Determina se un valore di contesto corrisponde a un determinato modello di espressione regolare. | (matches in::$greeting pattern::"h.*y")
|
| exists | Determina se è stato fornito un valore per una chiave di contesto. | (exists key::"country")
|
| dividi | Restituisce una determinata percentuale di traffico in base a un hash coerente dei valori di contesto forniti. `true` Per una spiegazione dettagliata di come `split` funziona, consultate la sezione successiva di questo argomento,. [Comprensione dell'operatore split](appconfig-creating-multi-variant-feature-flags-rules.md#appconfig-creating-multi-variant-feature-flags-rules-operators-split) Si noti che `seed` si tratta di una proprietà facoltativa. Se non lo specifichi`seed`, l'hash è coerente a *livello locale*, il che significa che il traffico verrà suddiviso in modo coerente per quel flag, ma altri flag che ricevono lo stesso valore di contesto potrebbero suddividere il traffico in modo diverso. Se fornito, `seed` è garantito che ogni valore univoco suddividerà il traffico in modo uniforme tra feature flag, profili di configurazione e. Account AWS | (split pct::10 by::$userId seed::"abc")
|
## Comprensione dell'operatore split
La sezione seguente descrive come si comporta l'`split`operatore quando viene utilizzato in diversi scenari. Come promemoria, `split` calcola una determinata percentuale di traffico sulla base di un hash coerente del valore di contesto fornito. `true` Per capirlo meglio, considera il seguente scenario di base che utilizza la divisione con due varianti:
```
A: (split by::$uniqueId pct::20)
C:
```
Come previsto, fornendo un insieme casuale di `uniqueId` valori si ottiene una distribuzione che è approssimativamente:
```
A: 20%
C: 80%
```
Se aggiungi una terza variante, ma usi la stessa percentuale di suddivisione in questo modo:
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::20)
C:
```
Si ottiene la seguente distribuzione:
```
A: 20%
B: 0%
C: 80%
```
Questa distribuzione potenzialmente inaspettata si verifica perché ogni regola di variante viene valutata in ordine e la prima corrispondenza determina la variante restituita. Quando viene valutata la regola A, il 20% dei `uniqueId` valori corrisponde, quindi viene restituita la prima variante. Successivamente, viene valutata la regola B. Tuttavia, tutti i `uniqueId` valori che avrebbero dovuto corrispondere alla seconda istruzione split corrispondevano già alla regola della variante A, quindi nessun valore corrisponde a B. Viene invece restituita la variante predefinita.
Consideriamo ora un terzo esempio.
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::25)
C:
```
Come nell'esempio precedente, il primo 20% dei `uniqueId` valori corrisponde alla regola A. Per la regola della variante B, il 25% di tutti i `uniqueId` valori corrisponderebbe, ma la maggior parte di quelli precedentemente corrispondenti alla regola A. Ciò lascia il 5% del totale per la variante B, mentre il resto riceve la variante C. La distribuzione sarebbe simile alla seguente:
```
A: 20%
B: 5%
C: 75%
```
**Utilizzo della proprietà `seed`**
È possibile utilizzare la `seed` proprietà per garantire che il traffico venga suddiviso in modo coerente per un determinato valore di contesto indipendentemente da dove viene utilizzato l'operatore di divisione. Se non lo specifichi`seed`, l'hash è coerente a *livello locale*, il che significa che il traffico verrà suddiviso in modo coerente per quel flag, ma altri flag che ricevono lo stesso valore di contesto potrebbero suddividere il traffico in modo diverso. Se fornito, `seed` è garantito che ogni valore univoco suddividerà il traffico in modo uniforme tra feature flag, profili di configurazione e. Account AWS
In genere, i clienti utilizzano lo stesso `seed` valore tra le varianti all'interno di un flag quando suddividono il traffico sulla stessa proprietà di contesto. Tuttavia, a volte può avere senso utilizzare un valore iniziale diverso. Ecco un esempio che utilizza semi diversi per le regole A e B:
```
A: (split by::$uniqueId pct::20 seed::"seed_one")
B: (split by::$uniqueId pct::25 seed::"seed_two")
C:
```
Come in precedenza, il 20% dei `uniqueId` valori corrispondenti corrisponde alla regola A. Ciò significa che l'80% dei valori soddisfa e viene testato in base alla regola variante B. Poiché il seme è diverso, non c'è correlazione tra i valori che corrispondono ad A e i valori che corrispondono alla regola B. Tuttavia, vi sono solo l'80% in più di `uniqueId` valori da dividere, il 25% di quel numero corrisponde alla regola B e il 75% no. Ciò si traduce nella seguente distribuzione:
```
A: 20%
B: 20% (25% of what falls through from A, or 25% of 80%)
C: 60%
```
# Creazione di un flag di funzionalità multivariante
Utilizzate le procedure in questa sezione per creare varianti di un feature flag.
**Prima di iniziare**
Prendi nota delle seguenti informazioni importanti.
+ È possibile creare varianti di feature flag esistenti modificandole. Non è possibile creare varianti di un nuovo feature flag *quando si crea un nuovo profilo di configurazione*. È necessario prima completare il flusso di lavoro di creazione del nuovo profilo di configurazione. Dopo aver creato il profilo di configurazione, è possibile aggiungere varianti a qualsiasi flag all'interno del profilo di configurazione. Per informazioni su come creare un nuovo profilo di configurazione, vedere[Creazione di un profilo di configurazione del feature flag in AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Per recuperare i dati delle varianti di feature flag per le piattaforme di calcolo Amazon EC2, Amazon ECS e Amazon EKS, è necessario AWS AppConfig utilizzare la versione dell'agente 2.0.4416 o successiva.
+ Per motivi di prestazioni e le chiamate SDK per non AWS CLI recuperare i dati delle varianti. AWS AppConfig Per ulteriori informazioni su AWS AppConfig Agent, consulta. [Come utilizzare AWS AppConfig Agent per recuperare i dati di configurazione](appconfig-agent-how-to-use.md)
+ Quando create una variante del feature flag, specificate una regola per essa. Le regole sono espressioni che prendono il contesto della richiesta come input e producono un risultato booleano come output. Prima di creare varianti, esamina gli operandi e gli operatori supportati per le regole delle varianti di bandiera. È possibile creare regole prima di creare varianti. Per ulteriori informazioni, consulta [Comprensione delle regole del feature flag multivariante](appconfig-creating-multi-variant-feature-flags-rules.md).
**Topics**
+ [
## Creazione di un flag di funzionalità multivariante (console)
](#appconfig-creating-multi-variant-feature-flags-procedures-console)
+ [
## Creazione di un flag di funzionalità multivariante (riga di comando)
](#appconfig-creating-multi-variant-feature-flags-procedures-commandline)
## Creazione di un flag di funzionalità multivariante (console)
La procedura seguente descrive come creare un flag di funzionalità multivariante per un profilo di configurazione esistente utilizzando la AWS AppConfig console. È inoltre possibile modificare i flag di funzionalità esistenti per creare varianti.
**Per creare un flag di funzionalità multivariante**
1. Apri la AWS Systems Manager console all'indirizzo [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Nel riquadro di navigazione, scegli **Applicazioni**, quindi scegli un'applicazione.
1. Nella scheda **Profili di configurazione e flag di funzionalità**, scegliete un profilo di configurazione dei feature flag esistente.
1. Nella sezione **Bandiere**, scegli **Aggiungi nuova** bandiera.
1. Nella sezione **Definizione della bandiera della caratteristica**, per **Nome bandiera**, inserisci un nome.
1. Per la **chiave Flag**, inserite un identificatore di bandiera per distinguere i flag all'interno dello stesso profilo di configurazione. I flag all'interno dello stesso profilo di configurazione non possono avere la stessa chiave. Dopo aver creato il flag, è possibile modificare il nome del flag, ma non la chiave del flag.
1. (Facoltativo) Nel campo **Descrizione**, inserisci le informazioni su questo contrassegno.
1. Nella sezione **Varianti**, scegli **Contrassegno multivariante**.
1. (Facoltativo) Nella sezione **Attributi del flag Feature**, scegliete **Definisci attributo**. Gli attributi consentono di fornire valori aggiuntivi all'interno della bandiera. Per ulteriori informazioni su attributi e vincoli, vedere. [Comprensione degli attributi dei feature flag](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes)
1. Per **Key**, specificate una chiave di bandiera e sceglietene il tipo dall'elenco **Tipo**. Per informazioni sulle opzioni supportate per i campi **Valore** e **Vincoli**, consultate la sezione precedentemente citata sugli attributi.
1. Seleziona **Valore richiesto per specificare se il valore** di un attributo è obbligatorio.
1. Scegliete **Definisci attributo** per aggiungere altri attributi.
1. Scegliete **Applica** per salvare le modifiche agli attributi.
1. Nella sezione **Varianti del Feature flag**, scegliete **Crea variante**.
1. Per **Nome variante**, inserisci un nome.
1. Utilizzate l'interruttore **Valore abilitato** per abilitare la variante.
1. Nella casella di testo **Regola**, inserisci una regola.
1. Utilizzate le opzioni **Crea variante** > **Crea variante sopra** o **Crea variante sotto** per creare varianti aggiuntive per questo contrassegno.
1. Nella sezione **Variante predefinita**, utilizzate l'interruttore **Valore abilitato** per abilitare la variante predefinita. Facoltativamente, fornite i valori per gli attributi definiti nel passaggio 10.
1. Scegli **Applica**.
1. Verifica i dettagli del contrassegno e delle sue varianti e scegli **Crea bandiera**.
Per informazioni sulla distribuzione del nuovo flag di funzionalità con varianti, consulta[Distribuzione di flag di funzionalità e dati di configurazione in AWS AppConfig](deploying-feature-flags.md).
## Creazione di un flag di funzionalità multivariante (riga di comando)
La procedura seguente descrive come utilizzare AWS Command Line Interface (su Linux o Windows) o Tools for Windows per PowerShell creare un flag di funzionalità multivariante per un profilo di configurazione esistente. È inoltre possibile modificare i flag di funzionalità esistenti per creare varianti.
**Prima di iniziare**
Completate le seguenti attività prima di creare un feature flag multivariante utilizzando il. AWS CLI
+ Create un profilo di configurazione del feature flag. Per ulteriori informazioni, consulta [Creazione di un profilo di configurazione del feature flag in AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Effettua l'aggiornamento alla versione più recente di AWS CLI. Per ulteriori informazioni, consulta [Install or update to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) nella *Guida per l’utente di AWS Command Line Interface *.
**Per creare un flag di funzionalità multivariante**
1. Create un file di configurazione sul computer locale che specifichi i dettagli del flag multivariante che desiderate creare. Salvate il file con un'`.json`estensione. Il file deve aderire allo schema [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. Il contenuto dello schema del file di configurazione sarà simile al seguente.
```
{
"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"
}
```
Ecco un esempio con tre varianti e la variante predefinita.
```
{
"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. Utilizza l'`CreateHostedConfigurationVersion`API per salvare i dati di configurazione del feature flag in 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
```
------
`service_returned_content_file`Contiene i dati di configurazione che includono alcuni metadati AWS AppConfig generati.
**Nota**
Quando crei la versione di configurazione ospitata, AWS AppConfig verifica che i dati siano conformi allo [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)schema JSON. AWS AppConfig verifica inoltre che ogni attributo feature flag presente nei dati soddisfi i vincoli definiti per tali attributi.
# Comprensione del tipo di riferimento per AWS.AppConfig.FeatureFlags
Utilizzate lo schema `AWS.AppConfig.FeatureFlags` JSON come riferimento per creare i dati di configurazione dei feature flag.
```
{
"$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
}
```
**Importante**
Per recuperare i dati di configurazione dei feature flag, l'applicazione deve chiamare l'`GetLatestConfiguration`API. Non è possibile recuperare i dati di configurazione dei feature flag chiamando`GetConfiguration`, il che è obsoleto. Per ulteriori informazioni, consulta [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html) nella *documentazione di riferimento dell’API AWS AppConfig *.
Quando l'applicazione chiama [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html)e riceve una configurazione appena distribuita, le informazioni che definiscono i flag e gli attributi delle funzionalità vengono rimosse. Il JSON semplificato contiene una mappa di chiavi che corrispondono a ciascuna delle chiavi flag specificate. Il JSON semplificato contiene anche i valori mappati di `true` o per l'attributo. `false` `enabled` Se un flag è `enabled` impostato su`true`, saranno presenti anche tutti gli attributi del flag. Lo schema JSON seguente descrive il formato dell'output 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
}
}
}
```
# Salvataggio di una versione precedente di Feature Flag in una nuova versione
Quando aggiorni un feature flag, salva AWS AppConfig automaticamente le modifiche in una nuova versione. Se desiderate utilizzare una versione precedente del feature flag, dovete copiarla in una versione bozza e salvarla. Non potete modificare e salvare le modifiche a una versione precedente del flag senza salvarla in una nuova versione.
**Per modificare una versione precedente del Feature Flag e salvarla in una nuova versione**
1. Apri la AWS Systems Manager console all'indirizzo [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. Nel pannello di navigazione, scegli **Applicazioni**, quindi scegli l'applicazione con il contrassegno di funzionalità che desideri modificare e salvare in una nuova versione.
1. Nella scheda **Profili di configurazione e bandiere di funzionalità**, scegliete il profilo di configurazione con il flag di funzionalità che desiderate modificare e salvatelo in una nuova versione.
1. Nella scheda **Feature flags**, utilizzate l'elenco **Versione** per scegliere la versione da modificare e salvare in una nuova versione.
1. Scegliete **Copia nella versione bozza**.
1. Nel campo **Etichetta della versione**, inserisci una nuova etichetta (facoltativa, ma consigliata).
1. Nel campo **Descrizione della versione**, inserisci una nuova descrizione (facoltativa, ma consigliata).
1. Scegli **Salva versione**.
1. Scegli **Avvia distribuzione** per distribuire la nuova versione.