As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criando um perfil de configuração no AWS AppConfig
*Dados de configuração* são um conjunto de configurações que influenciam o comportamento da aplicação. Um *perfil de configuração* inclui, entre outras coisas, um URI que permite AWS AppConfig localizar seus dados de configuração em seu local armazenado e um tipo de configuração. AWS AppConfig suporta os seguintes tipos de perfis de configuração:
+ **Sinalizadores de recursos**: você pode usar sinalizadores de recursos para ativar ou desativar recursos em seus aplicativos ou para configurar características diferentes dos recursos do seu aplicativo usando atributos de sinalizadores. AWS AppConfig armazena configurações de sinalizadores de recursos no repositório de configurações AWS AppConfig hospedado em um formato de sinalizador de recurso que contém dados e metadados sobre seus sinalizadores e os atributos do sinalizador. O URI para configurações do sinalizador de atributos é simplesmente `hosted`.
+ **Configurações de formato livre**: uma configuração de formato livre pode armazenar dados em qualquer uma das seguintes ferramentas e do Systems Serviços da AWS Manager:
+ AWS AppConfig armazenamento de configuração hospedado
+ Amazon Simple Storage Service
+ AWS CodePipeline
+ AWS Secrets Manager
+ AWS Systems Manager Armazenamento de parâmetros (SSM)
+ Armazenamento de documentos do SSM
**nota**
Se possível, recomendamos hospedar seus dados de configuração no armazenamento de configuração AWS AppConfig hospedado, pois ele oferece mais recursos e aprimoramentos.
Confira alguns exemplos de dados de configuração para compreender melhor os diferentes tipos de dados de configuração e como eles podem ser usados em um sinalizador de atributos ou em um perfil de configuração de forma livre.
**Dados de configuração de sinalizador de atributos**
A configuração de sinalizadores de atributos a seguir habilita ou desabilita pagamentos em dispositivos móveis e pagamentos padrão por região.
------
#### [ JSON ]
```
{
"allow_mobile_payments": {
"enabled": false
},
"default_payments_per_region": {
"enabled": true
}
}
```
------
#### [ YAML ]
```
---
allow_mobile_payments:
enabled: false
default_payments_per_region:
enabled: true
```
------
**Dados de configuração operacionais**
A configuração de forma livre a seguir impõe limites sobre como uma aplicação processa solicitações.
------
#### [ JSON ]
```
{
"throttle-limits": {
"enabled": "true",
"throttles": [
{
"simultaneous_connections": 12
},
{
"tps_maximum": 5000
}
],
"limit-background-tasks": [
true
]
}
}
```
------
#### [ YAML ]
```
---
throttle-limits:
enabled: 'true'
throttles:
- simultaneous_connections: 12
- tps_maximum: 5000
limit-background-tasks:
- true
```
------
**Dados de configuração da lista de controle de acesso**
Os dados de configuração de forma livre da lista de controle de acesso a seguir especificam quais usuários ou grupos podem acessar uma aplicação.
------
#### [ JSON ]
```
{
"allow-list": {
"enabled": "true",
"cohorts": [
{
"internal_employees": true
},
{
"beta_group": false
},
{
"recent_new_customers": false
},
{
"user_name": "Jane_Doe"
},
{
"user_name": "John_Doe"
}
]
}
}
```
------
#### [ YAML ]
```
---
allow-list:
enabled: 'true'
cohorts:
- internal_employees: true
- beta_group: false
- recent_new_customers: false
- user_name: Jane_Doe
- user_name: Ashok_Kumar
```
------
**Topics**
+ [Criando um perfil de configuração de sinalizador de recurso no AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md)
+ [Criando um perfil de configuração de formato livre no AWS AppConfig](appconfig-free-form-configurations-creating.md)
+ [Criar um perfil de configuração para fontes de dados não nativas](appconfig-creating-configuration-profile-other-data-sources.md)
# Criando um perfil de configuração de sinalizador de recurso no AWS AppConfig
Você pode usar sinalizadores de recursos para ativar ou desativar recursos em seus aplicativos ou para configurar características diferentes dos recursos do seu aplicativo usando atributos de sinalizadores. AWS AppConfig armazena configurações de sinalizadores de recursos no repositório de configurações AWS AppConfig hospedado em um formato de sinalizador de recurso que contém dados e metadados sobre seus sinalizadores e os atributos do sinalizador.
**nota**
Ao criar um perfil de configuração do sinalizador de recurso, você pode criar um sinalizador de recurso básico como parte do fluxo de trabalho do perfil de configuração. AWS AppConfig também oferece suporte a sinalizadores de recursos de várias variantes. Os *sinalizadores de atributos multivariante* permitem definir um conjunto de possíveis valores de sinalizador a serem exibidos para uma solicitação. Ao solicitar um sinalizador configurado com variantes, seu aplicativo fornece um contexto que é AWS AppConfig avaliado em relação a um conjunto de regras definidas pelo usuário. Dependendo do contexto especificado na solicitação e das regras definidas para a variante, AWS AppConfig retorna valores de sinalizadores diferentes para o aplicativo.
Para criar sinalizadores de atributos multivariante, primeiro crie um perfil de configuração e, depois, edite todos os sinalizadores no perfil de configuração para adicionar variantes. Para obter mais informações, consulte [Criar sinalizadores de atributos multivariante](appconfig-creating-multi-variant-feature-flags.md).
**Topics**
+ [Noções básicas sobre atributos do sinalizador de atributos](#appconfig-creating-configuration-profile-feature-flag-attributes)
+ [Criar um perfil de configuração de sinalizador de atributos (console)](appconfig-creating-feature-flag-configuration-create-console.md)
+ [Criar um perfil de configuração de sinalizador de atributos (linha de comandos)](appconfig-creating-feature-flag-configuration-commandline.md)
+ [Criar sinalizadores de atributos multivariante](appconfig-creating-multi-variant-feature-flags.md)
+ [Noções básicas sobre a referência de tipo para AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md)
+ [Salvar uma versão anterior do sinalizador de atributos em uma nova versão](appconfig-creating-configuration-profile-feature-flags-editing-version.md)
## Noções básicas sobre atributos do sinalizador de atributos
Ao criar um perfil de configuração de sinalizador de atributos ou criar outro sinalizador em um perfil de configuração existente, é possível especificar atributos e restrições correspondentes para o sinalizador. Atributo é um campo que você associa ao sinalizador de atributos para expressar propriedades relacionadas a ele. Os atributos são fornecidos à aplicação com a chave do sinalizador e o valor `enable` ou `disable` do sinalizador.
As restrições impedem que quaisquer valores de atributo inesperados sejam implantados na aplicação. A imagem a seguir mostra um exemplo.
![\[Exemplo de atributos de sinalizador para um sinalizador de AWS AppConfig recurso\]](http://docs.aws.amazon.com/pt_br/appconfig/latest/userguide/images/appconfig-flag-attributes.png)
**nota**
Observe as informações a seguir sobre atributos do sinalizador.
Para nomes de atributos, a palavra “ativado” é reservada. Você não pode criar nenhum atributo de sinalizadores de atributos chamado “ativado”. Não há outras palavras reservadas.
Os atributos de um sinalizador de atributos só são incluídos na resposta de `GetLatestConfiguration` se esse sinalizador estiver ativado.
As chaves de atributo de um sinalizador específico devem ser exclusivas.
AWS AppConfig suporta os seguintes tipos de atributos de bandeira e suas restrições correspondentes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/appconfig/latest/userguide/appconfig-creating-configuration-and-profile-feature-flags.html)
# Criar um perfil de configuração de sinalizador de atributos (console)
Use o procedimento a seguir para criar um perfil de configuração do sinalizador de AWS AppConfig recurso usando o AWS AppConfig console. Ao criar o perfil de configuração, você também pode criar um sinalizador de atributos básico.
**Para criar um perfil de configuração**
1. Abra o AWS Systems Manager console em [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. No painel de navegação, escolha **Aplicações** e selecione uma aplicação que você criou em [Criando um namespace para seu aplicativo no AWS AppConfig](appconfig-creating-namespace.md).
1. Na guia **Perfis de configuração e sinalizadores de atributos**, selecione **Criar configuração**.
1. Na seção **Opções de configuração**, escolha **sinalizador de atributos**.
1. Na seção **Perfil de configuração**, em **ID do perfil de configuração**, insira um nome.
1. (Opcional) Expanda **Descrição** e insira uma descrição.
1. (Opcional) Expanda **Opções adicionais** e conclua o seguinte, conforme necessário.
1. Na lista **Criptografia**, escolha uma chave AWS Key Management Service (AWS KMS) na lista. Essa chave gerenciada pelo cliente permite que você criptografe novas versões de dados de configuração no repositório de configuração AWS AppConfig hospedado. Para ter mais informações sobre essa chave, consulte **AWS AppConfig supports customer manager keys** em [Segurança em AWS AppConfig](appconfig-security.md).
1. Na seção **Tags**, selecione **Adicionar nova tag** e especifique uma chave e um valor opcional.
1. Escolha **Próximo**.
1. Na seção **Definição de sinalizador de atributos**, em **Nome do sinalizador**, insira um nome.
1. Em **Chave de sinalizador**, insira um identificador de sinalizador para distinguir os sinalizadores no mesmo perfil de configuração. Os sinalizadores no mesmo perfil de configuração não podem ter a mesma chave. Depois que o sinalizador for criado, você poderá editar o nome do sinalizador, mas não a chave do sinalizador.
1. (Opcional) Expanda **Descrição** e insira informações sobre esse sinalizador.
1. Selecione **Este é um sinalizador de curto prazo** e, opcionalmente, escolha uma data em que o sinalizador deve ser desativado ou excluído. AWS AppConfig *não* desativa o sinalizador na data de suspensão de uso.
1. (Opcional) Na seção **Atributos do sinalizador de atributos**, selecione **Definir atributo**. Os atributos permitem que você forneça valores adicionais em seu sinalizador. Para ter mais informações sobre atributos e restrições, consulte [Noções básicas sobre atributos do sinalizador de atributos](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Em **Chave**, especifique uma chave de sinalizador e escolha o tipo na lista **Tipo**. Para ter informações sobre as opções aceitas para os campos **Valor** e **Restrições**, consulte a seção mencionada anteriormente sobre atributos.
1. Selecione **Valor obrigatório** para especificar se um valor de atributo é obrigatório.
1. Selecione **Definir atributo** para adicionar outros atributos.
1. Na seção **Valor do sinalizador de atributos**, escolha **Habilitado** para habilitar o sinalizador. Use esse mesmo botão para desabilitar um sinalizador quando ele atingir uma data de depreciação especificada, se aplicável.
1. Escolha **Próximo**.
1. Na página **Revisar e salvar**, verifique os detalhes do sinalizador e **Salve e continue a implantação**.
Vá para [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md).
# Criar um perfil de configuração de sinalizador de atributos (linha de comandos)
O procedimento a seguir descreve como usar o AWS Command Line Interface (no Linux ou no Windows) ou o Tools for Windows PowerShell para criar um perfil de configuração do sinalizador de AWS AppConfig recurso. Ao criar o perfil de configuração, você também pode criar um sinalizador de atributos básico.
**Como criar uma configuração de sinalizador de atributos**
1. Abra AWS CLI o.
1. Crie um perfil de configuração de sinalizadores de atributos especificando seu **Tipo** como `AWS.AppConfig.FeatureFlags`. O perfil de configuração deve usar `hosted` para o URI de localização.
------
#### [ 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. Crie seus dados de configuração do sinalizador de atributos. Seus dados devem estar no formato JSON e estar em conformidade com o esquema JSON `AWS.AppConfig.FeatureFlags`. Para obter mais informações sobre o esquema, consulte [Noções básicas sobre a referência de tipo para AWS.AppConfig.FeatureFlags](appconfig-type-reference-feature-flags.md).
1. Use a API `CreateHostedConfigurationVersion` para salvar seus dados de configuração do sinalizador de atributos no 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
```
------
O comando carrega o conteúdo especificado para o parâmetro `Content` do disco. O conteúdo deve ser semelhante ao exemplo a seguir.
```
{
"flags": {
"ui_refresh": {
"name": "UI Refresh"
}
},
"values": {
"ui_refresh": {
"enabled": false,
"attributeValues": {
"dark_mode_support": true
}
}
},
"version": "1"
}
```
O sistema retorna informações como estas.
------
#### [ 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
```
------
O `service_returned_content_file` contém seus dados de configuração que incluem alguns metadados AWS AppConfig gerados.
**nota**
Ao criar a versão de configuração hospedada, AWS AppConfig verifica se seus dados estão em conformidade com o esquema `AWS.AppConfig.FeatureFlags` JSON. AWS AppConfig além disso, valida se cada atributo do sinalizador de recurso em seus dados satisfaz as restrições que você definiu para esses atributos.
# Criar sinalizadores de atributos multivariante
As variantes de sinalizador de atributos permitem definir um conjunto de possíveis valores de sinalizador a serem exibidos para uma solicitação. Também é possível configurar diferentes status (habilitado ou desabilitado) para sinalizadores multivariante. Ao solicitar um sinalizador configurado com variantes, seu aplicativo fornece um contexto que é AWS AppConfig avaliado em relação a um conjunto de regras definidas pelo usuário. Dependendo do contexto especificado na solicitação e das regras definidas para a variante, AWS AppConfig retorna valores de sinalizadores diferentes para o aplicativo.
A captura de tela a seguir mostra um exemplo de sinalizador de atributos com três variantes definidas pelo usuário e a variante padrão.
![\[Um exemplo de captura de tela de um sinalizador de atributos com variantes.\]](http://docs.aws.amazon.com/pt_br/appconfig/latest/userguide/images/flag-variant-example.png)
**Topics**
+ [Noções básicas sobre conceitos de sinalizadores de atributos multivariante e casos de uso comuns](appconfig-creating-multi-variant-feature-flags-concepts.md)
+ [Noções básicas sobre as regras de sinalizador de atributos multivariante](appconfig-creating-multi-variant-feature-flags-rules.md)
+ [Criar um sinalizador de atributos multivariante](appconfig-creating-multi-variant-feature-flags-procedures.md)
# Noções básicas sobre conceitos de sinalizadores de atributos multivariante e casos de uso comuns
Para ajudar você a entender melhor as variantes de sinalizador de atributos, esta seção explica os conceitos de variante de sinalizador e os casos de uso comuns.
**Conceitos**
+ **Sinalizador de recurso**: um tipo de AWS AppConfig configuração usado para controlar o comportamento de um recurso em um aplicativo. Um sinalizador tem um status (habilitado ou desabilitado) e um conjunto opcional de atributos que contém valores arbitrários de string, de matriz, numéricos ou boolianos.
+ **Variante de sinalizador de atributos**: uma combinação específica de valores de status e de atributos pertencentes a um sinalizador de atributos. Um sinalizador de atributos pode ter diversas variantes.
+ **Regra de variante**: uma expressão definida pelo usuário usada para selecionar uma variante de sinalizador de atributos. Cada variante tem sua própria regra que AWS AppConfig avalia para determinar se deve devolvê-la ou não.
+ **Variante padrão**: uma variante especial que é exibida quando nenhuma outra é selecionada. Todos os sinalizadores de atributos multivariante têm uma variante padrão.
A variante padrão deve ser a última na sua ordem de variantes e não pode ter regras associadas a ela. Se não estiver definido por último, AWS AppConfig retornará a `BadRequestException` quando você tentar criar o sinalizador de várias variantes.
+ **Contexto**: chaves e valores definidos pelo usuário transmitidos ao AWS AppConfig no momento da recuperação da configuração. Os valores de contexto são usados durante a avaliação da regra para selecionar a variante de sinalizador de atributos a ser exibida.
**nota**
AWS AppConfig o agente avalia as regras variantes e determina qual regra se aplica à solicitação com base no contexto fornecido. Para saber mais sobre como recuperar os sinalizadores de atributos multivariante, consulte [Recuperar sinalizadores de atributos básicos e multivariante](appconfig-integration-retrieving-feature-flags.md).
**Casos de uso comuns**
Esta seção descreve dois casos de uso comuns para variantes de sinalizador de atributos.
*Segmentação de usuários*
A segmentação de usuários é o processo de dividir usuários com base em determinados atributos. Por exemplo, é possível usar variantes de sinalizador para expor um recurso a alguns usuários, mas não a outros, com base em dados, como ID do usuário, localização geográfica, tipo de dispositivo ou frequência de compra.
Usando o exemplo da frequência de compra, suponha que sua aplicação de comércio eletrônico comporte um recurso para aumentar a fidelidade do cliente. É possível usar variantes de sinalizador para configurar diferentes tipos de incentivo a serem exibidos a um usuário com base na última vez em que ele comprou algo. Um novo usuário pode receber um pequeno desconto para incentivá-lo a se tornar um cliente, enquanto um cliente recorrente poderá receber um desconto maior se comprar algo de uma nova categoria.
*Divisão de tráfego*
Divisão de tráfego é o processo de selecionar uma variante de sinalizador aleatória, mas consistente, com base em um valor de contexto definido por você. Por exemplo, talvez você queira realizar um experimento em que uma pequena porcentagem de seus usuários (identificados pelo ID de usuário) veja uma variante específica. Ou talvez você queira realizar uma distribuição gradual de recursos, em que um deles seja exposto primeiro a 5% dos usuários, depois a 15%, depois a 40% e, por fim, a 100%, mantendo uma experiência de usuário consistente durante toda a distribuição.
Usando o exemplo de experimentação, é possível usar variantes de sinalizador para testar um novo estilo de botão para a ação principal na página inicial da aplicação e ver se ele gera mais cliques. Em seu experimento, você pode criar uma variante de sinalizador com uma regra de divisão de tráfego que selecione 5% dos usuários para ver o novo estilo, enquanto a variante padrão indica os usuários que devem continuar vendo o estilo existente. Se o experimento for bem-sucedido, você poderá aumentar o valor percentual ou até mesmo determinar que essa variante seja o padrão.
# Noções básicas sobre as regras de sinalizador de atributos multivariante
Ao criar uma variante de sinalizador de atributos, especifique uma regra para ela. Regras são expressões que usam valores de contexto como entrada e produzem um resultado booliano como saída. Por exemplo, é possível definir uma regra para selecionar uma variante de sinalizador para usuários beta, identificada pelo ID da conta, testando uma atualização da interface de usuário. No caso desse cenário, faça o seguinte:
1. Crie um perfil de configuração de sinalizador de atributos chamado *Atualização da interface de usuário.*
1. Crie um sinalizador de atributos chamado *ui\$1refresh*.
1. Depois de criá-lo, edite-o para adicionar variantes.
1. Crie e habilite uma nova variante chamada *BetaUsers*.
1. Defina uma regra para selecionar *BetaUsers*a variante se o ID da conta do contexto da solicitação estiver em uma lista de contas IDs aprovadas para visualizar a nova experiência beta.
1. Confirme se o status da variante padrão está definido como **Desativado**.
**nota**
As variantes são avaliadas como uma lista ordenada com base na ordem em que são definidas no console. A variante no início da lista será avaliada primeiro. Se nenhuma regra corresponder ao contexto fornecido, AWS AppConfig retornará a variante Default.
Quando AWS AppConfig processa a solicitação do sinalizador de recurso, ele compara primeiro o contexto fornecido, que inclui o accountId (neste exemplo) com a variante. BetaUsers Se o contexto corresponder à regra de BetaUsers, AWS AppConfig retornará os dados de configuração da experiência beta. Se o contexto não incluir uma ID da conta ou se a ID da conta terminar em algo diferente de 123, AWS AppConfig retornará os dados de configuração da regra padrão, o que significa que o usuário visualiza a experiência atual na produção.
**nota**
Para obter mais informações sobre como recuperar os sinalizadores de atributos multivariante, consulte [Recuperar sinalizadores de atributos básicos e multivariante](appconfig-integration-retrieving-feature-flags.md).
# Definir regras para sinalizadores de atributos multivariante
Regra de variante é uma expressão composta de um ou mais operandos e de um operador. Operando é um valor específico usado durante a avaliação de uma regra. Os valores de operando podem ser estáticos, como um número literal ou uma string, ou variáveis, como o valor encontrado em um contexto ou o resultado de outra expressão. Um operador, como “maior que”, é um teste ou uma ação aplicada aos respectivos operandos que produz um valor. Uma expressão de regra de variante deve produzir um valor “true” ou “false” para ser válida.
**Operandos**
****
| Tipo | Description | Exemplo |
| --- | --- | --- |
| String | Uma sequência de caracteres UTF-8, entre aspas duplas. | "apple", "Ḽơᶉëᶆ ȋṕšᶙṁ"
|
| Inteiro | Um valor inteiro de 64 bits. | -7, 42
|
| Float | Um valor de ponto flutuante IEEE 754 de 64 bits. | 3.14, 1.234e-5
|
| Timestamp | Um momento específico, conforme descrito na [nota do W3C sobre formatos de data e hora](https://www.w3.org/TR/NOTE-datetime). | 2012-03-04T05:06:07-08:00, 2024-01
|
| Booleano | Um valor verdadeiro ou falso. | true, false
|
| Valor de contexto. | Um valor parametrizado na forma de \$1 *key* que é recuperado do contexto durante a avaliação da regra. | $country, $userId
|
**Operadores de comparação**
****
| Operador | Description | Exemplo |
| --- | --- | --- |
| eq | Determina se um valor de contexto é igual a um valor específico. | (eq $state "Virginia")
|
| gt | Determina se um valor de contexto é maior do que um valor específico. | (gt $age 65)
|
| gte | Determina se um valor de contexto é maior ou igual a um valor específico. | (gte $age 65)
|
| lt | Determina se um valor de contexto é menor do que um valor específico. | (lt $age 65)
|
| lte | Determina se um valor de contexto é menor ou igual a um valor específico. | (lte $age 65)
|
**Operadores lógicos**
****
| Operador | Description | Exemplo |
| --- | --- | --- |
| and | Determina se os dois operandos são verdadeiros. | (and
(eq $state "Virginia")
(gt $age 65)
)
|
| or | Determina se pelo menos um dos operandos é verdadeiro. | (or
(eq $state "Virginia")
(gt $age 65)
)
|
| not | Reverte o valor de uma expressão. | (not (eq $state "Virginia"))
|
**Operadores personalizados**
****
| Operador | Description | Exemplo |
| --- | --- | --- |
| begins\$1with | Determina se um valor de contexto começa com um prefixo específico. | (begins_with $state "A")
|
| ends\$1with | Determina se um valor de contexto termina com um prefixo específico. | (ends_with $email "amazon.com")
|
| contém | Determina se um valor de contexto contém uma substring específica. | (contains $promoCode "WIN")
|
| in | Determina se um valor de contexto está contido em uma lista de constantes. | (in $userId ["123", "456"])
|
| matches | Determina se um valor de contexto corresponde a um padrão regex específico. | (matches in::$greeting pattern::"h.*y")
|
| exists | Determina se algum valor foi fornecido para uma chave de contexto. | (exists key::"country")
|
| dividir | Avalia uma porcentagem específica de tráfego como `true` com base em um hash consistente dos valores de contexto fornecidos. Para obter uma explicação detalhada sobre como o `split` funciona, confira a próxima seção deste tópico, [Entender o operador split](appconfig-creating-multi-variant-feature-flags-rules.md#appconfig-creating-multi-variant-feature-flags-rules-operators-split). Observe que `seed` é uma propriedade opcional. Se você não especificar `seed`, o hash será *localmente* consistente, o que significa que o tráfego será dividido de forma consistente para esse sinalizador, mas outros sinalizadores que receberem o mesmo valor de contexto poderão dividir o tráfego de maneira diferente. Se `seed` for fornecido, cada valor exclusivo dividirá o tráfego de forma consistente entre sinalizadores de atributos, perfis de configuração e Contas da AWS. | (split pct::10 by::$userId seed::"abc")
|
## Entender o operador split
A seção a seguir descreve como o operador `split` se comporta quando usado em diferentes cenários. Como lembrete, `split` é avaliado como `true` para uma determinada porcentagem de tráfego com base em um hash consistente do valor de contexto fornecido. Para entender melhor, considere o seguinte cenário de linha de base que usa a divisão com duas variantes:
```
A: (split by::$uniqueId pct::20)
C:
```
Como esperado, fornecer um conjunto aleatório de valores `uniqueId` produz uma distribuição que é aproximadamente:
```
A: 20%
C: 80%
```
Se você adicionar uma terceira variante, mas usar a mesma porcentagem de divisão da seguinte maneira:
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::20)
C:
```
A distribuição fica da seguinte forma:
```
A: 20%
B: 0%
C: 80%
```
Essa distribuição possivelmente inesperada acontece porque cada regra de variante é avaliada em ordem, e a primeira correspondência define a variante retornada. Quando a regra A é avaliada, 20% dos valores `uniqueId` correspondem a ela, então a primeira variante é retornada. Em seguida, a regra B é avaliada. No entanto, todos os valores `uniqueId` que corresponderiam à segunda instrução dividida já foram correspondidos pela regra de variante A. Portanto, nenhum valor corresponde a B. Em vez disso, a variante padrão é retornada.
Agora, considere um terceiro exemplo.
```
A: (split by::$uniqueId pct::20)
B: (split by::$uniqueId pct::25)
C:
```
Como no exemplo anterior, os primeiros 20% dos valores `uniqueId` correspondem à regra A. Para a regra da variante B, 25% de todos os valores `uniqueId` seriam correspondentes. Porém, a maioria deles correspondia à regra A. Isso deixa 5% do total para a variante B, com o restante recebendo a variante C. A distribuição teria a seguinte aparência:
```
A: 20%
B: 5%
C: 75%
```
**Usar a propriedade `seed`**
Você pode usar a propriedade `seed` para garantir que o tráfego seja dividido de maneira consistente para um determinado valor de contexto, independentemente de onde o operador split seja usado. Se você não especificar `seed`, o hash será *localmente* consistente, o que significa que o tráfego será dividido de forma consistente para esse sinalizador, mas outros sinalizadores que receberem o mesmo valor de contexto poderão dividir o tráfego de maneira diferente. Se `seed` for fornecido, cada valor exclusivo dividirá o tráfego de forma consistente entre sinalizadores de atributos, perfis de configuração e Contas da AWS.
Os clientes costumam usar o mesmo valor `seed` em todas as variantes em um sinalizador ao dividir o tráfego na mesma propriedade de contexto. No entanto, às vezes pode fazer sentido usar um valor de semente diferente. Confira um exemplo que usa sementes diferentes para as regras A e B:
```
A: (split by::$uniqueId pct::20 seed::"seed_one")
B: (split by::$uniqueId pct::25 seed::"seed_two")
C:
```
Como antes, 20% dos valores `uniqueId` equivalentes correspondem à regra A. Isso significa que 80% dos valores são aprovados e testados em relação à regra da variante B. Como a semente é diferente, não há correlação entre os valores que correspondem a A e os que correspondem a B. No entanto, existem somente 80% dos valores `uniqueId` a serem divididos com 25% desse número correspondente à regra B, e 75% não. Isso funciona para a seguinte distribuição:
```
A: 20%
B: 20% (25% of what falls through from A, or 25% of 80%)
C: 60%
```
# Criar um sinalizador de atributos multivariante
Use os procedimentos desta seção para criar variantes de um sinalizador de atributos.
**Antes de começar**
Observe as seguintes informações importantes:
+ É possível criar variantes de sinalizadores de atributos existentes editando-os. Não é possível criar variantes de um novo sinalizador de atributos *ao criar um perfil de configuração*. Primeiro, é necessário concluir o fluxo de trabalho de criação do perfil de configuração. Após a criação do perfil de configuração, é possível adicionar variantes a qualquer sinalizador no perfil de configuração. Para ter informações sobre como criar um perfil de configuração, consulte [Criando um perfil de configuração de sinalizador de recurso no AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Para recuperar dados de variantes de sinalização de recurso para as plataformas computacionais Amazon EC2, Amazon ECS e Amazon EKS, você deve AWS AppConfig usar a versão 2.0.4416 ou posterior do Agent.
+ Por motivos de desempenho AWS CLI e chamadas do SDK para AWS AppConfig não recuperar dados de variantes. Para obter mais informações sobre o AWS AppConfig Agente, consulte[Como usar o AWS AppConfig Agent para recuperar dados de configuração](appconfig-agent-how-to-use.md).
+ Ao criar uma variante de sinalizador de atributos, especifique uma regra para ela. Regras são expressões que usam o contexto da solicitação como entrada e produzem um resultado booliano como saída. Antes de criar variantes, revise os operandos e os operadores compatíveis para regras de variantes de sinalizador. É possível criar regras antes de criar variantes. Para obter mais informações, consulte [Noções básicas sobre as regras de sinalizador de atributos multivariante](appconfig-creating-multi-variant-feature-flags-rules.md).
**Topics**
+ [Criar um sinalizador de atributos multivariante (console)](#appconfig-creating-multi-variant-feature-flags-procedures-console)
+ [Criar um sinalizador de atributos multivariante (linha de comandos)](#appconfig-creating-multi-variant-feature-flags-procedures-commandline)
## Criar um sinalizador de atributos multivariante (console)
O procedimento a seguir descreve como criar um sinalizador de recurso de várias variantes para um perfil de configuração existente usando o AWS AppConfig console. Também é possível editar sinalizadores de atributos existentes para criar variantes.
**Como criar um sinalizador de atributos multivariante**
1. Abra o AWS Systems Manager console em [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. No painel de navegação, escolha **Aplicações** e selecione uma aplicação.
1. Na guia **Perfis de configuração e sinalizadores de atributoss**, escolha um perfil de configuração de sinalizador de atributos existente.
1. Na seção **Sinalizadores**, escolha **Adicionar novo sinalizador**.
1. Na seção **Definição de sinalizador de atributos**, em **Nome do sinalizador**, insira um nome.
1. Em **Chave de sinalizador**, insira um identificador de sinalizador para distinguir os sinalizadores no mesmo perfil de configuração. Os sinalizadores no mesmo perfil de configuração não podem ter a mesma chave. Depois que o sinalizador for criado, você poderá editar o nome do sinalizador, mas não a chave do sinalizador.
1. (Opcional) No campo **Descrição**, insira informações sobre esse sinalizador.
1. Na seção **Variantes**, selecione **Sinalizador multivariante**.
1. (Opcional) Na seção **Atributos do sinalizador de atributos**, selecione **Definir atributo**. Os atributos permitem que você forneça valores adicionais em seu sinalizador. Para ter mais informações sobre atributos e restrições, consulte [Noções básicas sobre atributos do sinalizador de atributos](appconfig-creating-configuration-and-profile-feature-flags.md#appconfig-creating-configuration-profile-feature-flag-attributes).
1. Em **Chave**, especifique uma chave de sinalizador e escolha o tipo na lista **Tipo**. Para ter informações sobre as opções aceitas para os campos **Valor** e **Restrições**, consulte a seção mencionada anteriormente sobre atributos.
1. Selecione **Valor obrigatório** para especificar se um valor de atributo é obrigatório.
1. Selecione **Definir atributo** para adicionar outros atributos.
1. Selecione **Aplicar** para salvar as alterações de atributo.
1. Na seção **Variantes de sinalizador de atributos**, selecione **Criar variante**.
1. Em **Nome da variante**, insira um nome.
1. Use o botão de alternância **Valor habilitado** para habilitar a variante.
1. Na caixa de texto **Regra**, insira uma regra.
1. Se quiser criar variantes adicionais para esse sinalizador, use as opções **Criar variante** > **Criar a variante acima** ou **Criar uma variante abaixo**.
1. Na seção **Variante padrão**, use a opção **Valor habilitado** para habilitar a variante padrão. Também é possível fornecer valores para os atributos definidos na Etapa 10.
1. Escolha **Aplicar**.
1. Verifique os detalhes do sinalizador e as respectivas variantes e selecione **Criar sinalizador**.
Para ter informações sobre como implantar um novo sinalizador de atributos com variantes, consulte [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md).
## Criar um sinalizador de atributos multivariante (linha de comandos)
O procedimento a seguir descreve como usar o AWS Command Line Interface (no Linux ou no Windows) ou o Tools for Windows PowerShell para criar um sinalizador de recurso de várias variantes para um perfil de configuração existente. Também é possível editar sinalizadores de atributos existentes para criar variantes.
**Antes de começar**
Realize as tarefas a seguir antes de criar um sinalizador de atributos multivariante usando a AWS CLI.
+ Crie um perfil de configuração de sinalizador de atributos. Para obter mais informações, consulte [Criando um perfil de configuração de sinalizador de recurso no AWS AppConfig](appconfig-creating-configuration-and-profile-feature-flags.md).
+ Atualize para a versão mais recente da AWS CLI. Para ter mais informações, consulte [Install or update to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) no *Guia do usuário da versão 2 da AWS Command Line Interface *.
**Como criar um sinalizador de atributos multivariante**
1. Crie um arquivo de configuração em sua máquina local que especifique os detalhes do sinalizador multivariante que você deseja criar. Salve o arquivo com a extensão `.json`. O arquivo deve seguir o esquema JSON [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). O conteúdo do esquema do arquivo de configuração será semelhante ao seguinte:
```
{
"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"
}
```
Veja um exemplo com três variantes e a variante padrão.
```
{
"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. Use a API `CreateHostedConfigurationVersion` para salvar seus dados de configuração do sinalizador de atributos no 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
```
------
O `service_returned_content_file` contém seus dados de configuração que incluem alguns metadados AWS AppConfig gerados.
**nota**
Ao criar a versão de configuração hospedada, AWS AppConfig verifica se seus dados estão em conformidade com o esquema [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 além disso, valida se cada atributo do sinalizador de recurso em seus dados satisfaz as restrições que você definiu para esses atributos.
# Noções básicas sobre a referência de tipo para AWS.AppConfig.FeatureFlags
Use o esquema JSON `AWS.AppConfig.FeatureFlags` como referência para criar seus dados de configuração do sinalizador de atributos.
```
{
"$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**
Para recuperar dados de configuração do sinalizador de atributos, seu aplicativo deve chamar a API `GetLatestConfiguration`. Não é possível recuperar dados de configuração do sinalizador de atributos chamando `GetConfiguration`, que está obsoleto. Para obter mais informações, consulte [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html) na *Referência de APIs do AWS AppConfig *.
Quando seu aplicativo chama [GetLatestConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetLatestConfiguration.html)e recebe uma configuração recém-implantada, as informações que definem seus sinalizadores e atributos de recursos são removidas. O JSON simplificado contém um mapa de chaves que correspondem a cada uma das chaves de sinalizadores que você especificou. O JSON simplificado também contém valores `true` ou `false` mapeados para o atributo `enabled`. Se um sinalizador definir `enabled` como `true`, todos os atributos do sinalizador também estarão presentes. O esquema JSON a seguir descreve o formato da saída 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
}
}
}
```
# Salvar uma versão anterior do sinalizador de atributos em uma nova versão
Quando você atualiza um sinalizador de recurso, salva AWS AppConfig automaticamente suas alterações em uma nova versão. Se quiser usar uma versão anterior do sinalizador de atributos, copie-a para uma versão de rascunho e depois salve-a. Não é possível editar e salvar as alterações em uma versão anterior do sinalizador sem salvá-las em uma nova versão.
**Para editar uma versão anterior do sinalizador de atributos e salvá-la em uma nova versão**
1. Abra o AWS Systems Manager console em [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. No painel de navegação, escolha **aplicativos** e, depois, o aplicativo com o sinalizador de atributos que deseja editar e salvar em uma nova versão.
1. Na guia **Perfis de configuração e sinalizadores de atributos**, escolha o perfil de configuração com o sinalizador de atributos que você quer editar e salvar em uma nova versão.
1. Na guia **Sinalizadores de atributos**, use a lista de **versões** para escolher a versão que você quer editar e salvar em uma nova versão.
1. Escolha **Copiar para a versão de rascunho**.
1. No campo **Rótulo da versão**, insira um novo rótulo (opcional, mas recomendado).
1. No campo **Descrição da versão**, insira uma nova descrição (opcional, mas recomendado).
1. Escolha **Salvar versão**.
1. Escolha **Iniciar implantação** para implantar a nova versão.
# Criando um perfil de configuração de formato livre no AWS AppConfig
*Dados de configuração* são um conjunto de configurações que influenciam o comportamento da aplicação. Um *perfil de configuração* inclui, entre outras coisas, um URI que permite AWS AppConfig localizar seus dados de configuração em seu local armazenado e um tipo de configuração. Com perfis de configuração de formato livre, você pode armazenar seus dados no repositório de configuração AWS AppConfig hospedado ou em qualquer uma das seguintes ferramentas Serviços da AWS e no Systems Manager:
****
| Local | Tipos de arquivos compatíveis |
| --- | --- |
| AWS AppConfig armazenamento de configuração hospedado | YAML, JSON e texto, se adicionados usando o. Console de gerenciamento da AWS Qualquer tipo de arquivo, se adicionado usando a ação AWS AppConfig [CreateHostedConfigurationVersion](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_CreateHostedConfigurationVersion.html)da API. |
| [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) | Any |
| [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html) | Pipeline (conforme definido pelo serviço) |
| [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) | Segredo (conforme definido pelo serviço) |
| [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) | Parâmetros de string padrão e seguros (conforme definido pelo Parameter Store) |
| [AWS Systems Manager armazenamento de documentos (documentos SSM)](https://docs.aws.amazon.com/systems-manager/latest/userguide/documents.html) | YAML, JSON, texto |
Um perfil de configuração também pode incluir validadores opcionais para garantir que seus dados de configuração estejam sintática e semanticamente corretos. AWS AppConfig executa uma verificação usando os validadores quando você inicia uma implantação. Se algum erro for detectado, a implantação será interrompida antes de fazer qualquer alteração nos destinos da configuração.
**nota**
Se possível, recomendamos hospedar seus dados de configuração no armazenamento de configuração AWS AppConfig hospedado, pois ele oferece mais recursos e aprimoramentos.
Para configurações de formato livre armazenadas no repositório de configurações AWS AppConfig hospedado ou nos documentos SSM, você pode criar a configuração de forma livre usando o console do Systems Manager ao criar um perfil de configuração. O processo está descrito posteriormente neste tópico.
Para configurações de formato livre armazenadas no Parameter Store, Secrets Manager ou Amazon S3, você deve primeiro criar o parâmetro, segredo ou objeto e armazená-lo no respectivo armazenamento de configuração. Depois de armazenar os dados de configuração, use o procedimento neste tópico para criar o perfil de configuração.
**Topics**
+ [Noções básicas sobre validadores](appconfig-creating-configuration-and-profile-validators.md)
+ [Noções básicas sobre cotas e limitações do armazenamento de configuração](appconfig-creating-configuration-and-profile-quotas.md)
+ [Entendendo o armazenamento de configuração AWS AppConfig hospedado](appconfig-creating-configuration-and-profile-about-hosted-store.md)
+ [Noções básicas sobre configurações armazenadas no Amazon S3](appconfig-creating-configuration-and-profile-S3-source.md)
+ [Criação de um perfil AWS AppConfig de configuração de formato livre (console)](appconfig-creating-free-form-configuration-and-profile-create-console.md)
+ [Criação de um perfil AWS AppConfig de configuração de formato livre (linha de comando)](appconfig-creating-free-form-configuration-and-profile-create-commandline.md)
# Noções básicas sobre validadores
Ao criar um perfil de configuração, é possível especificar até dois validadores. Um validador garante que os dados da configuração estejam sintaticamente e semanticamente corretos. Se você planeja usar um validador, deve criá-lo antes de criar o perfil de configuração. AWS AppConfig suporta os seguintes tipos de validadores:
+ **AWS Lambda funções**: Compatível com sinalizadores de recursos e configurações de formato livre.
+ **Esquema JSON**: compatível com configurações de formato livre. (valida AWS AppConfig automaticamente os sinalizadores de recursos em relação a um esquema JSON.)
**Topics**
+ [AWS Lambda validadores de funções](#appconfig-creating-configuration-and-profile-validators-lambda)
+ [Validadores do esquema JSON](#appconfig-creating-configuration-and-profile-validators-json-schema)
## AWS Lambda validadores de funções
O validadores da função do Lambda devem ser configurados com o esquema de eventos a seguir. O AWS AppConfig usa esse esquema para invocar a função do Lambda. O conteúdo é uma string codificada em base64 e o URI é uma string.
```
{
"applicationId": "The application ID of the configuration profile being validated",
"configurationProfileId": "The ID of the configuration profile being validated",
"configurationVersion": "The version of the configuration profile being validated",
"content": "Base64EncodedByteString",
"uri": "The configuration uri"
}
```
AWS AppConfig verifica se o cabeçalho `X-Amz-Function-Error` Lambda está definido na resposta. O Lambda define esse cabeçalho se a função gerar uma exceção. Para obter mais informações sobre `X-Amz-Function-Error`, consulte [Lidar com erros e tentativas automáticas no AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/retries-on-errors.html) no *Guia do desenvolvedor do AWS Lambda *.
Veja um exemplo simples de um código de resposta do Lambda para uma validação bem-sucedida.
```
import json
def handler(event, context):
#Add your validation logic here
print("We passed!")
```
Veja um exemplo simples de um código de resposta do Lambda para uma validação malsucedida.
```
def handler(event, context):
#Add your validation logic here
raise Exception("Failure!")
```
Veja a seguir outro exemplo que valida somente se o parâmetro de configuração for um número primo.
```
function isPrime(value) {
if (value < 2) {
return false;
}
for (i = 2; i < value; i++) {
if (value % i === 0) {
return false;
}
}
return true;
}
exports.handler = async function(event, context) {
console.log('EVENT: ' + JSON.stringify(event, null, 2));
const input = parseInt(Buffer.from(event.content, 'base64').toString('ascii'));
const prime = isPrime(input);
console.log('RESULT: ' + input + (prime ? ' is' : ' is not') + ' prime');
if (!prime) {
throw input + "is not prime";
}
}
```
AWS AppConfig chama sua validação de Lambda ao chamar as operações de `ValidateConfigurationActivity` API `StartDeployment` e. Você deve fornecer permissões `appconfig.amazonaws.com` para invocar seu Lambda. Para obter mais informações, consulte [Concedendo acesso de funções aos AWS serviços](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#permissions-resource-serviceinvoke). AWS AppConfig limita o tempo de execução da validação do Lambda a 15 segundos, incluindo a latência de inicialização.
## Validadores do esquema JSON
Se você criar uma configuração em um documento do SSM, será necessário especificar ou criar um esquema JSON para essa configuração. Um esquema JSON define as propriedades permitidas para cada definição de configuração de aplicativo. O esquema JSON funciona como um conjunto de regras para garantir que definições de configuração novas ou atualizadas estejam em conformidade com as melhores práticas exigidas pelo aplicativo. Aqui está um exemplo.
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "$id$",
"description": "BasicFeatureToggle-1",
"type": "object",
"additionalProperties": false,
"patternProperties": {
"[^\\s]+$": {
"type": "boolean"
}
},
"minProperties": 1
}
```
Quando você cria uma configuração a partir de um documento SSM, o sistema verifica automaticamente se a configuração está em conformidade com os requisitos do esquema. Caso contrário, o AWS AppConfig retornará um erro de validação.
**Importante**
Observe as seguintes informações importantes sobre validadores do esquema JSON:
Os dados de configuração armazenados em documentos do SSM devem ser validados em relação a um esquema JSON associado antes que você possa adicionar a configuração ao sistema. Os parâmetros SSM não exigem um método de validação, mas recomendamos que você crie uma verificação de validação para configurações de parâmetros SSM novas ou atualizadas usando. AWS Lambda
Uma configuração em um documento SSM usa o tipo de documento `ApplicationConfiguration`. O esquema JSON correspondente usa o tipo de documento `ApplicationConfigurationSchema`.
AWS AppConfig suporta o esquema JSON versão 4.X para esquema embutido. Se a configuração do seu aplicativo exigir uma versão diferente do esquema JSON, será necessário criar um validador do Lambda.
# Noções básicas sobre cotas e limitações do armazenamento de configuração
Os repositórios de configuração suportados pelo AWS AppConfig têm as seguintes cotas e limitações.
****
| | AWS AppConfig armazenamento de configuração hospedado | Amazon S3 | Systems Manager Parameter Store | AWS Secrets Manager | Systems Manager Document Store | AWS CodePipeline |
| --- | --- | --- | --- | --- | --- | --- |
| **Limite de tamanho da configuração** | Padrão de 2 MB, máximo de 4 MB | 2 MB Aplicado por AWS AppConfig, não pelo S3 | 4 KB (nível gratuito) / 8 KB (parâmetros avançados) | 64 KB | 64 KB | 2 MBImposta por AWS AppConfig, não CodePipeline |
| **Limite de armazenamento de recursos** | 1 GB | Ilimitado | 10.000 parâmetros (nível gratuito) / 100.000 parâmetros (parâmetros avançados) | 500.000 | 500 documentos | Limitado pelo número de perfis de configuração por aplicativo (100 perfis por aplicativo) |
| **Criptografia do lado do servidor** | Sim | [SSE-S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html), [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) | Sim | Sim | Não | Sim |
| **CloudFormation apoio** | Sim | Não é para criar ou atualizar dados | Sim | Sim | Não | Sim |
| **Preços** | Gratuito | Consulte [Definição de preço do Amazon S3](https://aws.amazon.com//s3/pricing/) | Consulte [Definição de preço do AWS Systems Manager](https://aws.amazon.com//systems-manager/pricing/) | Consulte [Definição de preço do AWS Secrets Manager](https://aws.amazon.com//secrets-manager/pricing/) | Gratuito | Consulte [Definição de preço do AWS CodePipeline](https://aws.amazon.com//codepipeline/pricing/) |
# Entendendo o armazenamento de configuração AWS AppConfig hospedado
AWS AppConfig inclui um armazenamento de configuração interno ou hospedado. As configurações devem ter 2 MB ou menos. O armazenamento de configuração AWS AppConfig hospedado oferece os seguintes benefícios em relação a outras opções de armazenamento de configuração.
+ Não é necessário configurar outros serviços, como o Amazon Simple Storage Service (Amazon S3) ou o repositório de parâmetros.
+ Você não precisa configurar permissões AWS Identity and Access Management (IAM) para usar o armazenamento de configurações.
+ É possível armazenar configurações em YAML, JSON ou como documentos de texto.
+ Não há custo para usar o armazenamento.
+ É possível criar uma configuração e adicioná-la ao armazenamento ao criar um perfil de configuração.
# Noções básicas sobre configurações armazenadas no Amazon S3
Você pode armazenar configurações em um bucket do Amazon Simple Storage Service (Amazon S3). Ao criar o perfil de configuração, você especifica o URI para um único objeto do S3 em um bucket. Você também especifica o Amazon Resource Name (ARN) de uma função AWS Identity and Access Management (IAM) que dá AWS AppConfig permissão para obter o objeto. Antes de criar um perfil de configuração para um objeto do Amazon S3, lembre-se das restrições a seguir.
****
| Restrição | Detalhes |
| --- | --- |
| Tamanho | As configurações armazenadas como objetos do S3 podem ter um tamanho máximo de 1 MB. |
| Object encryption | Um perfil de configuração pode ter como alvo objetos criptografados SSE-S3 e SSE-KMS. |
| Classes de armazenamento | AWS AppConfig suporta as seguintes classes de armazenamento S3: `STANDARD``INTELLIGENT_TIERING`,`REDUCED_REDUNDANCY`,`STANDARD_IA`, e. `ONEZONE_IA` As classes a seguir não são compatíveis: todas as classes do S3 Glacier (`GLACIER` e `DEEP_ARCHIVE`). |
| Versionamento | AWS AppConfig exige que o objeto S3 use o controle de versão. |
## Configuração de permissões para uma configuração armazenada como um objeto do Amazon S3
Ao criar um perfil de configuração para uma configuração armazenada como um objeto do S3, você deve especificar um ARN para uma função do IAM que AWS AppConfig dê permissão para obter o objeto. A função deve incluir as seguintes permissões:
Permissões para acessar o objeto do S3
+ s3: GetObject
+ s3: GetObjectVersion
Permissões para listar buckets do S3
s3: ListAllMyBuckets
Permissões para acessar o bucket do S3 em que o objeto está armazenado
+ s3: GetBucketLocation
+ s3: GetBucketVersioning
+ s3: ListBucket
+ s3: ListBucketVersions
Conclua o procedimento a seguir para criar uma função que permita AWS AppConfig obter uma configuração armazenada em um objeto do S3.
**Criação da política do IAM para acessar um objeto do S3**
Use o procedimento a seguir para criar uma política do IAM que permita AWS AppConfig obter uma configuração armazenada em um objeto do S3.
**Para criar uma política do IAM para acessar um objeto do S3**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, selecione **Políticas** e, em seguida, **Criar política**.
1. Na página **Criar política**, escolha a guia **JSON**.
1. Atualize a política de exemplo a seguir com informações sobre o bucket do S3 e o objeto de configuração. Depois, cole a política no campo de texto na guia **JSON** . Substitua *placeholder values* por suas próprias informações.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/my-configurations/my-configuration.json"
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:GetBucketVersioning",
"s3:ListBucketVersions",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
1. Selecione **Revisar política**.
1. Na página **Review policy (Revisar política)**, digite um nome na caixa **Name (Nome)** e, depois, uma descrição.
1. Selecione **Criar política**. O sistema faz com que você retorne para a página **Roles**.
**Criação do perfil do IAM para acessar um objeto do S3**
Use o procedimento a seguir para criar uma função do IAM que permita AWS AppConfig obter uma configuração armazenada em um objeto do S3.
**Para criar um perfil do IAM para acessar um objeto do Amazon S3**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Perfis** e **Criar perfil**.
1. Na seção **Selecionar tipo de entidade confiável**, escolha **Serviço da AWS **.
1. Na seção **Choose a case use (Escolher um caso de uso)** em **Common use cases (Casos de uso comuns)**, escolha **EC2** e, depois, escolha **Next: Permissions (Próximo: Permissões)**.
1. Na página **Attach permissions policy (Anexar política de permissões)**, na caixa de pesquisa, insira o nome da política criada no procedimento anterior.
1. Selecione essa política e escolha **Next: Tags (Próximo: Tags)**.
1. Na página **Adicionar tags (opcional)**, insira uma chave e um valor opcional e escolha **Próximo: revisão**.
1. Na página **Review (Revisar)**, digite um nome na caixa **Role name (Nome da função)** e, depois, uma descrição.
1. Selecione **Create role** (Criar função). O sistema faz com que você retorne para a página **Roles**.
1. Na página **Roles** (Funções), escolha a função que você acabou de criar para abrir a página **Summary** (Resumo). Anote os valores de **Role Name (Nome da função)** e **Role ARN (ARN da função)**. Você especificará o ARN da função ao criar o perfil de configuração posteriormente neste tópico.
**Criar um relacionamento de confiança**
Use o procedimento a seguir para configurar a função que você acabou de criar para confiar no AWS AppConfig.
**Como adicionar um relacionamento de confiança**
1. Na página **Summary** da função que você acabou de criar, escolha a guia **Trust Relationships** e, em seguida, **Edit Trust Relationship**.
1. Exclua `"ec2.amazonaws.com"` e adicione `"appconfig.amazonaws.com"`, conforme mostrado no exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appconfig.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Selecione **Atualizar política de confiança**.
# Criação de um perfil AWS AppConfig de configuração de formato livre (console)
Use o procedimento a seguir para criar um perfil de configuração de AWS AppConfig forma livre e (opcionalmente) uma configuração de forma livre usando o console. AWS Systems Manager
**Como criar um perfil de configuração de forma livre**
1. Abra o AWS Systems Manager console em [https://console.aws.amazon.com/systems-manager/appconfig/](https://console.aws.amazon.com/systems-manager/appconfig/).
1. No painel de navegação, escolha **Aplicações** e selecione uma aplicação que você criou em [Criando um namespace para seu aplicativo no AWS AppConfig](appconfig-creating-namespace.md).
1. Selecione a guia **Perfis de configuração e sinalizadores de atributos** e escolha **Criar configuração**.
1. Na seção **Opções de configuração**, escolha **Configuração de forma livre**.
1. Em **ID do perfil de configuração**, insira um nome para o perfil de configuração.
1. (Opcional) Expanda **Descrição** e insira uma descrição.
1. (Opcional) Expanda **Opções adicionais** e conclua o seguinte, conforme necessário.
1. Na seção **Associar extensões**, selecione uma extensão na lista.
1. Na seção **Tags**, selecione **Adicionar nova tag** e especifique uma chave e um valor opcional.
1. Escolha **Próximo**.
1. Na página **Especificar dados de configuração**, na seção **Definição de configuração**, escolha uma opção.
1. Preencha os campos da opção que você selecionou, conforme descrito na tabela a seguir.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/appconfig/latest/userguide/appconfig-creating-free-form-configuration-and-profile-create-console.html)
1. Na seção **Função de serviço**, escolha **Nova função de serviço** para AWS AppConfig criar a função do IAM que fornece acesso aos dados de configuração. AWS AppConfig preenche automaticamente o campo **Nome da função** com base no nome que você inseriu anteriormente. Ou selecione **Perfil de serviço existente**. Escolha a função usando a lista **Role ARN (ARN de função)**.
1. Opcionalmente, na página **Adicionar validadores**, escolha **Esquema JSON** ou **AWS Lambda**. Se você escolher **JSON Schema (Esquema JSON)**, insira o esquema JSON no campo. Se você escolher **AWS Lambda**, escolha o nome de recurso da Amazon (ARN) da função e a versão na lista.
**Importante**
Os dados de configuração armazenados em documentos do SSM devem ser validados em relação a um esquema JSON associado antes que você possa adicionar a configuração ao sistema. Os parâmetros SSM não exigem um método de validação, mas recomendamos que você crie uma verificação de validação para configurações de parâmetros SSM novas ou atualizadas usando. AWS Lambda
1. Escolha **Próximo**.
1. Na página **Revisar e salvar**, selecione **Salve continue a implantação**.
**Importante**
Se você criou um perfil de configuração para AWS CodePipeline, deverá criar um pipeline CodePipeline que especifique AWS AppConfig como o *provedor de implantação*. Você não precisa executar [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md). No entanto, você deve configurar um cliente para receber atualizações de configuração do aplicativo conforme descrito em [Recuperando dados de configuração sem AWS AppConfig o Agente](about-data-plane.md). Para obter informações sobre a criação de um pipeline que especifica AWS AppConfig como provedor de implantação, consulte [Tutorial: Criar um pipeline usado AWS AppConfig como provedor de implantação](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-AppConfig.html) no *Guia do AWS CodePipeline usuário*.
Vá para [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md).
# Criação de um perfil AWS AppConfig de configuração de formato livre (linha de comando)
O procedimento a seguir descreve como usar o AWS CLI (no Linux ou no Windows) ou Ferramentas da AWS para PowerShell criar um perfil de configuração de AWS AppConfig formato livre. Se preferir, você pode usar AWS CloudShell para executar os comandos listados abaixo. Para obter mais informações, consulte [O que é o AWS CloudShell?](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) no * Guia do usuário do AWS CloudShell *.
**nota**
Para configurações de formato livre hospedadas no repositório de configurações AWS AppConfig hospedado, você especifica o `hosted` URI de localização.
**Para criar um perfil de configuração usando o AWS CLI**
1. Abra AWS CLI o.
1. Execute o comando a seguir para criar um perfil de configuração de formato livre.
------
#### [ Linux ]
```
aws appconfig create-configuration-profile \
--application-id APPLICATION_ID \
--name NAME \
--description CONFIGURATION_PROFILE_DESCRIPTION \
--location-uri CONFIGURATION_URI or hosted \
--retrieval-role-arn IAM_ROLE_ARN \
--tags TAGS \
--validators "Content=SCHEMA_CONTENT or LAMBDA_FUNCTION_ARN,Type=JSON_SCHEMA or LAMBDA"
```
------
#### [ Windows ]
```
aws appconfig create-configuration-profile ^
--application-id APPLICATION_ID ^
--name NAME ^
--description CONFIGURATION_PROFILE_DESCRIPTION ^
--location-uri CONFIGURATION_URI or hosted ^
--retrieval-role-arn IAM_ROLE_ARN ^
--tags TAGS ^
--validators "Content=SCHEMA_CONTENT or LAMBDA_FUNCTION_ARN,Type=JSON_SCHEMA or LAMBDA"
```
------
#### [ PowerShell ]
```
New-APPCConfigurationProfile `
-Name NAME `
-ApplicationId APPLICATION_ID `
-Description CONFIGURATION_PROFILE_DESCRIPTION `
-LocationUri CONFIGURATION_URI or hosted `
-RetrievalRoleArn IAM_ROLE_ARN `
-Tag TAGS `
-Validators "Content=SCHEMA_CONTENT or LAMBDA_FUNCTION_ARN,Type=JSON_SCHEMA or LAMBDA"
```
------
**Importante**
Observe as seguintes informações importantes:
Se você criou um perfil de configuração para AWS CodePipeline, deverá criar um pipeline CodePipeline que especifique AWS AppConfig como o *provedor de implantação*. Você não precisa executar [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md). No entanto, você deve configurar um cliente para receber atualizações de configuração do aplicativo conforme descrito em [Recuperando dados de configuração sem AWS AppConfig o Agente](about-data-plane.md). Para obter informações sobre a criação de um pipeline que especifica AWS AppConfig como provedor de implantação, consulte [Tutorial: Criar um pipeline usado AWS AppConfig como provedor de implantação](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-AppConfig.html) no *Guia do AWS CodePipeline usuário*.
Se você criou uma configuração no armazenamento de configuração AWS AppConfig hospedado, poderá criar novas versões da configuração usando as operações da [CreateHostedConfigurationVersion](https://docs.aws.amazon.com//appconfig/2019-10-09/APIReference/API_CreateHostedConfigurationVersion.html)API. Para ver AWS CLI detalhes e exemplos de comandos dessa operação de API, consulte [create-hosted-configuration-version](https://docs.aws.amazon.com/cli/latest/reference/appconfig/create-hosted-configuration-version.html)na *Referência de AWS CLI comandos*.
Vá para [Implantando sinalizadores de recursos e dados de configuração no AWS AppConfig](deploying-feature-flags.md).
# Criar um perfil de configuração para fontes de dados não nativas
AWS AppConfig suporta a implantação de dados de configuração da maioria dos armazenamentos de dados. Nativamente, o AWS AppConfig oferece suporte à implantação de dados de configuração armazenados nos seguintes serviços:
+ O armazenamento de configuração AWS AppConfig hospedado
+ Amazon S3
+ AWS Secrets Manager
+ AWS Systems Manager Armazenamento de parâmetros
+ Systems Manager Document Store
+ AWS CodePipeline
Se seus dados de configuração estiverem armazenados em um local sem suporte nativo AWS AppConfig, você poderá criar uma [AWS AppConfig extensão](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions.html) para recuperar os dados da fonte. Por exemplo, usando uma AWS AppConfig extensão, você pode recuperar dados de configuração armazenados no Amazon Relational Database Service (Amazon RDS), no Amazon DynamoDB (DynamoDB GitHub) GitLab,,, ou em um repositório local, para citar alguns. Ao implementar uma extensão, você pode aproveitar a AWS AppConfig segurança e DevOps os aprimoramentos de seus aplicativos e ambiente de computação. Você também pode usar esse método ao migrar dados de configuração de sistemas legados para o AWS AppConfig.
A criação de um perfil de configuração para fontes de dados sem suporte nativo no AWS AppConfig envolve os seguintes processos ou ações:
1. Crie uma [AWS Lambda função](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) que busque dados da sua fonte de dados. Desde que uma função Lambda possa acessar a fonte de dados, sua AWS AppConfig extensão poderá recuperar os dados.
1. Crie uma AWS AppConfig extensão personalizada que invoque sua função Lambda. Para obter mais informações, consulte [Passo a passo: Criação de extensões personalizadas AWS AppConfig](working-with-appconfig-extensions-creating-custom.md).
1. Crie um perfil de configuração AWS AppConfig de formato livre. Especificamente, crie um perfil de configuração que use a definição de **configuração hospedada do AWS AppConfig **. O perfil de configuração funciona como um armazenamento de dados temporário depois que a função do Lambda recupera a configuração da sua fonte. Seu aplicativo recuperará os dados de configuração do armazenamento de configuração AWS AppConfig hospedado. Para obter mais informações, consulte [Criando um perfil de configuração de formato livre no AWS AppConfig](appconfig-free-form-configurations-creating.md).
1. Crie uma associação de extensão que seja acionada usando o ponto de ação do `PRE_CREATE_HOSTED_CONFIGURATION_VERSION`. Para obter mais informações, consulte [Etapa 4: criar uma associação de extensão para uma AWS AppConfig extensão personalizada](working-with-appconfig-extensions-creating-custom-association.md).
Após a configuração, quando o aplicativo solicita uma nova versão dos dados de configuração, o Lambda busca esses dados e os insere no perfil de configuração. Em seguida, o AWS AppConfig salva o perfil de configuração e seus dados de terceiros.
Quando estiver pronto, você poderá implantar o perfil de configuração nos seus aplicativos, assim como qualquer outro tipo de dado de configuração.
**nota**
Você pode optar por inserir dados de terceiros de acordo com os dados de configuração existentes ou fazer com que todo o conteúdo dos dados de configuração contenha somente os dados de terceiros. Se você quiser alinhar os dados com outros dados existentes, essa lógica deverá fazer parte da função do Lambda que importa os dados da fonte de terceiros.
## Migração AWS AppConfig de serviços de configuração antigos e internos
Se você começou a usar AWS AppConfig e ainda tem dados de configuração legados ou sinalizadores de recursos em outro sistema, você pode usar o processo descrito anteriormente neste tópico para migrar do seu sistema legado para dentro. AWS AppConfig Você pode criar uma extensão que extrai dados do seu sistema antigo e os implanta por meio dele. AWS AppConfig O uso dessa AWS AppConfig forma fornece todos os controles e benefícios da proteção de segurança enquanto ainda usa seus armazenamentos de dados antigos.