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.<br />*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.<br />*Tipo:* string<br />*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.<br />*Tipo:* string<br />*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.<br />*Tipo:* string | Não | 
| `--http-proxy` | Um proxy HTTP (não SSL). Use o seguinte formato: `http://{{user:password}}@{{host}}:{{port}}`.<br />*Tipo:* string | Não | 
| `--https-proxy` | Um proxy HTTPS. Use o seguinte formato: .: `https://{{user:password}}@{{host}}:{{port}}`<br />*Tipo:* string | Não | 
| `-i, --id` | O ID exclusivo a ser enviado.<br />*Tipo:* string<br />*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.<br />*Tipo:* string | Não | 
| --region (apenas sinalização de recursos) | O endpoint regional do CloudFormation a ser usado.<br />*Tipo:* string<br />*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.<br />*Tipo:* string | Sim | 
| `--role` (apenas sinalização de recursos) | O nome de um perfil do IAM que está associado à instância.<br />*Tipo:* string<br />Condição: o parâmetro do arquivo de credencial substitui este parâmetro. | Não | 
| `-s, --success`  | Se verdadeiro, sinal `SUCCESS`, senão `FAILURE`.<br />*Tipo*: booliano<br />*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.<br />*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.<br />*Tipo:* string | Sim | 
| -u, --url (apenas sinalização de recursos) | O endpoint do CloudFormation a ser usado.<br />*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<br />*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 $? 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)