

• O AWS Systems Manager CloudWatch Dashboard não estará mais disponível a partir de 30 de abril de 2026. Os clientes podem continuar usando o console do Amazon CloudWatch para visualizar, criar e gerenciar os painéis do Amazon CloudWatch exatamente como fazem hoje. Para obter mais informações, consulte a [documentação do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). 

# Criar OpsItems
<a name="OpsCenter-create-OpsItems"></a>

Após configurar o OpsCenter, uma ferramenta do AWS Systems Manager, e integrá-lo aos seus Serviços da AWS, seus Serviços da AWS criam OpsItems automaticamente com base em regras, eventos ou alarmes padrões. 

É possível visualizar os status e os níveis de severidade das regras padrão do Amazon EventBridge. Se necessário, você pode criar ou editar essas regras no Amazon EventBridge. Também é possível visualizar alarmes do Amazon CloudWatch e criar ou editar alarmes. Ao usar regras e alarmes, você pode configurar eventos para os quais deseja gerar OpsItems automaticamente.

Quando o sistema cria um OpsItem, ele está no status **Aberto**. É possível alterar o status para **Em andamento** ao iniciar a investigação do OpsItem e para **Resolvido** após corrigir o OpsItem. Para obter mais informações sobre como configurar alarmes e regras nos Serviços da AWS para criar OpsItems e como criar OpsItems manualmente, consulte os tópicos a seguir. 

**Topics**
+ [Configurar regras do EventBridge para criar OpsItems](OpsCenter-automatically-create-OpsItems-2.md)
+ [Configuração dos alarmes do CloudWatch para criar OpsItems](OpsCenter-create-OpsItems-from-CloudWatch-Alarms.md)
+ [Criar OpsItems manualmente](OpsCenter-manually-create-OpsItems.md)

# Configurar regras do EventBridge para criar OpsItems
<a name="OpsCenter-automatically-create-OpsItems-2"></a>

Quando o Amazon EventBridge recebe um evento, ele cria um novo OpsItem com base nas regras padrão. É possível criar uma regra ou editar uma regra existente para definir o OpsCenter como o destino de um evento do EventBridge. Para obter informações sobre como criar uma regra de evento, consulte [Criar uma regra para um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-eventbridge-rule.html), no *Guia do usuário do Amazon EventBridge*.

**Como configurar uma regra do EventBridge para criar OpsItems no OpsCenter**

