Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Avvio di azioni con Amazon EventBridge in ACM
<a name="example-actions"></a>

Puoi creare EventBridge regole Amazon basate su questi eventi e utilizzare la EventBridge console Amazon per configurare le azioni da eseguire quando vengono rilevati gli eventi. Questa sezione fornisce procedure di esempio per configurare le EventBridge regole di Amazon e le azioni risultanti.

**Topics**
+ [Risposta a un evento con Amazon SNS](event-sns-response.md)
+ [Rispondere a un evento con una funzione Lambda](event-lambda-response.md)

# Risposta a un evento con Amazon SNS
<a name="event-sns-response"></a>

In questa sezione viene illustrato come configurare Amazon SNS per inviare una notifica di testo ogni volta che ACM genera un evento sull'integrità.

Completa la procedura seguente per configurare una risposta.

**Per creare una EventBridge regola Amazon e attivare un'azione**

1. Crea una EventBridge regola Amazon. Per ulteriori informazioni, consulta [Creazione di EventBridge regole Amazon che reagiscono agli eventi](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html).

   1. Nella EventBridge console Amazon [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/), vai alla pagina **Eventi** > **Regole** e scegli **Crea regola**. 

   1. Dalla pagina **Crea una regola** seleziona **Pattern di eventi**.

   1. Per **Nome servizio**, scegli **Integrità** dal menu.

   1. Per **Tipo di evento**, scegli **Eventi specifici sull'integrità**.

   1. Seleziona **Servizi specifici** e scegli **ACM** dal menu.

   1. Seleziona**Categorie specifiche del tipo di evento** e scegli **accountNotification**.

   1. Scegli **Qualsiasi codice del tipo di evento**.

   1. Seleziona **Qualsiasi risorsa**.

   1. Nell'editor **Anteprima dei pattern degli eventi**, incolla il pattern JSON emesso dall'evento. In questo esempio viene utilizzato il pattern della sezione [AWS eventi sanitari](supported-events.md#health-event).

   ```
   {
      "source":[
         "aws.health"
      ],
      "detail-type":[
         "AWS Health Event"
      ],
      "detail":{
         "service":[
            "ACM"
         ],
         "eventTypeCategory":[
            "scheduledChange"
         ],
         "eventTypeCode":[
            "AWS_ACM_RENEWAL_STATE_CHANGE"
         ]
      }
   }
   ```

1. Configurare un'operazione.

   Nella sezione **Target**, puoi scegliere tra molti servizi che possono attivare immediatamente il tuo evento, ad esempio Amazon Simple Notification Service (SNS), oppure puoi scegliere la **funzione Lambda** per passare l'evento al codice eseguibile personalizzato. Per un esempio di implementazione AWS Lambda , consulta [Rispondere a un evento con una funzione Lambda](event-lambda-response.md).

# Rispondere a un evento con una funzione Lambda
<a name="event-lambda-response"></a>

Questa procedura illustra come utilizzare per AWS Lambda ascoltare su Amazon EventBridge, creare notifiche con Amazon Simple Notification Service (SNS) e pubblicare i risultati AWS Security Hub CSPM, fornendo visibilità agli amministratori e ai team di sicurezza. <a name="lambda-setup"></a>

**Per impostare una funzione Lambda e un ruolo IAM**

1. Per prima cosa configura un ruolo AWS Identity and Access Management (IAM) e definisci le autorizzazioni necessarie alla funzione Lambda. Questa procedura consigliata per la protezione offre flessibilità nella designazione dell'utente che dispone dell'autorizzazione a chiamare la funzione e nella limitazione delle autorizzazioni concesse a tale persona. Non è consigliabile eseguire la maggior parte delle AWS operazioni direttamente con un account utente e soprattutto non con un account amministratore.

   Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Usa l'editor delle policy JSON per creare la policy definita nel modello seguente. Fornisci i dettagli della tua regione e AWS del tuo account. Per ulteriori informazioni, consulta [Creazione di policy nella scheda JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor).

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "LambdaCertificateExpiryPolicy1",
               "Effect": "Allow",
               "Action": "logs:CreateLogGroup",
               "Resource": "arn:aws:logs:us-east-1:123456789012:*"
           },
           {
               "Sid": "LambdaCertificateExpiryPolicy2",
               "Effect": "Allow",
               "Action": [
                   "logs:CreateLogStream",
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/handle-expiring-certificates:*"
               ]
           },
           {
               "Sid": "LambdaCertificateExpiryPolicy3",
               "Effect": "Allow",
               "Action": [
                   "acm:DescribeCertificate",
                   "acm:GetCertificate",
                   "acm:ListCertificates",
                   "acm:ListTagsForCertificate"
               ],
               "Resource": "*"
           },
           {
               "Sid": "LambdaCertificateExpiryPolicy4",
               "Effect": "Allow",
               "Action": "SNS:Publish",
               "Resource": "*"
           },
           {
               "Sid": "LambdaCertificateExpiryPolicy5",
               "Effect": "Allow",
               "Action": [
                   "SecurityHub:BatchImportFindings",
                   "SecurityHub:BatchUpdateFindings",
                   "SecurityHub:DescribeHub"
               ],
               "Resource": "*"
           },
           {
               "Sid": "LambdaCertificateExpiryPolicy6",
               "Effect": "Allow",
               "Action": "cloudwatch:ListMetrics",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Creare un ruolo IAM e collegare la policy. Per informazioni sulla creazione di un ruolo IAM e sull'associazione di una policy, consulta [Creating a role for an AWS service (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console). 

1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Creazione della funzione Lambda Per ulteriori informazioni sull'utilizzo di Lambda, consulta [Creare una funzione Lambda con la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html). Completa questa procedura:

   1. Nella pagina **Crea funzione**, scegli l'opzione **Crea da zero** per creare la funzione.

   1. Specificate un nome come handle-expiring-certificates "" nel campo **Nome funzione**.

   1. Scegli Python 3.8 dall'elenco **Tempo di esecuzione**.

   1. Espandi **Modifica ruolo di esecuzione predefinito** e scegli **Usa un ruolo esistente**.

   1. Scegli il ruolo creato in precedenza dall'elenco **Ruolo esistente**.

   1. Scegli **Crea funzione**.

   1. In **Codice della funzione**, inserisci il seguente codice:

      ```
      # Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
      # SPDX-License-Identifier: MIT-0
      #
      # Permission is hereby granted, free of charge, to any person obtaining a copy of this
      # software and associated documentation files (the "Software"), to deal in the Software
      # without restriction, including without limitation the rights to use, copy, modify,
      # merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
      # permit persons to whom the Software is furnished to do so.
      #
      # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
      # INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
      # PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
      # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
      # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
      
      import json
      import boto3
      import os
      from datetime import datetime, timedelta, timezone
      # -------------------------------------------
      # setup global data
      # -------------------------------------------
      utc = timezone.utc
      # make today timezone aware
      today = datetime.now().replace(tzinfo=utc)
      # set up time window for alert - default to 45 if its missing
      if os.environ.get('EXPIRY_DAYS') is None:
          expiry_days = 45
      else:
          expiry_days = int(os.environ['EXPIRY_DAYS'])
      expiry_window = today + timedelta(days = expiry_days)
      def lambda_handler(event, context):
          # if this is coming from the ACM event, its for a single certificate
          if (event['detail-type'] == "ACM Certificate Approaching Expiration"):
              response = handle_single_cert(event, context.invoked_function_arn)
          return {
              'statusCode': 200,
              'body': response 
          }
      def handle_single_cert(event, context_arn):
          cert_client = boto3.client('acm')
          cert_details = cert_client.describe_certificate(CertificateArn=event['resources'][0])
          result = 'The following certificate is expiring within ' + str(expiry_days) + ' days: ' + cert_details['Certificate']['DomainName']
          # check the expiry window before logging to Security Hub and sending an SNS
          if cert_details['Certificate']['NotAfter'] < expiry_window:
              # This call is the text going into the SNS notification
              result = result + ' (' + cert_details['Certificate']['CertificateArn'] + ') '
              # this call is publishing to SH
              result = result + ' - ' + log_finding_to_sh(event, cert_details, context_arn)
              # if there's an SNS topic, publish a notification to it
              if os.environ.get('SNS_TOPIC_ARN') is None:
                  response = result
              else:
                  sns_client = boto3.client('sns')
                  response = sns_client.publish(TopicArn=os.environ['SNS_TOPIC_ARN'], Message=result, Subject='Certificate Expiration Notification')
          return result
      def log_finding_to_sh(event, cert_details, context_arn):
          # setup for security hub
          sh_region = get_sh_region(event['region'])
          sh_hub_arn = "arn:aws:securityhub:{0}:{1}:hub/default".format(sh_region, event['account'])
          sh_product_arn = "arn:aws:securityhub:{0}:{1}:product/{1}/default".format(sh_region, event['account'])
          # check if security hub is enabled, and if the hub arn exists
          sh_client = boto3.client('securityhub', region_name = sh_region)
          try:
              sh_enabled = sh_client.describe_hub(HubArn = sh_hub_arn)
          # the previous command throws an error indicating the hub doesn't exist or lambda doesn't have rights to it so we'll stop attempting to use it
          except Exception as error:
              sh_enabled = None
              print ('Default Security Hub product doesn\'t exist')
              response = 'Security Hub disabled'
          # This is used to generate the URL to the cert in the Security Hub Findings to link directly to it
          cert_id = right(cert_details['Certificate']['CertificateArn'], 36)
          if sh_enabled:
              # set up a new findings list
              new_findings = []
                  # add expiring certificate to the new findings list
              new_findings.append({
                  "SchemaVersion": "2018-10-08",
                  "Id": cert_id,
                  "ProductArn": sh_product_arn,
                  "GeneratorId": context_arn,
                  "AwsAccountId": event['account'],
                  "Types": [
                      "Software and Configuration Checks/AWS Config Analysis"
                  ],
                  "CreatedAt": event['time'],
                  "UpdatedAt": event['time'],
                  "Severity": {
                      "Original": '89.0',
                      "Label": 'HIGH'
                  },
                  "Title": 'Certificate expiration',
                  "Description": 'cert expiry',
                  'Remediation': {
                      'Recommendation': {
                          'Text': 'A new certificate for ' + cert_details['Certificate']['DomainName'] + ' should be imported to replace the existing imported certificate before expiration',
                          'Url': "https://console.aws.amazon.com/acm/home?region=" + event['region'] + "#/?id=" + cert_id
                      }
                  },
                  'Resources': [
                      {
                          'Id': event['id'],
                          'Type': 'ACM Certificate',
                          'Partition': 'aws',
                          'Region': event['region']
                      }
                  ],
                  'Compliance': {'Status': 'WARNING'}
              })
              # push any new findings to security hub
              if new_findings:
                  try:
                      response = sh_client.batch_import_findings(Findings=new_findings)
                      if response['FailedCount'] > 0:
                          print("Failed to import {} findings".format(response['FailedCount']))
                  except Exception as error:
                      print("Error: ", error)
                      raise
          return json.dumps(response)
      # function to setup the sh region    
      def get_sh_region(event_region):
          # security hub findings may need to go to a different region so set that here
          if os.environ.get('SECURITY_HUB_REGION') is None:
              sh_region_local = event_region
          else:
              sh_region_local = os.environ['SECURITY_HUB_REGION']
          return sh_region_local
      # quick function to trim off right side of a string
      def right(value, count):
          # To get right part of string, use negative first index in slice.
          return value[-count:]
      ```

   1. Sotto **Variabili ambiente**, scegli **Modifica** e facoltativamente aggiungi le seguenti variabili.
      + (Facoltativo) EXPIRY\$1DAYS

        Specifica il lead time, espressa in giorni, prima dell'invio della notifica di scadenza del certificato. Il valore predefinito della funzione è 45 giorni, ma è possibile specificare valori personalizzati.
      + (Facoltativo) SNS\$1TOPIC\$1ARN

        Specifica un ARN per un Amazon SNS. Fornisci l'ARN completo nel formato arn:aws:sns:::. *<region>* *<account-number>* *<topic-name>*
      + (Opzionale) SECURITY\$1HUB\$1REGION

        Specifica un in una regione diversa. AWS Security Hub CSPM Se questo non viene specificato, viene utilizzata la regione della funzione Lambda in esecuzione. Se la funzione viene eseguita in più regioni, può essere preferibile che tutti i messaggi di certificato vengano inviati al Security Hub CSPM in un'unica regione. 

   1. In **Impostazioni di base**, imposta il valore **Timeout** su 30 secondi.

   1. Nella parte superiore della pagina, scegli **Implementa**.

Completare le attività descritte nella procedura seguente per iniziare a utilizzare questa soluzione.

**Per automatizzare una notifica e-mail di scadenza**

In questo esempio, forniamo un'unica e-mail per ogni certificato in scadenza nel momento in cui l'evento viene segnalato tramite Amazon. EventBridge Per impostazione predefinita, ACM genera un evento ogni giorno per un certificato pari o inferiore a 45 giorni dalla scadenza. (Questo periodo può essere personalizzato usando l'azione [PutAccountConfiguration](https://docs.aws.amazon.com/acm/latest/APIReference/API_PutAccountConfiguration.html) dell'API ACM.) Ciascuno di questi eventi attiva la seguente cascata di azioni automatiche:

```
ACM raises Amazon EventBridge event → 
>>>>>>> events

          Event matches Amazon EventBridge rule → 

                    Rule calls Lambda function → 

                              Function sends SNS email and logs a Finding in Security Hub CSPM
```

1. Crea la funzione Lambda e configura le autorizzazioni. (Già completato — vedi [Per impostare una funzione Lambda e un ruolo IAM](#lambda-setup)).

1. Crea un argomento SNS *standard* per la funzione Lambda da utilizzare per inviare notifiche. Per ulteriori informazioni, consulta [Creazione di un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html).

1. Iscriviti tutte le parti interessate al nuovo argomento SNS. Per ulteriori informazioni, consulta [Iscrizione a un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).

1. Crea una EventBridge regola Amazon per attivare la funzione Lambda. Per ulteriori informazioni, consulta [Creazione di EventBridge regole Amazon che reagiscono agli eventi](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html).

   Nella EventBridge console Amazon [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/), vai alla pagina **Eventi** > **Regole** e scegli **Crea regola**. Specifica **Nome servizio**, **Tipo di evento** e **Funzione Lambda**. Nell'editor **Anteprima dei pattern degli eventi**, incolla il seguente codice:

   ```
   {
     "source": [
       "aws.acm"
     ],
     "detail-type": [
       "ACM Certificate Approaching Expiration"
     ]
   }
   ```

   Un evento come quello ricevuto da Lambda viene visualizzato in** Mostra eventi campione**:

   ```
   {
     "version": "0",
     "id": "9c95e8e4-96a4-ef3f-b739-b6aa5b193afb",
     "detail-type": "ACM Certificate Approaching Expiration",
     "source": "aws.acm",
     "account": "123456789012",
     "time": "2020-09-30T06:51:08Z",
     "region": "us-east-1",
     "resources": [
       "arn:aws:acm:us-east-1:123456789012:certificate/61f50cd4-45b9-4259-b049-d0a53682fa4b"
     ],
     "detail": {
       "DaysToExpiry": 31,
       "CommonName": "My Awesome Service"
     }
   }
   ```

**Per eliminare**

Una volta che non è più necessaria la configurazione di esempio o qualsiasi configurazione, è consigliabile rimuoverne tutte le tracce per evitare problemi di sicurezza e costi futuri imprevisti:
+ Policy IAM e ruolo
+ funzione Lambda
+ CloudWatch Regola degli eventi
+ CloudWatch Log associati a Lambda
+ Argomento SNS