

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á.

# Passo a passo: Criação de extensões personalizadas AWS AppConfig
<a name="working-with-appconfig-extensions-creating-custom"></a>

Para criar uma AWS AppConfig extensão personalizada, conclua as tarefas a seguir. Cada tarefa é descrita em mais detalhes nos tópicos mais adiante.

**nota**  
Você pode ver exemplos de AWS AppConfig extensões personalizadas em GitHub:  
[Extensão de exemplo que impede implantações com um calendário de moratória `blocked day` usando o calendário de alterações do Systems Manager](https://github.com/aws-samples/aws-appconfig-change-calendar-extn)
[Extensão de exemplo que impede o vazamento de segredos em dados de configuração usando a ferramenta git-secrets](https://github.com/aws-samples/aws-appconfig-git-secrets-extn)
[Extensão de exemplo que impede o vazamento de informações de identificação pessoal (PII) em dados de configuração usando o Amazon Comprehend](https://github.com/aws-samples/aws-appconfig-pii-extn)

**1. [Crie uma AWS Lambda função](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-creating-custom-lambda.html)**  
Para a maioria dos casos de uso, para criar uma extensão personalizada, você deve criar uma AWS Lambda função para realizar qualquer computação e processamento definidos na extensão. Uma exceção a essa regra é se você criar versões *personalizadas* das [extensões de notificação criadas pela AWS](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-about-predefined.html) para adicionar ou remover pontos de ação. Para obter mais detalhes sobre esta exceção, consulte [Etapa 3: criar uma AWS AppConfig extensão personalizada](working-with-appconfig-extensions-creating-custom-extensions.md).

**2. [Configure permissões para sua extensão personalizada](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-creating-custom-permissions.html)**  
Para configurar permissões para sua extensão personalizada, você pode realizar um dos seguintes procedimentos:  
+ Crie uma função de serviço AWS Identity and Access Management (IAM) que inclua `InvokeFunction` permissões. 
+ Crie uma política de recursos usando a ação da [AddPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html)API Lambda.
Este passo a passo descreve como criar o perfil de serviço do IAM.

**3. [Crie uma extensão](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-creating-custom-extensions.html)**  
Você pode criar uma extensão usando o AWS AppConfig console ou chamando a ação da [CreateExtension](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_CreateExtension.html)API do AWS CLI, Ferramentas da AWS para PowerShell, ou do SDK. O passo a passo usa o console.

**4. [Crie uma associação de extensão](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-creating-custom-association.html)**  
Você pode criar uma associação de extensão usando o AWS AppConfig console ou chamando a ação da [CreateExtensionAssociation](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_CreateExtensionAssociation.html)API do AWS CLI, Ferramentas da AWS para PowerShell, ou do SDK. O passo a passo usa o console.

**5. Execute uma ação que invoque a extensão**  
Depois de criar a associação, AWS AppConfig invoca a extensão quando os pontos de ação definidos pela extensão ocorrerem para esse recurso. Por exemplo, se você associar uma extensão que contém uma ação `PRE_CREATE_HOSTED_CONFIGURATION_VERSION`, a extensão será invocada toda vez que você criar uma nova versão de configuração hospedada.

Os tópicos nesta seção descrevem cada tarefa envolvida na criação de uma extensão do AWS AppConfig personalizada. Cada tarefa é descrita no contexto de um caso de uso em que o cliente deseja criar uma extensão que faz backup automático de uma configuração em um bucket do Amazon Simple Storage Service (Amazon S3). A extensão é executada sempre que uma configuração hospedada é criada (`PRE_CREATE_HOSTED_CONFIGURATION_VERSION`) ou implantada (`PRE_START_DEPLOYMENT`).

**Topics**
+ [

# Etapa 1: criar uma função Lambda para uma extensão personalizada AWS AppConfig
](working-with-appconfig-extensions-creating-custom-lambda.md)
+ [

# Etapa 2: configurar permissões para uma AWS AppConfig extensão personalizada
](working-with-appconfig-extensions-creating-custom-permissions.md)
+ [

# Etapa 3: criar uma AWS AppConfig extensão personalizada
](working-with-appconfig-extensions-creating-custom-extensions.md)
+ [

# Etapa 4: criar uma associação de extensão para uma AWS AppConfig extensão personalizada
](working-with-appconfig-extensions-creating-custom-association.md)

# Etapa 1: criar uma função Lambda para uma extensão personalizada AWS AppConfig
<a name="working-with-appconfig-extensions-creating-custom-lambda"></a>

Para a maioria dos casos de uso, para criar uma extensão personalizada, você deve criar uma AWS Lambda função para realizar qualquer computação e processamento definidos na extensão. Esta seção inclui um exemplo de código da função Lambda para uma extensão personalizada AWS AppConfig . Esta seção inclui também detalhes de referência de solicitações e respostas de carga útil. Para obter mais informações sobre como criar uma função do Lambda, consulte a seção [Conceitos básicos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) no *Guia do desenvolvedor do AWS Lambda *.

## Código de exemplo
<a name="working-with-appconfig-extensions-creating-custom-lambda-code-sample"></a>

O código de exemplo a seguir para uma função Lambda, quando invocado, faz backup automático de uma AWS AppConfig configuração em um bucket do Amazon S3. O backup da configuração é feito sempre que uma nova configuração é criada ou implantada. O exemplo usa parâmetros de extensão para que o nome do bucket não precise ser codificado na função do Lambda. Usando parâmetros de extensão, o usuário pode anexar a extensão a vários aplicativos e fazer backup das configurações em diferentes buckets. O exemplo de código inclui comentários para explicar melhor a função.

**Exemplo de função Lambda para uma extensão AWS AppConfig **

```
from datetime import datetime
import base64
import json

import boto3


def lambda_handler(event, context):
    print(event)
    
    # Extensions that use the PRE_CREATE_HOSTED_CONFIGURATION_VERSION and PRE_START_DEPLOYMENT 
    # action points receive the contents of AWS AppConfig configurations in Lambda event parameters.
    # Configuration contents are received as a base64-encoded string, which the lambda needs to decode 
    # in order to get the configuration data as bytes. For other action points, the content 
    # of the configuration isn't present, so the code below will fail.
    config_data_bytes = base64.b64decode(event["Content"])
    
    # You can specify parameters for extensions. The CreateExtension API action lets you define  
    # which parameters an extension supports. You supply the values for those parameters when you 
    # create an extension association by calling the CreateExtensionAssociation API action.
    # The following code uses a parameter called S3_BUCKET to obtain the value specified in the 
    # extension association. You can specify this parameter when you create the extension 
    # later in this walkthrough.
    extension_association_params = event.get('Parameters', {})
    bucket_name = extension_association_params['S3_BUCKET']
    write_backup_to_s3(bucket_name, config_data_bytes)
    
    # The PRE_CREATE_HOSTED_CONFIGURATION_VERSION and PRE_START_DEPLOYMENT action points can 
    # modify the contents of a configuration. The following code makes a minor change 
    # for the purposes of a demonstration.
    old_config_data_string = config_data_bytes.decode('utf-8')
    new_config_data_string = old_config_data_string.replace('hello', 'hello!')
    new_config_data_bytes = new_config_data_string.encode('utf-8')
    
    # The lambda initially received the configuration data as a base64-encoded string 
    # and must return it in the same format.
    new_config_data_base64string = base64.b64encode(new_config_data_bytes).decode('ascii')
    
    return {
        'statusCode': 200,
        # If you want to modify the contents of the configuration, you must include the new contents in the 
        # Lambda response. If you don't want to modify the contents, you can omit the 'Content' field shown here.
        'Content': new_config_data_base64string
    }


def write_backup_to_s3(bucket_name, config_data_bytes):
    s3 = boto3.resource('s3')
    new_object = s3.Object(bucket_name, f"config_backup_{datetime.now().isoformat()}.txt")
    new_object.put(Body=config_data_bytes)
```

Se você desejar usar esse exemplo durante este passo a passo, salve-o com o nome **MyS3ConfigurationBackUpExtension** e copie o nome do recurso da Amazon (ARN) da função. Você especifica o ARN ao criar a função de assumir AWS Identity and Access Management (IAM) na próxima seção. Você especifica o ARN e o nome ao criar a extensão.

## Referência de carga útil
<a name="working-with-appconfig-extensions-creating-custom-lambda-payload"></a>

Esta seção inclui detalhes de referência de solicitação e resposta de carga útil para trabalhar com AWS AppConfig extensões personalizadas.

**Estrutura de solicitações**  
*AtDeploymentTick*

```
{
    'InvocationId': 'o2xbtm7',
    'Parameters': {
        'ParameterOne': 'ValueOne',
        'ParameterTwo': 'ValueTwo'
    },
    'Type': 'OnDeploymentStart',
    'Application': {
        'Id': 'abcd123'
    },
    'Environment': {
        'Id': 'efgh456'
    },
    'ConfigurationProfile': {
        'Id': 'ijkl789',
        'Name': 'ConfigurationName'
    },
    'DeploymentNumber': 2,
    'Description': 'Deployment description',
    'ConfigurationVersion': '2',
    'DeploymentState': 'DEPLOYING',
    'PercentageComplete': '0.0'
}
```

**Estrutura de solicitações**  
*PreCreateHostedConfigurationVersion*

```
{
    'InvocationId': 'vlns753', // id for specific invocation
    'Parameters': {
        'ParameterOne': 'ValueOne',
        'ParameterTwo': 'ValueTwo'
    },
    'ContentType': 'text/plain',
    'ContentVersion': '2',
    'Content': 'SGVsbG8gZWFydGgh', // Base64 encoded content
    'Application': {
        'Id': 'abcd123',
        'Name': 'ApplicationName'
    },
    'ConfigurationProfile': {
        'Id': 'ijkl789',
        'Name': 'ConfigurationName'
    },
    'Description': '',
    'Type': 'PreCreateHostedConfigurationVersion',
    'PreviousContent': {
        'ContentType': 'text/plain',
        'ContentVersion': '1',
        'Content': 'SGVsbG8gd29ybGQh'
    }
}
```

*PreStartDeployment*

```
{
    'InvocationId': '765ahdm',
    'Parameters': {
        'ParameterOne': 'ValueOne',
        'ParameterTwo': 'ValueTwo'
    },
    'ContentType': 'text/plain',
    'ContentVersion': '2',
    'Content': 'SGVsbG8gZWFydGgh',
    'Application': {
        'Id': 'abcd123',
        'Name': 'ApplicationName'
    },
    'Environment': {
        'Id': 'ibpnqlq',
        'Name': 'EnvironmentName'
    },
    'ConfigurationProfile': {
        'Id': 'ijkl789',
        'Name': 'ConfigurationName'
    },
    'DeploymentNumber': 2,
    'Description': 'Deployment description',
    'Type': 'PreStartDeployment'
}
```

**Eventos assíncronos**  


*OnStartDeployment, OnDeploymentStep, OnDeployment*

```
{
    'InvocationId': 'o2xbtm7',
    'Parameters': {
        'ParameterOne': 'ValueOne',
        'ParameterTwo': 'ValueTwo'
    },
    'Type': 'OnDeploymentStart',
    'Application': {
        'Id': 'abcd123'
    },
    'Environment': {
        'Id': 'efgh456'
    },
    'ConfigurationProfile': {
        'Id': 'ijkl789',
        'Name': 'ConfigurationName'
    },
    'DeploymentNumber': 2,
    'Description': 'Deployment description',
    'ConfigurationVersion': '2'
}
```

**Estrutura de respostas**  
Os exemplos a seguir mostram o que sua função Lambda retorna em resposta à solicitação de uma extensão personalizada AWS AppConfig .

*Eventos síncronos PRE\$1\$1: resposta bem-sucedida*

Se você deseja transformar o conteúdo, use o seguinte:

```
"Content": "SomeBase64EncodedByteArray"
```

*Eventos síncronos AT\$1\$1: resposta bem-sucedida*

Se você quiser controlar as próximas etapas de uma implantação (continuar uma implantação ou revertê-la), defina os atributos `Directive` e `Description` na resposta. 

```
"Directive": "ROLL_BACK"
"Description" "Deployment event log description"
```

A `Directive` oferece suporte a dois valores: `CONTINUE` ou `ROLL_BACK`. Use esses enums na sua resposta de carga útil para controlar as próximas etapas de uma implantação.

*Eventos síncronos: resposta bem-sucedida*

Se você deseja transformar o conteúdo, use o seguinte:

```
"Content": "SomeBase64EncodedByteArray"
```

Se você não deseja transformar o conteúdo, não retorne nada.

*Eventos assíncronos: resposta bem-sucedida*

Não retorne nada.

*Todos os eventos de erro*

```
{
        "Error": "BadRequestError",
        "Message": "There was malformed stuff in here",
        "Details": [{
            "Type": "Malformed",
            "Name": "S3 pointer",
            "Reason": "S3 bucket did not exist"
        }]
    }
```

# Etapa 2: configurar permissões para uma AWS AppConfig extensão personalizada
<a name="working-with-appconfig-extensions-creating-custom-permissions"></a>

Use o procedimento a seguir para criar e configurar uma função de serviço AWS Identity and Access Management (IAM) (ou *assumir uma função*). AWS AppConfig usa essa função para invocar a função Lambda.

**Para criar uma função de serviço do IAM e AWS AppConfig permitir assumi-la**

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. Em **Selecionar tipo de entidade confiável**, escolha **Política de confiança personalizada**.

1. Cole a política JSON a seguir no campo **Política de confiança personalizada**.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "appconfig.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

   Escolha **Próximo**.

1. Na página **Adicionar permissões**, escolha **Criar política**. A página **Create policy (Criar política)** é aberta em uma nova guia.

1. Escolha a guia **JSON** e cole a política personalizada a seguir no editor. A ação `lambda:InvokeFunction` é usada para pontos de ação `PRE_*`. A ação `lambda:InvokeAsync` é usada para pontos de ação `ON_*`. *Your Lambda ARN*Substitua pelo Amazon Resource Name (ARN) do seu Lambda.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "VisualEditor0",
         "Effect": "Allow",
         "Action": [
           "lambda:InvokeFunction",
           "lambda:InvokeAsync"
         ],
         "Resource": "arn:aws:lambda:us-east-1:111122223333:function:function-name"
       }
     ]
   }
   ```

------

1. Escolha **Próximo: tags**.

1. Na página **Adicionar tags (opcional)**, adicione um ou mais pares chave-valor e escolha **Próximo: revisão**.

1. Na página **Revisar política**, insira um nome e uma descrição e, depois, escolha **Criar política**.

1. Na guia do navegador da sua política de confiança personalizada, escolha o ícone Atualizar e pesquise a política de permissões que você acabou de criar.

1. Marque a caixa de seleção da política de permissões e escolha **Próximo**.

1. Na página **Nomear, revisar e criar**, insira um nome na caixa **Nome do perfil** e, em seguida, insira uma descrição.

1. Selecione **Create role** (Criar função). O sistema faz com que você retorne para a página **Roles**. Escolha **Exibir perfil** no banner.

1. Copie o ARN. Você especifica esse ARN ao criar a extensão.

# Etapa 3: criar uma AWS AppConfig extensão personalizada
<a name="working-with-appconfig-extensions-creating-custom-extensions"></a>



Uma extensão define uma ou mais ações que ela executa durante um AWS AppConfig fluxo de trabalho. Por exemplo, a `AWS AppConfig deployment events to Amazon SNS` extensão AWS criada inclui uma ação para enviar uma notificação para um tópico do Amazon SNS. Cada ação é invocada quando você interage com AWS AppConfig ou quando AWS AppConfig está executando um processo em seu nome. Eles são chamados de *pontos de ação*. AWS AppConfig as extensões suportam os seguintes pontos de ação:

**Pontos de ação PRE\$1\$1**: as ações de extensão configuradas em pontos de ação `PRE_*` são aplicadas após a validação da solicitação, mas antes de o AWS AppConfig realizar a atividade que corresponde ao nome do ponto de ação. Essas invocações de ação são processadas ao mesmo tempo da solicitação. Se mais de uma solicitação for feita, as invocações de ação serão executadas sequencialmente. Observe também que os pontos de ação `PRE_*` recebem e podem alterar o conteúdo de uma configuração. Os pontos de ação `PRE_*` também podem responder a um erro e impedir que uma ação aconteça. 
+ `PRE_CREATE_HOSTED_CONFIGURATION_VERSION`
+ `PRE_START_DEPLOYMENT`

**Pontos de ação ON\$1\$1**: uma extensão também pode ser executada paralelamente a um AWS AppConfig fluxo de trabalho usando um ponto de `ON_*` ação. `ON_*`os pontos de ação são invocados de forma assíncrona. `ON_*`os pontos de ação não recebem o conteúdo de uma configuração. Se uma extensão apresentar um erro durante um ponto de ação `ON_*`, o serviço ignorará o erro e continuará o fluxo de trabalho.
+ `ON_DEPLOYMENT_START`
+ `ON_DEPLOYMENT_STEP`
+ `ON_DEPLOYMENT_BAKING`
+ `ON_DEPLOYMENT_COMPLETE`
+ `ON_DEPLOYMENT_ROLLED_BACK`

**Pontos de ação AT\$1\$1**: as ações de extensão configuradas nos pontos de ação `AT_*` são invocadas de maneira síncrona e em paralelo com um fluxo de trabalho do AWS AppConfig . Se uma extensão apresentar um erro durante um ponto de ação `AT_*`, o serviço interromperá o fluxo de trabalho e reverterá a implantação.
+ `AT_DEPLOYMENT_TICK`

O ponto de ação `AT_DEPLOYMENT_TICK` oferece suporte à integração de monitoramento de terceiros. `AT_DEPLOYMENT_TICK` é invocado durante a orquestração do processamento da implantação da configuração. Se você usa uma solução de monitoramento de terceiros (por exemplo, Datadog ou New Relic), você pode criar uma AWS AppConfig extensão que verifica os alarmes no ponto de `AT_DEPLOYMENT_TICK` ação e, como proteção de segurança, reverte a implantação se ela acionar um alarme. 

Se você usa uma solução de monitoramento de terceiros, como Datadog ou New Relic, pode criar uma AWS AppConfig extensão que verifica os alarmes no ponto de `AT_DEPLOYMENT_TICK` ação e, como proteção de segurança, reverte a implantação se ela acionar um alarme. Para obter mais informações, consulte os seguintes exemplos de integração entre Datadog e New Relic em: GitHub 
+ [Datadog](https://github.com/aws-samples/aws-appconfig-tick-extn-for-datadog)
+ [New Relic](https://github.com/aws-samples/sample-aws-appconfig-tick-extn-for-newrelic)

Para obter mais informações sobre AWS AppConfig extensões, consulte os tópicos a seguir:
+ [Estendendo AWS AppConfig fluxos de trabalho usando extensões](working-with-appconfig-extensions.md)
+ [Passo a passo: Criação de extensões personalizadas AWS AppConfig](working-with-appconfig-extensions-creating-custom.md)

**Exemplo de extensão do**  
O exemplo de extensão a seguir define uma ação que chama o ponto de ação `PRE_CREATE_HOSTED_CONFIGURATION_VERSION`. No campo `Uri`, a ação especifica o nome do recurso da Amazon (ARN) da função do Lambda `MyS3ConfigurationBackUpExtension` criada anteriormente neste passo a passo. A ação também especifica o ARN de função de assumir AWS Identity and Access Management (IAM) criado anteriormente nesta explicação passo a passo.

** AWS AppConfig Extensão de amostra**

```
{
    "Name": "MySampleExtension",
    "Description": "A sample extension that backs up configurations to an S3 bucket.",
    "Actions": {
        "PRE_CREATE_HOSTED_CONFIGURATION_VERSION": [
            {
                "Name": "PreCreateHostedConfigVersionActionForS3Backup",
                "Uri": "arn:aws:lambda:aws-region:111122223333:function:MyS3ConfigurationBackUpExtension",
                "RoleArn": "arn:aws:iam::111122223333:role/ExtensionsTestRole"
            }
        ]
    },
    "Parameters" : {
        "S3_BUCKET": {
            "Required": false
        }
    }
}
```

**nota**  
Para ver a sintaxe da solicitação e as descrições dos campos ao criar uma extensão, consulte o [CreateExtension](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_CreateExtension.html)tópico na *Referência da AWS AppConfig API*.

**Para criar uma extensão (console)**

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 **AWS AppConfig**.

1. Na guia **Extensões**, escolha **Criar extensão**.

1. Em **Nome da extensão**, insira um nome exclusivo. Para a finalidade deste passo a passo, insira **MyS3ConfigurationBackUpExtension**. Como opção, insira uma descrição.

1. Na seção **Ações**, selecione **Adicionar nova ação**.

1. Em **Nome da ação**, insira um nome exclusivo. Para a finalidade deste passo a passo, insira **PreCreateHostedConfigVersionActionForS3Backup**. Esse nome descreve o ponto de ação usado pela ação e a finalidade da extensão.

1. Na lista **Ponto de ação**, escolha **PRE\$1CREATE\$1HOSTED\$1CONFIGURATION\$1VERSION**.

1. Para **Uri**, escolha **Função do Lambda** e, em seguida, escolha a função na lista **Função do Lambda**. Se você não vê sua função, verifique se você está no mesmo Região da AWS local em que criou a função.

1. Para **Perfil do IAM**, escolha o perfil que você criou anteriormente neste passo a passo.

1. Na seção **Parâmetros de extensão (opcional)**, escolha **Adicionar novo parâmetro**. 

1. Em **Nome do parâmetro**, insira um nome. Para a finalidade deste passo a passo, insira **S3\$1BUCKET**.

1. Repita as etapas de 5 a 11 para criar uma segunda ação para o ponto de ação `PRE_START_DEPLOYMENT`.

1. Escolha **Criar extensão**.

# Personalização de extensões AWS de notificação criadas
<a name="working-with-appconfig-extensions-creating-custom-notification"></a>

Não é necessário criar um Lambda ou uma extensão para usar [extensões de notificação criadas pela AWS](https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-about-predefined.html). Basta criar uma associação de extensão e, em seguida, realizar uma operação que chame um dos pontos de ação suportados. Por padrão, as extensões AWS de notificação criadas oferecem suporte aos seguintes pontos de ação: 
+ `ON_DEPLOYMENT_START`
+ `ON_DEPLOYMENT_COMPLETE`
+ `ON_DEPLOYMENT_ROLLED_BACK`

Se criar versões personalizadas da extensão `AWS AppConfig deployment events to Amazon SNS` e das extensões `AWS AppConfig deployment events to Amazon SQS`, você poderá especificar os pontos de ação para os quais deseja receber notificações. 

**nota**  
A extensão `AWS AppConfig deployment events to EventBridge` não suporta os pontos de ação `PRE_*`. Você pode criar uma versão personalizada se quiser remover alguns dos pontos de ação padrão atribuídos à AWS versão criada.

Você não precisa criar nenhuma função do Lambda se criar versões personalizadas das extensões de notificação criadas pela AWS . Você só precisa especificar um nome do recurso da Amazon (ARN) no campo `Uri` para a nova versão da extensão.
+ Para uma extensão de EventBridge notificação personalizada, insira o ARN dos eventos EventBridge padrão no `Uri` campo.
+ Para uma extensão de notificação personalizada do Amazon SNS, insira o ARN de um tópico do Amazon SNS no campo `Uri`.
+ Para uma extensão de notificação personalizada do Amazon SQS, insira o ARN de uma fila de mensagens do Amazon SQS no campo `Uri`.

# Etapa 4: criar uma associação de extensão para uma AWS AppConfig extensão personalizada
<a name="working-with-appconfig-extensions-creating-custom-association"></a>

Para criar uma extensão ou configurar uma extensão de AWS autoria, você define os pontos de ação que invocam uma extensão quando um AWS AppConfig recurso específico é usado. Por exemplo, você pode optar por executar a extensão `AWS AppConfig deployment events to Amazon SNS` e receber notificações sobre um tópico do Amazon SNS sempre que uma implantação de configuração for iniciada para um aplicativo específico. Definir quais pontos de ação invocam uma extensão para um AWS AppConfig recurso específico é chamado de *associação de extensão*. Uma associação de extensão é uma relação especificada entre uma extensão e um AWS AppConfig recurso, como um aplicativo ou um perfil de configuração.

Um único AWS AppConfig aplicativo pode incluir vários ambientes e perfis de configuração. Se você associar uma extensão a um aplicativo ou ambiente, AWS AppConfig invoca a extensão para qualquer fluxo de trabalho relacionado ao aplicativo ou aos recursos do ambiente, se aplicável.

Por exemplo, digamos que você tenha um AWS AppConfig aplicativo chamado MobileApps que inclui um perfil de configuração chamado AccessList. E digamos que o MobileApps aplicativo inclua ambientes beta, de integração e de produção. Você cria uma associação de extensão para a extensão AWS de notificação criada pelo Amazon SNS e associa a extensão ao aplicativo. MobileApps A extensão de notificação do Amazon SNS é invocada sempre que a configuração é implantada para o aplicativo em qualquer um dos três ambientes. 

Use os procedimentos a seguir para criar uma associação de AWS AppConfig extensão usando o AWS AppConfig console.

**Para criar uma associação de extensão (console)**

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 **AWS AppConfig**.

1. Na guia **Extensões**, escolha um botão de opção para uma extensão e escolha **Adicionar ao recurso**. **Para fins deste passo a passo, escolha MyS3. ConfigurationBackUpExtension**

1. Na seção **Detalhes do recurso de extensão**, em **Tipo de recurso**, escolha um tipo de AWS AppConfig recurso. Dependendo do recurso escolhido, AWS AppConfig solicita que você escolha outros recursos. Para a finalidade deste passo a passo, escolha **Aplicativo**.

1. Selecione um aplicativo na lista.

1. Na seção **Parâmetros**, verifique se **S3\$1BUCKET** está listado no campo **Chave**. No campo **Valor**, cole o ARN das extensões do Lambda. Por exemplo: `arn:aws:lambda:aws-region:111122223333:function:MyS3ConfigurationBackUpExtension`.

1. Escolha **Criar associação ao recurso**.

Depois de criar a associação, você pode invocar a extensão `MyS3ConfigurationBackUpExtension` criando um novo perfil de configuração que especifique `hosted` para seu `SourceUri`. Como parte do fluxo de trabalho para criar a nova configuração, AWS AppConfig encontra o ponto de `PRE_CREATE_HOSTED_CONFIGURATION_VERSION` ação. O encontro desse ponto de ação invoca a extensão `MyS3ConfigurationBackUpExtension`, que faz backup automático da configuração recém-criada no bucket do S3 especificado na seção `Parameter` da associação da extensão.