

Este é o novo *Guia de referência de modelos do CloudFormation*. Atualize seus favoritos e links. Para obter ajuda para começar a usar o CloudFormation, consulte o [Guia do usuário do AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

# cfn-signal
<a name="cfn-signal"></a>

O script auxiliar `cfn-signal` sinaliza o CloudFormation para indicar se as instâncias do Amazon EC2 foram criadas ou atualizadas com êxito. Se você instalar e configurar os aplicativos de software em instâncias, é possível sinalizar para o CloudFormation quando esses aplicativos de software estiverem prontos.

Você usa o script `cfn-signal` em conjunto com um [Atributo `CreationPolicy`](aws-attribute-creationpolicy.md) ou um [`UpdatePolicy`Atributo](aws-attribute-updatepolicy.md) com `WaitOnResourceSignals` para grupos do Amazon EC2 Auto Scaling. Quando o CloudFormation cria ou atualiza recursos com essas políticas, ele suspende o trabalho na pilha até que o recurso receba o número de sinais exigidos ou até que o tempo limite seja excedido. Para cada sinal válido que o CloudFormation recebe, ele publica os sinais para os eventos da pilha de modo que você possa acompanhar cada sinal.

**Topics**
+ [Sintaxe para a sinalização de recursos (recomendado)](#w2aac32c29b9)
+ [Sintaxe para uso com processamento de condição de espera](#cfn-signal-Syntaxwaitcondition)
+ [Opções](#cfn-signal-options)
+ [Exemplos](#cfn-signal-examples)
+ [Recursos relacionados](#cfn-signal-related-resources)

## Sintaxe para a sinalização de recursos (recomendado)
<a name="w2aac32c29b9"></a>

Se você deseja sinalizar os recursos do CloudFormation, use a sintaxe a seguir.

```
cfn-signal --success|-s signal.to.send \
        --access-key access.key \
        --credential-file|-f credential.file \
        --exit-code|-e exit.code \
        --http-proxy HTTP.proxy \
        --https-proxy HTTPS.proxy \
        --id|-i unique.id \
        --region AWS.region \
        --resource resource.logical.ID \
        --role IAM.role.name \
        --secret-key secret.key \
        --stack stack.name.or.stack.ID \
        --url CloudFormation.endpoint
```

**nota**  
`cfn-signal` não exige credenciais; portanto, você não precisa usar as opções `--access-key`, `--secret-key`, `--role` ou `--credential-file`. No entanto, se nenhuma credencial for especificada, o CloudFormation verificará se há associação de pilha e limitará o escopo da chamada para a pilha à qual a instância pertence. Para obter mais informações, consulte [Permissões para scripts auxiliares](cfn-helper-scripts-reference.md#cfn-helper-scripts-reference-permissions).

## Sintaxe para uso com processamento de condição de espera
<a name="cfn-signal-Syntaxwaitcondition"></a>

Se você deseja sinalizar um processamento de condição de espera, use a seguinte sintaxe.

```
cfn-signal --success|-s signal.to.send \
        --reason|-r resource.status.reason \
        --data|-d data \
        --id|-i unique.id \
        --exit-code|-e exit.code \
        waitconditionhandle.url
```

## Opções
<a name="cfn-signal-options"></a>

As opções que você pode usar dependem se você está sinalizando uma política de criação ou um processamento de condição de espera. Algumas opções que se aplicam a uma política de criação podem não se aplicar a um processamento de condição de espera.


| Name (Nome) | Descrição | Obrigatório | 
| --- | --- | --- | 
|  `--access-key` (apenas sinalização de recursos)  |  A chave de acesso da AWS para uma conta com permissão para chamar a `SignalResource `API do CloudFormation. O parâmetro do arquivo de credencial substitui este parâmetro. *Tipo:* string  |  Não  | 
|  `-d, --data` (processamento de condição de espera apenas)  |  Dados para enviar de volta com o `waitConditionHandle`. O padrão é branco. *Tipo:* string *Padrão*: branco  |  Não  | 
|  `-e, --exit-code`   |  O código de erro de um processo que pode ser usado para determinar o sucesso ou falha. Se especificado, a opção `--success` será ignorada. *Tipo:* string *Exemplos*: `-e $?` (para Linux), `-e %ERRORLEVEL%` (para Windows cmd.exe) e `-e $lastexitcode` (para Windows PowerShell).  |  Não  | 
|  `-f, --credential-file` (apenas sinalização de recursos)  |  Um arquivo que contém uma chave de acesso secreta e uma chave de acesso. O parâmetro do arquivo de credencial substitui os parâmetros --role, --access-key e --secret-key. *Tipo:* string  |  Não  | 
|  `--http-proxy`  |  Um proxy HTTP (não SSL). Use o seguinte formato: `http://user:password@host:port`. *Tipo:* string  |  Não  | 
|  `--https-proxy`  |  Um proxy HTTPS. Use o seguinte formato: .: `https://user:password@host:port` *Tipo:* string  |  Não  | 
|  `-i, --id`  |  O ID exclusivo a ser enviado. *Tipo:* string *Default*: O ID da instância do Amazon EC2. Se o ID não pode ser resolvido, o nome de domínio totalmente qualificado (FQDN) da máquina é retornado.  |  Não  | 
|  `-r, --reason ` (processamento de condição de espera apenas)  |  Um motivo de status para o evento de recurso (atualmente usado apenas em falha) - padrão 'Configuração falhou' se o sucesso for falso. *Tipo:* string  |  Não  | 
| --region (apenas sinalização de recursos) |  O endpoint regional do CloudFormation a ser usado. *Tipo:* string *Padrão*: `us-east-1`  |  Não  | 
| --resource (apenas sinalização de recursos) |  A ID lógica do recurso que contém a política de criações que você deseja sinalizar. *Tipo:* string  |  Sim  | 
|  `--role` (apenas sinalização de recursos)  |  O nome de um perfil do IAM que está associado à instância. *Tipo:* string Condição: o parâmetro do arquivo de credencial substitui este parâmetro.  |  Não  | 
|  `-s, --success`   |  Se verdadeiro, sinal `SUCCESS`, senão `FAILURE`. *Tipo*: booliano *Padrão*: `true`  |  Não  | 
|  `--secret-key` (apenas sinalização de recursos)  |  A chave de acesso secreta da AWS que corresponde a uma chave de acesso específica da AWS. *Tipo:* string  |  Não  | 
|  `--stack` (apenas sinalização de recursos)  |  O nome da pilha ou ID da pilha que contém o recurso que você deseja sinalizar. *Tipo:* string  |  Sim  | 
| -u, --url (apenas sinalização de recursos) |  O endpoint do CloudFormation a ser usado. *Tipo:* string  |  Não  | 
|  `waitconditionhandle.url` (processamento de condição de espera apenas)  |  Um URL pré-assinado que você pode usar para sinalizar sucesso ou falha a uma `WaitCondition` associada *Tipo:* string  |  Sim  | 

## Exemplos
<a name="cfn-signal-examples"></a>

### Exemplo do Amazon Linux
<a name="w2aac32c29c15b3"></a>

Um padrão de utilização comum é utilizar `cfn-init` e `cfn-signal` juntos. A chamada de `cfn-signal` usa o status de retorno da chamada para `cfn-init` (usando o constructo \$1? shell). Se o aplicativo falhar ao instalar, a instância falhará para criar e a pilha reverterá.

#### JSON
<a name="cfn-signal-example.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Simple EC2 instance",
    "Resources": {
        "MyInstance": {
            "Type": "AWS::EC2::Instance",
            "Metadata": {
                "AWS::CloudFormation::Init": {
                    "config": {
                        "files": {
                            "/tmp/test.txt": {
                                "content": "Hello world!",
                                "mode": "000755",
                                "owner": "root",
                                "group": "root"
                            }
                        }
                    }
                }
            },
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
                "InstanceType": "t2.micro",
                "UserData": {
                    "Fn::Base64": {
                        "Fn::Join": [
                            "",
                            [
                                "#!/bin/bash -x\n",
                                "# Install the files and packages from the metadata\n",
                                "yum install -y aws-cfn-bootstrap",
                                "\n",
                                "/opt/aws/bin/cfn-init -v ",
                                "         --stack ",
                                {
                                    "Ref": "AWS::StackName"
                                },
                                "         --resource MyInstance ",
                                "         --region ",
                                {
                                    "Ref": "AWS::Region"
                                },
                                "\n",
                                "# Signal the status from cfn-init\n",
                                "/opt/aws/bin/cfn-signal -e $? ",
                                "         --stack ",
                                {
                                    "Ref": "AWS::StackName"
                                },
                                "         --resource MyInstance ",
                                "         --region ",
                                {
                                    "Ref": "AWS::Region"
                                },
                                "\n"
                            ]
                        ]
                    }
                }
            },
            "CreationPolicy": {
                "ResourceSignal": {
                    "Timeout": "PT5M"
                }
            }
        }
    }
}
```

#### YAML
<a name="cfn-signal-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: Simple EC2 instance
Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Metadata:
      'AWS::CloudFormation::Init':
        config:
          files:
            /tmp/test.txt:
              content: Hello world!
              mode: '000755'
              owner: root
              group: root
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      InstanceType: t2.micro
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -x
          # Install the files and packages from the metadata
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource MyInstance --region ${AWS::Region}
          # Signal the status from cfn-init
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource MyInstance --region ${AWS::Region}
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M
```

## Recursos relacionados
<a name="cfn-signal-related-resources"></a>

Você também pode visitar nosso repositório no GitHub para baixar [exemplos de modelo](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html#sample-templates) que usam `cfn-signal`, incluindo os que se seguem.
+  [InstanceWithCfnInit.yaml](https://github.com/aws-cloudformation/aws-cloudformation-templates/blob/main/EC2/InstanceWithCfnInit.yaml) 
+  [AutoScalingRollingUpdates.yaml](https://github.com/aws-cloudformation/aws-cloudformation-templates/blob/main/AutoScaling/AutoScalingRollingUpdates.yaml) 