1. Abra o console do Amazon EventBridge em [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. No painel de navegação, escolha **Regras**.

1. Na página **Rules** (Regras), para **Event bus** (Barramento de eventos), escolha **default** (padrão).

1. Em **Regras**, escolha uma regra marcando a caixa de seleção ao lado de seu nome.

1. Selecione o nome da regra para abrir sua página de detalhes. Em **Detalhes da regra**, verifique se o **Status** está definido como **Habilitado**.
**nota**  
Se necessário, é possível atualizar o status usando **Editar** no canto superior direito da página.

1. Escolha a guia **Destinos**. 

1. Na guia **Destinos**, selecione **Editar**.

1. Para **Tipos de destino**, selecione **AWS service (Serviço da AWS)**.

1. Para **Select a target** (Selecionar um destino), escolha **Systems Manager OpsItem**.

1. Para muitos tipos de destino, o EventBridge precisa de permissão para enviar eventos ao destino. Nesses casos, o Eventbridge pode criar a função do AWS Identity and Access Management (IAM) necessária para que sua regra seja executada. 
   + Para criar um perfil do IAM automaticamente, escolha **Create a new role for this specific resource**.
   + Para usar um perfil do IAM que você criou para dar permissão ao EventBridge para criar OpsItems no OpsCenter, escolha **Use existing role** (Usar função existente).

1. Em **Configurações adicionais**, para **Configurar entrada de destino**, escolha **Transformador de entrada**.

   É possível usar a opção **Transformador de entrada** para especificar uma string de eliminação de duplicação e outras informações importantes para os OpsItems, como título e severidade.

1. Escolha **Configurar o transformador de entrada**.

1. Em **Transformador de entrada de destino**, para **Caminho de entrada**, especifique os valores a serem analisados ​​do evento de acionamento. Por exemplo, para analisar a hora de início, a hora de término e outros detalhes do evento que aciona a regra, use o seguinte JSON.

   ```
   {
       "end-time": "$.detail.EndTime",
       "failure-cause": "$.detail.cause",
       "resources": "$.resources[0]",
       "source": "$.detail.source",
       "start-time": "$.detail.StartTime"
   }
   ```

1. Em **Template** (Modelo), especifique as informações a serem enviadas ao destino. Por exemplo, use o seguinte JSON para transmitir informações ao OpsCenter. As informações são utilizadas para criar um OpsItem.
**nota**  
Se o modelo de entrada estiver no formato JSON, o valor do objeto no modelo não poderá conter aspas. Por exemplo, os valores de recursos, a causa da falha, a origem, a hora de início e a hora de fim não podem estar entre aspas. 

   ```
   {
       "title": "EBS snapshot copy failed",
       "description": "CloudWatch Event Rule SSMOpsItems-EBS-snapshot-copy-failed was triggered. Your EBS snapshot copy has failed. See below for more details.",
       "category": "Availability",
       "severity": "2",
       "source": "EC2",
       "operationalData": {
           "/aws/dedup": {
               "type": "SearchableString",
               "value": "{\"dedupString\":\"SSMOpsItems-EBS-snapshot-copy-failed\"}"
           },
           "/aws/automations": {
               "value": "[ { \"automationType\": \"AWS:SSM:Automation\", \"automationId\": \"AWS-CopySnapshot\" } ]"
           },
           "failure-cause": {
               "value": <failure-cause>
           },
           "source": {
               "value": <source>
           },
           "start-time": {
               "value": <start-time>
           },
           "end-time": {
               "value": <end-time>
           },
            },
           "resources": {
               "value": <resources>
           }
       }
   }
   ```

   Para obter mais informações sobre esses campos, consulte [Transformar a entrada de destino](https://docs.aws.amazon.com/eventbridge/latest/userguide/transform-input.html) no *Manual do usuário do Amazon EventBridge*.

1. Escolha **Confirmar**.

1. Escolha **Próximo**.

1. Escolha **Próximo**.

1. Escolha **Upgrade rule (Atualizar regra)**.

Depois que uma OpsItem for criada com base em um evento, você poderá visualizar os detalhes do evento abrindo a OpsItem e rolando para baixo até a seção **Private operational data (Dados operacionais privados)**. Para obter informações sobre como configurar as opções em um OpsItem, consulte [Gerenciamento de OpsItems](OpsCenter-working-with-OpsItems.md).

# Configuração dos alarmes do CloudWatch para criar OpsItems
<a name="OpsCenter-create-OpsItems-from-CloudWatch-Alarms"></a>

Durante a configuração integrada do OpsCenter, uma ferramenta do AWS Systems Manager, você habilita o Amazon CloudWatch para criar OpsItems automaticamente com base em alarmes comuns. É possível criar um alarme ou editar um alarme existente para criar OpsItems no OpsCenter. 

O CloudWatch cria um novo perfil vinculado ao serviço no AWS Identity and Access Management (IAM) quando você configura um alarme para criar OpsItems. A nova função é nomeada como `AWSServiceRoleForCloudWatchAlarms_ActionSSM`. Para obter mais informações sobre os perfis vinculados ao serviço do CloudWatch, consulte [Usar funções vinculadas ao serviço para o CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-service-linked-roles.html) no *Guia do usuário do Amazon CloudWatch*. 

Quando um alarme do CloudWatch gera um OpsItem, o OpsItem exibe **o alarme do CloudWatch “*alarm\$1name*” está no estado ALARM**. 

Para visualizar detalhes sobre um OpsItem específico, escolha o OpsItem e, em seguida, selecione a guia **Detalhes de recursos relacionados**. É possível editar os OpsItems manualmente para alterar detalhes, como a severidade ou a categoria. No entanto, ao editar a severidade ou a categoria de um alarme, o Systems Manager não pode atualizar a severidade ou a categoria dos OpsItems que já foram criados no alarme. Se um alarme criou um OpsItem e você especificou uma string de desduplicação, o alarme não criará outro OpsItems, mesmo se você editá-lo no CloudWatch. Se o OpsItem for resolvido no OpsCenter, o CloudWatch criará um novo OpsItem.

Para obter mais informações sobre como configurar alarmes do CloudWatch, consulte os tópicos a seguir.

**Topics**
+ [Configuração de um alarme do CloudWatch para criar OpsItems (console)](OpsCenter-creating-or-editing-existing-alarm-console.md)
+ [Configuração de um alarme existente do CloudWatch para criar OpsItems (programaticamente)](OpsCenter-configuring-an-existing-alarm-programmatically.md)

# Configuração de um alarme do CloudWatch para criar OpsItems (console)
<a name="OpsCenter-creating-or-editing-existing-alarm-console"></a>

É possível criar um alarme ou atualizar um alarme existente para criar OpsItems manualmente no Amazon CloudWatch.

**Como criar um alarme do CloudWatch e configurar o Systems Manager como destino desse alarme**

1. Conclua as etapas de 1 a 9, conforme especificado em [Criar um alarme do CloudWatch com base em um limite estático](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) no *Guia do usuário do Amazon CloudWatch*.

1. Na seção **Ação do Systems Manager**, escolha **Adicionar ação do OpsCenter do Systems Manager**.

1. Escolha **OpsItems**.

1. Em **Severidade**, escolha de 1 a 4. 

1. (Opcional) Em **Categoria**, escolha uma categoria para o OpsItem.

1. Conclua as etapas de 11 a 13, conforme especificado em [Criar um alarme do CloudWatch com base em um limite estático](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) no *Guia do usuário do Amazon CloudWatch*.

1. Selecione **Next** (Próximo) e conclua o assistente.

**Para editar um alarme existente e configurar o Systems Manager como destino desse alarme**

1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. No painel de navegação, selecione **Alarmes**.

1. Selecione o alarme e escolha **Actions** (Ações), **Edit** (Editar).

1. (Opcional) Altere as configurações nas seções **Metrics** (Métricas) e **Conditions** (Condições) e, em seguida, escolha **Next** (Próximo).

1. No**Systems Manager (Gerenciador de sistemas)**, selecione**Adicionar Systems ManagerOpsCenterAção do**. 

1. Para **Severity** (Gravidade), selecione um número. 
**nota**  
A gravidade é um valor definido pelo usuário. Você ou sua organização determinam o que significa cada valor de gravidade e todo contrato de nível de serviço associado a cada gravidade.

1. (Opcional) Em **Category** (Categoria), escolha uma categoria. 

1. Selecione **Next** (Próximo) e conclua o assistente.

# Configuração de um alarme existente do CloudWatch para criar OpsItems (programaticamente)
<a name="OpsCenter-configuring-an-existing-alarm-programmatically"></a>

É possível configurar alarmes do Amazon CloudWatch para criar OpsItems programaticamente usando a AWS Command Line Interface (AWS CLI), modelos do AWS CloudFormation ou trechos de código Java.

**Topics**
+ [Antes de começar](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-before-you-begin)
+ [Como configurar alarmes do CloudWatch para criar OpsItems (AWS CLI)](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-manually-configure-cli)
+ [Como configurar alarmes do CloudWatch para criar ou atualizar OpsItems (CloudFormation)](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-programmatically-configure-CloudFormation)
+ [Como configurar alarmes do CloudWatch para criar ou atualizar OpsItems (Java)](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-programmatically-configure-java)

## Antes de começar
<a name="OpsCenter-create-OpsItems-from-CloudWatch-Alarms-before-you-begin"></a>

Caso edite um alarme existente programaticamente ou criar um alarme que crie OpsItems, você deverá especificar um nome do recurso da Amazon (ARN). Este ARN identifica o OpsCenter do Systems Manager como alvo para OpsItems criados a partir do alerta. Você pode personalizar o ARN para queOpsItemscriado a partir do alarme incluem informações específicas, como gravidade ou categoria. Cada ARN inclui as informações descritas na tabela a seguir.


****  

| Parâmetro | Detalhes | 
| --- | --- | 
|  `Region` (obrigatório)  |  ORegião da AWSonde o alarme existe. Por exemplo: `us-west-2`. Para obter informações sobre as Regiões da AWS onde você pode usar o OpsCenter, consulte [AWS Systems Manager endpoints and quotas (Endpoints e cotas do Systems Manager).](https://docs.aws.amazon.com/general/latest/gr/ssm.html)  | 
|  `account_ID` (obrigatório)  |  O mesmoConta da AWSO ID usado para criar o alarme. Por exemplo: `123456789012`. O ID da conta deve ser seguido por dois pontos (`:`) e o parâmetro `opsitem`, conforme mostrado nos exemplos a seguir.  | 
|  `severity` (obrigatório)  |  Um nível de gravidade definido pelo usuário para OpsItems, criado no alerta. Valores válidos: `1`, `2`, `3`, `4`  | 
|  `Category` (opcional)  |  Uma categoria para o OpsItems criada a partir do alerta. Valores válidos: `Availability`, `Cost`, `Performance`, `Recovery` e `Security`.  | 

Crie o ARN usando a sintaxe a seguir. Este ARN não inclui o opcional`Category`parâmetro .

```
arn:aws:ssm:Region:account_ID:opsitem:severity
```

Veja um exemplo a seguir.

```
arn:aws:ssm:us-west-2:123456789012:opsitem:3
```

Para criar um ARN que use o`Category`, use a sintaxe a seguir.

```
arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name
```

Veja um exemplo a seguir.

```
arn:aws:ssm:us-west-2:123456789012:opsitem:3#CATEGORY=Security
```

## Como configurar alarmes do CloudWatch para criar OpsItems (AWS CLI)
<a name="OpsCenter-create-OpsItems-from-CloudWatch-Alarms-manually-configure-cli"></a>

Este comando requer que você especifique um ARN para o parâmetro `alarm-actions`. Para obter informações sobre como criar o ARN, consulte [Antes de começar](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-before-you-begin).

**Como configurar um alarme do CloudWatch para criar OpsItems (AWS CLI)**

1. Instale e configure a AWS Command Line Interface (AWS CLI), caso ainda não o tenha feito.

   Para obter informações, consulte [Instalar ou atualizar a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

1. Execute o seguinte comando a fim de coletar informações sobre o alarme que você deseja configurar.

   ```
   aws cloudwatch describe-alarms --alarm-names "alarm name"
   ```

1. Execute o comando a seguir para atualizar um alarme. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.

   ```
   aws cloudwatch put-metric-alarm --alarm-name name \
   --alarm-description "description" \
   --metric-name name --namespace namespace \
   --statistic statistic --period value --threshold value \
   --comparison-operator value \
   --dimensions "dimensions" --evaluation-periods value \
       --alarm-actions arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name \
   --unit unit
   ```

   Aqui está um exemplo.

------
#### [ Linux & macOS ]

   ```
   aws cloudwatch put-metric-alarm --alarm-name cpu-mon \
   --alarm-description "Alarm when CPU exceeds 70 percent" \
   --metric-name CPUUtilization --namespace AWS/EC2 \
   --statistic Average --period 300 --threshold 70 \
   --comparison-operator GreaterThanThreshold \
   --dimensions "Name=InstanceId,Value=i-12345678" --evaluation-periods 2 \
   --alarm-actions arn:aws:ssm:us-east-1:123456789012:opsitem:3#CATEGORY=Security \
   --unit Percent
   ```

------
#### [ Windows ]

   ```
   aws cloudwatch put-metric-alarm --alarm-name cpu-mon ^
   --alarm-description "Alarm when CPU exceeds 70 percent" ^
   --metric-name CPUUtilization --namespace AWS/EC2 ^
   --statistic Average --period 300 --threshold 70 ^
   --comparison-operator GreaterThanThreshold ^
   --dimensions "Name=InstanceId,Value=i-12345678" --evaluation-periods 2 ^
   --alarm-actions arn:aws:ssm:us-east-1:123456789012:opsitem:3#CATEGORY=Security ^
   --unit Percent
   ```

------

## Como configurar alarmes do CloudWatch para criar ou atualizar OpsItems (CloudFormation)
<a name="OpsCenter-create-OpsItems-from-CloudWatch-Alarms-programmatically-configure-CloudFormation"></a>

Esta seção inclui modelos do AWS CloudFormation que você pode usar para configurar alarmes do CloudWatch para criar ou atualizar OpsItems automaticamente. Cada modelo requer que você especifique um ARN para o parâmetro `AlarmActions`. Para obter informações sobre como criar o ARN, consulte [Antes de começar](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-before-you-begin).

**Alarme de métrica**: use o modelo do CloudFormation a seguir para criar ou atualizar um alarme de métrica do CloudWatch. O alarme especificado neste modelo monitora as verificações de status da instância do Amazon Elastic Compute Cloud (Amazon EC2). Se o alarme entrar no estado `ALARM`, ele criará um OpsItem no OpsCenter. 

```
    {
      "AWSTemplateFormatVersion": "2010-09-09",
      "Parameters" : {
        "RecoveryInstance" : {
          "Description" : "The EC2 instance ID to associate this alarm with.",
          "Type" : "AWS::EC2::Instance::Id"
        }
      },
      "Resources": {
        "RecoveryTestAlarm": {
          "Type": "AWS::CloudWatch::Alarm",
          "Properties": {
            "AlarmDescription": "Run a recovery action when instance status check fails for 15 consecutive minutes.",
            "Namespace": "AWS/EC2" ,
            "MetricName": "StatusCheckFailed_System",
            "Statistic": "Minimum",
            "Period": "60",
            "EvaluationPeriods": "15",
            "ComparisonOperator": "GreaterThanThreshold",
            "Threshold": "0",
            "AlarmActions": [ {"Fn::Join" : ["", ["arn:arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name", { "Ref" : "AWS::Partition" }, ":ssm:", { "Ref" : "AWS::Region" }, { "Ref" : "AWS:: AccountId" }, ":opsitem:3" ]]} ],
            "Dimensions": [{"Name": "InstanceId","Value": {"Ref": "RecoveryInstance"}}]
          }
        }
      }
    }
```

**Alarme composto**: use o modelo do CloudFormation a seguir para criar ou atualizar um alarme composto. Um alarme compite consiste em vários alarmes métricos. Se o alarme entrar no estado `ALARM`, ele criará um OpsItem no OpsCenter.

```
"Resources":{
       "HighResourceUsage":{
          "Type":"AWS::CloudWatch::CompositeAlarm",
          "Properties":{
             "AlarmName":"HighResourceUsage",
             "AlarmRule":"(ALARM(HighCPUUsage) OR ALARM(HighMemoryUsage)) AND NOT ALARM(DeploymentInProgress)",
             "AlarmActions":"arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name",
             "AlarmDescription":"Indicates that the system resource usage is high while no known deployment is in progress"
          },
          "DependsOn":[
             "DeploymentInProgress",
             "HighCPUUsage",
             "HighMemoryUsage"
          ]
       },
       "DeploymentInProgress":{
          "Type":"AWS::CloudWatch::CompositeAlarm",
          "Properties":{
             "AlarmName":"DeploymentInProgress",
             "AlarmRule":"FALSE",
             "AlarmDescription":"Manually updated to TRUE/FALSE to disable other alarms"
          }
       },
       "HighCPUUsage":{
          "Type":"AWS::CloudWatch::Alarm",
          "Properties":{
             "AlarmDescription":"CPUusageishigh",
             "AlarmName":"HighCPUUsage",
             "ComparisonOperator":"GreaterThanThreshold",
             "EvaluationPeriods":1,
             "MetricName":"CPUUsage",
             "Namespace":"CustomNamespace",
             "Period":60,
             "Statistic":"Average",
             "Threshold":70,
             "TreatMissingData":"notBreaching"
          }
       },
       "HighMemoryUsage":{
          "Type":"AWS::CloudWatch::Alarm",
          "Properties":{
             "AlarmDescription":"Memoryusageishigh",
             "AlarmName":"HighMemoryUsage",
             "ComparisonOperator":"GreaterThanThreshold",
             "EvaluationPeriods":1,
             "MetricName":"MemoryUsage",
             "Namespace":"CustomNamespace",
             "Period":60,
             "Statistic":"Average",
             "Threshold":65,
             "TreatMissingData":"breaching"
          }
       }
    }
```

## Como configurar alarmes do CloudWatch para criar ou atualizar OpsItems (Java)
<a name="OpsCenter-create-OpsItems-from-CloudWatch-Alarms-programmatically-configure-java"></a>

Esta seção inclui trechos de código Java que você pode usar para configurar alarmes do CloudWatch para criar ou atualizar OpsItems automaticamente. Cada trecho requer que você especifique um ARN para o parâmetro `validSsmActionStr`. Para obter informações sobre como criar o ARN, consulte [Antes de começar](#OpsCenter-create-OpsItems-from-CloudWatch-Alarms-before-you-begin).

**Um alarme específico**: use o trecho de código Java a seguir para criar ou atualizar um alarme do CloudWatch. O alarme especificado neste modelo monitora as verificações de status de instância do Amazon EC2. Se o alarme entrar no estado `ALARM`, ele criará um OpsItem no OpsCenter.

```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
    import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
    import com.amazonaws.services.cloudwatch.model.ComparisonOperator;
    import com.amazonaws.services.cloudwatch.model.Dimension;
    import com.amazonaws.services.cloudwatch.model.PutMetricAlarmRequest;
    import com.amazonaws.services.cloudwatch.model.PutMetricAlarmResult;
    import com.amazonaws.services.cloudwatch.model.StandardUnit;
    import com.amazonaws.services.cloudwatch.model.Statistic;
     
    private void putMetricAlarmWithSsmAction() {
        final AmazonCloudWatch cw =
                AmazonCloudWatchClientBuilder.defaultClient();
     
        Dimension dimension = new Dimension()
                .withName("InstanceId")
                .withValue(instanceId);
     
        String validSsmActionStr = "arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name";
     
        PutMetricAlarmRequest request = new PutMetricAlarmRequest()
                .withAlarmName(alarmName)
                .withComparisonOperator(
                        ComparisonOperator.GreaterThanThreshold)
                .withEvaluationPeriods(1)
                .withMetricName("CPUUtilization")
                .withNamespace("AWS/EC2")
                .withPeriod(60)
                .withStatistic(Statistic.Average)
                .withThreshold(70.0)
                .withActionsEnabled(false)
                .withAlarmDescription(
                        "Alarm when server CPU utilization exceeds 70%")
                .withUnit(StandardUnit.Seconds)
                .withDimensions(dimension)
                .withAlarmActions(validSsmActionStr);
     
        PutMetricAlarmResult response = cw.putMetricAlarm(request);
    }
```

**Atualizar todos os alarmes**: use o trecho de código Java a seguir para atualizar todos os alarmes do CloudWatch em sua Conta da AWS para criar OpsItems quando um alarme entrar no estado `ALARM`. 

```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
    import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
    import com.amazonaws.services.cloudwatch.model.DescribeAlarmsRequest;
    import com.amazonaws.services.cloudwatch.model.DescribeAlarmsResult;
    import com.amazonaws.services.cloudwatch.model.MetricAlarm;
     
    private void listMetricAlarmsAndAddSsmAction() {
        final AmazonCloudWatch cw = AmazonCloudWatchClientBuilder.defaultClient();
     
        boolean done = false;
        DescribeAlarmsRequest request = new DescribeAlarmsRequest();
     
        String validSsmActionStr = "arn:aws:ssm:Region:account_ID:opsitem:severity#CATEGORY=category_name";
     
        while(!done) {
     
            DescribeAlarmsResult response = cw.describeAlarms(request);
     
            for(MetricAlarm alarm : response.getMetricAlarms()) {
                // assuming there are no alarm actions added for the metric alarm
                alarm.setAlarmActions(ImmutableList.of(validSsmActionStr));
            }
     
            request.setNextToken(response.getNextToken());
     
            if(response.getNextToken() == null) {
                done = true;
            }
        }
    }
```

# Criar OpsItems manualmente
<a name="OpsCenter-manually-create-OpsItems"></a>

Ao encontrar um problema operacional, é possível criar um OpsItem manualmente no OpsCenter, uma ferramenta do AWS Systems Manager, para gerenciar e resolver o problema. 

Se você configurar o OpsCenter para administração entre contas, um administrador delegado do Systems Manager ou uma conta de gerenciamento do AWS Organizations poderá criar OpsItems para contas de membros. Para ter mais informações, consulte [(Opcional) Configuração do OpsCenter para gerenciar OpsItems de forma centralizada entre contas](OpsCenter-getting-started-multiple-accounts.md).

É possível criar OpsItems usando o console do AWS Systems Manager, a AWS Command Line Interface (AWS CLI) ou as AWS Tools for Windows PowerShell.

**Topics**
+ [Criação de OpsItems manualmente (console)](OpsCenter-creating-OpsItems-console.md)
+ [Criação de OpsItems manualmente (AWS CLI)](OpsCenter-creating-OpsItems-CLI.md)
+ [Criação de OpsItems manualmente (PowerShell)](OpsCenter-creating-OpsItems-Powershell.md)

# Criação de OpsItems manualmente (console)
<a name="OpsCenter-creating-OpsItems-console"></a>

 É possível criar OpsItems manualmente usando o console do AWS Systems Manager. Quando você cria um OpsItem, ele é exibido em sua conta do OpsCenter. Se você configurar o OpsCenter para administração entre contas, o OpsCenter fornecerá ao administrador delegado ou à conta de gerenciamento a opção de criar OpsItems para contas de membros selecionados. Para obter mais informações, consulte [(Opcional) Configuração do OpsCenter para gerenciar OpsItems de forma centralizada entre contas](OpsCenter-getting-started-multiple-accounts.md).

**Como criar um OpsItem usando o console do AWS Systems Manager**

1. Abra o console AWS Systems Manager em [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).

1. No painel de navegação, escolha **OpsCenter**.

1. Escolha **CreateOpsItem** (Criar OpsItem). Se este botão não for exibido, escolha **OpsItems** e, em seguida, escolha **CreateOpsItem** (Criar).

1.  (Opcional) Escolha **Outra conta** e, em seguida, selecione a conta na qual você deseja criar o OpsItem. 
**nota**  
Esta etapa será necessária se você estiver criando OpsItems para uma conta de membro. 

1. Em **Title (Título)**, insira um nome descritivo para ajudar a compreender a finalidade do OpsItem.

1. Em **Source** (Origem), insira o tipo de recurso da AWS afetado ou outras informações de origem para ajudar usuários a compreender a origem do OpsItem.
**nota**  
Você não poderá editar o campo **Source (Origem)** depois de criar a OpsItem.

1. Em **Priority (Prioridade)**, escolha o nível de prioridade.

1. (Opcional) Em **Severity** (Gravidade), escolha o nível de gravidade.

1. (Opcional) Em **Category** (Categoria), escolha uma categoria.

1. Em **Description (Descrição)**, insira informações sobre esse OpsItem, inclusive (se aplicáveis) etapas para reproduzir o problema. 
**nota**  
O console oferece suporte à maior parte da formatação de markdown no campo de descrição do OpsItem. Para obter mais informações, consulte [Usar o Markdown no console](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/aws-markdown.html) no *Guia de conceitos básicos do Console de gerenciamento da AWS*.

1. Em **String de eliminação de duplicação**, insira palavras que o sistema pode usar para verificar se há OpsItems duplicados. Para obter mais informações sobre strings de desduplicação, consulte [Gerenciamento de OpsItems duplicados](OpsCenter-working-deduplication.md). 

1. (Opcional) Em **Notificações**, especifique o nome do recurso da Amazon (ARN) do tópico do Amazon SNS para o qual você deseja que as notificações sejam enviadas quando esse OpsItem for atualizado. Você deve especificar um ARN do Amazon SNS que esteja na mesma Região da AWS em que a OpsItem.

1. (Opcional) Em **Recursos relacionados**, escolha **Adicionar** para especificar o ID ou o ARN do recurso afetado e quaisquer recursos relacionados.

1. Escolha **CreateOpsItem** (Criar OpsItem).

Se tiver êxito, a página exibirá o OpsItem. Quando um administrador delegado ou uma conta de gerenciamento cria um OpsItem para contas de membros selecionados, os novos OpsItems são exibidos no OpsCenter das contas de administrador e de membros. Para obter informações sobre como configurar as opções em um OpsItem, consulte [Gerenciamento de OpsItems](OpsCenter-working-with-OpsItems.md).

# Criação de OpsItems manualmente (AWS CLI)
<a name="OpsCenter-creating-OpsItems-CLI"></a>

O procedimento a seguir descreve como criar um OpsItem usando a AWS Command Line Interface (AWS CLI).

**Como criar um OpsItem usando a AWS CLI**

1. Instale e configure a AWS Command Line Interface (AWS CLI), caso ainda não o tenha feito.

   Para obter informações, consulte [Instalar ou atualizar a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

1. Abra a AWS CLI e execute o comando a seguir para criar uma OpsItem. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.

   ```
   aws ssm create-ops-item \
       --title "Descriptive_title" \
       --description "Information_about_the_issue" \
       --priority Number_between_1_and_5 \
       --source Source_of_the_issue \
       --operational-data Up_to_20_KB_of_data_or_path_to_JSON_file \
       --notifications Arn="SNS_ARN_in_same_Region" \
       --tags "Key=key_name,Value=a_value"
   ```

   **Especificar dados operacionais de um arquivo**

   Ao criar uma OpsItem, você pode especificar dados operacionais de um arquivo. O arquivo deve ser um arquivo JSON e o conteúdo do arquivo deve usar o formato a seguir.

   ```
   {
     "key_name": {
       "Type": "SearchableString",
       "Value": "Up to 20 KB of data"
     }
   }
   ```

   Aqui está um exemplo.

   ```
   aws ssm create-ops-item ^
       --title "EC2 instance disk full" ^
       --description "Log clean up may have failed which caused the disk to be full" ^
       --priority 2 ^
       --source ec2 ^
       --operational-data file:///Users/TestUser1/Desktop/OpsItems/opsData.json ^
       --notifications Arn="arn:aws:sns:us-west-1:12345678:TestUser1" ^
       --tags "Key=EC2,Value=Production"
   ```
**nota**  
Para obter informações sobre como inserir parâmetros formatados em JSON na linha de comando em diferentes sistemas operacionais locais, consulte [Uso de aspas com strings na AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html) no *Guia do usuário da AWS Command Line Interface*.

   O sistema retorna informações como estas.

   ```
   {
       "OpsItemId": "oi-1a2b3c4d5e6f"
   }
   ```

1. Execute o comando a seguir para visualizar detalhes sobre o OpsItem que você criou.

   ```
   aws ssm get-ops-item --ops-item-id ID
   ```

   O sistema retorna informações como estas.

   ```
   {
       "OpsItem": {
           "CreatedBy": "arn:aws:iam::12345678:user/TestUser",
           "CreatedTime": 1558386334.995,
           "Description": "Log clean up may have failed which caused the disk to be full",
           "LastModifiedBy": "arn:aws:iam::12345678:user/TestUser",
           "LastModifiedTime": 1558386334.995,
           "Notifications": [
               {
                   "Arn": "arn:aws:sns:us-west-1:12345678:TestUser"
               }
           ],
           "Priority": 2,
           "RelatedOpsItems": [],
           "Status": "Open",
           "OpsItemId": "oi-1a2b3c4d5e6f",
           "Title": "EC2 instance disk full",
           "Source": "ec2",
           "OperationalData": {
               "EC2": {
                   "Value": "12345",
                   "Type": "SearchableString"
               }
           }
       }
   }
   ```

1. Execute o comando a seguir para atualizar a OpsItem. Esse comando altera o status de `Open` (o padrão) para `InProgress`.

   ```
   aws ssm update-ops-item --ops-item-id ID --status InProgress
   ```

   O comando não tem uma saída.

1. Execute o comando a seguir novamente para verificar se o status foi alterado para `InProgress`.

   ```
   aws ssm get-ops-item --ops-item-id ID
   ```

## Exemplos de criação de um OpsItem
<a name="OpsCenter_creating_OpsItems-CLI_examples"></a>

Os exemplos de código a seguir mostram como criar um OpsItem usando o portal de gerenciamento do Linux, macOS ou Windows Server. 

**Portal de gerenciamento do Linux ou macOS**

O comando a seguir cria um OpsItem quando um disco de instância do Amazon Elastic Compute Cloud (Amazon EC2) está cheio. 

```
aws ssm create-ops-item \
    --title "EC2 instance disk full" \
    --description "Log clean up may have failed which caused the disk to be full" \
    --priority 2 \
    --source ec2 \
    --operational-data '{"EC2":{"Value":"12345","Type":"SearchableString"}}' \
    --notifications Arn="arn:aws:sns:us-west-1:12345678:TestUser1" \
    --tags "Key=EC2,Value=ProductionServers"
```

O comando a seguir usa a chave `/aws/resources` em `OperationalData` para criar um OpsItem com um recurso relacionado ao Amazon DynamoDB.

```
aws ssm create-ops-item \
    --title "EC2 instance disk full" \
    --description "Log clean up may have failed which caused the disk to be full" \
    --priority 2 \
    --source ec2 \
    --operational-data '{"/aws/resources":{"Value":"[{\"arn\": \"arn:aws:dynamodb:us-west-2:12345678:table/OpsItems\"}]","Type":"SearchableString"}}' \
    --notifications Arn="arn:aws:sns:us-west-2:12345678:TestUser"
```

O comando a seguir usa a chave `/aws/automations` em `OperationalData` para criar um OpsItem que especifica o documento `AWS-ASGEnterStandby` como um runbook do Automation associado.

```
aws ssm create-ops-item \
    --title "EC2 instance disk full" \
    --description "Log clean up may have failed which caused the disk to be full" \
    --priority 2 \
    --source ec2 \
    --operational-data '{"/aws/automations":{"Value":"[{\"automationId\": \"AWS-ASGEnterStandby\", \"automationType\": \"AWS::SSM::Automation\"}]","Type":"SearchableString"}}' \
    --notifications Arn="arn:aws:sns:us-west-2:12345678:TestUser"
```

**Windows**

O comando a seguir cria um OpsItem quando uma instância do Amazon Relational Database Service (Amazon RDS) não está respondendo. 

```
aws ssm create-ops-item ^
    --title "RDS instance not responding" ^
    --description "RDS instance not responding to ping" ^
    --priority 1 ^
    --source RDS ^
    --operational-data={\"RDS\":{\"Value\":\"abcd\",\"Type\":\"SearchableString\"}} ^
    --notifications Arn="arn:aws:sns:us-west-1:12345678:TestUser1" ^
    --tags "Key=RDS,Value=ProductionServers"
```

O comando a seguir usa a chave `/aws/resources` em `OperationalData` para criar um OpsItem com um recurso relacionado à instância do Amazon EC2.

```
aws ssm create-ops-item ^
    --title "EC2 instance disk full" ^
    --description "Log clean up may have failed which caused the disk to be full" ^
    --priority 2 ^
    --source ec2 ^
    --operational-data={\"/aws/resources\":{\"Value\":\"[{\\"""arn\\""":\\"""arn:aws:ec2:us-east-1:123456789012:instance/i-1234567890abcdef0\\"""}]\",\"Type\":\"SearchableString\"}}
```

O comando a seguir usa a chave `/aws/automations` em `OperationalData` para criar um OpsItem que especifica o runbook `AWS-RestartEC2Instance` como um runbook do Automation associado.

```
aws ssm create-ops-item ^
    --title "EC2 instance disk full" ^
    --description "Log clean up may have failed which caused the disk to be full" ^
    --priority 2 ^
    --source ec2 ^
    --operational-data={\"/aws/automations\":{\"Value\":\"[{\\"""automationId\\""":\\"""AWS-RestartEC2Instance\\”"",\\"""automationType\\""":\\"""AWS::SSM::Automation\\"""}]\",\"Type\":\"SearchableString\"}}
```

# Criação de OpsItems manualmente (PowerShell)
<a name="OpsCenter-creating-OpsItems-Powershell"></a>

O procedimento a seguir descreve como criar um OpsItem usando as AWS Tools for Windows PowerShell. 

**Como criar um OpsItem usando as AWS Tools for Windows PowerShell**

1. Abra o AWS Tools for Windows PowerShell e execute o seguinte comando para especificar suas credenciais. 

   ```
   Set-AWSCredentials –AccessKey key-name –SecretKey key-name
   ```

1. Execute o comando a seguir para definir a Região da AWS para sua sessão do PowerShell.

   ```
   Set-DefaultAWSRegion -Region Region
   ```

1. Execute o comando a seguir para criar um novo OpsItem. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações. Este comando especifica um runbook de automação do Systems Manager para corrigir esse OpsItem. 

   ```
   $opsItem = New-Object Amazon.SimpleSystemsManagement.Model.OpsItemDataValue
   $opsItem.Type = [Amazon.SimpleSystemsManagement.OpsItemDataType]::SearchableString 
   $opsItem.Value = '[{\"automationId\":\"runbook_name\",\"automationType\":\"AWS::SSM::Automation\"}]'
   $newHash = @{" /aws/automations"=[Amazon.SimpleSystemsManagement.Model.OpsItemDataValue]$opsItem}
   
   New-SSMOpsItem `
       -Title "title" `
       -Description "description" `
       -Priority priority_number `
       -Source AWS_service `
       -OperationalData $newHash
   ```

   Se for bem-sucedido, o comando mostrará o ID do novo OpsItem.

O exemplo a seguir especifica o nome do recurso da Amazon (ARN) de uma instância comprometida do Amazon Elastic Compute Cloud (Amazon EC2).

```
$opsItem = New-Object Amazon.SimpleSystemsManagement.Model.OpsItemDataValue
$opsItem.Type = [Amazon.SimpleSystemsManagement.OpsItemDataType]::SearchableString 
$opsItem.Value = '[{\"arn\":\"arn:aws:ec2:us-east-1:123456789012:instance/i-1234567890abcdef0\"}]'
$newHash = @{" /aws/resources"=[Amazon.SimpleSystemsManagement.Model.OpsItemDataValue]$opsItem}
New-SSMOpsItem -Title "EC2 instance disk full still" -Description "Log clean up may have failed which caused the disk to be full" -Priority 2 -Source ec2 -OperationalData $newHash
```