Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Aktionen mit Amazon EventBridge in ACM einleiten
<a name="example-actions"></a>

Sie können EventBridge Amazon-Regeln auf der Grundlage dieser Ereignisse erstellen und die EventBridge Amazon-Konsole verwenden, um Aktionen zu konfigurieren, die ausgeführt werden, wenn die Ereignisse erkannt werden. Dieser Abschnitt enthält Beispielverfahren für die Konfiguration von EventBridge Amazon-Regeln und die daraus resultierenden Aktionen.

**Topics**
+ [Reagieren auf ein Ereignis mit Amazon SNS](event-sns-response.md)
+ [Reagieren auf ein Ereignis mit einer Lambda Funktion](event-lambda-response.md)

# Reagieren auf ein Ereignis mit Amazon SNS
<a name="event-sns-response"></a>

In diesem Abschnitt wird erläutert, wie Amazon SNS so konfiguriert wird, dass eine Textbenachrichtigung gesendet wird, wenn ACM ein Integritätsereignis generiert.

Führen Sie das folgende Verfahren durch, um eine Antwort zu konfigurieren.

**Um eine EventBridge Amazon-Regel zu erstellen und eine Aktion auszulösen**

1. Erstellen Sie eine EventBridge Amazon-Regel. Weitere Informationen finden Sie unter [ EventBridgeAmazon-Regeln erstellen, die auf Ereignisse reagieren](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html).

   1. Navigieren Sie in der EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/)zur Seite **Ereignisse** > **Regeln** und wählen Sie **Regel erstellen** aus. 

   1. Klicken Sie auf der**Regel erstellen**Wählen Sie**Ereignismuster**aus.

   1. Für**Service-Name**, wählen Sie**Integrität**aus dem Menü.

   1. Für**Ereignistyp**, wählen Sie**Spezifische Health Ereignisse**aus.

   1. Select**Spezifische Dienstleistung (en)**und wählen Sie**ACM**aus dem Menü.

   1. Select**Spezifische Ereignistypkategorie (en)**und wählen Sie**KontoBenachrichtigung**aus.

   1. Klicken Sie auf**Jeder Ereignistypcode**aus.

   1. Wählen Sie **Irgendeine Ressource**.

   1. In der**Vorschau auf Ereignismuster**-Editor das JSON-Muster ein, das vom Ereignis ausgegeben wird. In diesem Beispiel wird das Muster aus der[AWS Gesundheitsereignisse](supported-events.md#health-event)Abschnitts erstellt.

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

1. Konfigurieren Sie eine Aktion.

   In der**Targets (Ziele)**können Sie unter vielen Services auswählen, die Ihre Veranstaltung sofort in Anspruch nehmen können, z. B. Amazon Simple Notification Service (SNS), oder Sie können**Lambda-Funktion**, um das Ereignis an angepassten ausführbaren Code zu übergeben. Für ein Beispiel eines AWS Lambda -Implementierung finden Sie unter[Reagieren auf ein Ereignis mit einer Lambda Funktion](event-lambda-response.md)aus.

# Reagieren auf ein Ereignis mit einer Lambda Funktion
<a name="event-lambda-response"></a>

Dieses Verfahren zeigt, wie Sie AWS Lambda bei Amazon mithören EventBridge, Benachrichtigungen mit Amazon Simple Notification Service (SNS) erstellen und Ergebnisse veröffentlichen können AWS Security Hub CSPM, um Administratoren und Sicherheitsteams Transparenz zu bieten. <a name="lambda-setup"></a>

**So richten Sie eine Lambda Funktion und IAM-Rolle ein**

1. Konfigurieren Sie zunächst eine AWS Identity and Access Management (IAM-) Rolle und definieren Sie die Berechtigungen, die für die Lambda-Funktion benötigt werden. Diese bewährte Sicherheitspraxis bietet Ihnen Flexibilität bei der Festlegung, wer die Berechtigung zum Aufrufen der Funktion hat, und beim Beschränken der Berechtigungen, die dieser Person gewährt werden. Es wird nicht empfohlen, die meisten AWS Operationen direkt unter einem Benutzerkonto und insbesondere nicht unter einem Administratorkonto auszuführen.

   Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Erstellen Sie mithilfe des JSON-Richtlinieneditor die Richtlinie, die in der folgenden Vorlage definiert ist. Geben Sie Ihre eigene Region und Ihre AWS Kontodaten an. Weitere Informationen finden Sie unter [Erstellen von Richtlinien auf der Registerkarte 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. Erstellen Sie eine IAM-Rolle und fügen Sie sie der Richtlinie an. Informationen zum Erstellen einer IAM-Rolle und zum Anhängen einer Richtlinie finden Sie unter [Eine Rolle für einen AWS Dienst erstellen (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console). 

1. Öffnen Sie die AWS Lambda Konsole unter. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1. So erstellen Sie die Lambda-Funktion: Weitere Informationen zur Verwendung von Lambda finden Sie unter [Erstellen einer Lambda-Funktion mit der Konsole](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html). Führen Sie folgende Schritte aus:

   1. Wählen Sie auf der Seite **Create function** die Option **Author from scratch**.

   1. Geben Sie im Feld **Funktionsname einen Namen** wie handle-expiring-certificates "" ein.

   1. Wählen Sie in der Liste **Laufzeit** „Python 3.8“.

   1. Erweitern**Ändern der standardmäßigen Ausführungsrolle**und wählen Sie**Verwenden einer vorhandenen Rolle**aus.

   1. Wählen Sie in der Liste **Existing role (Vorhandene Rolle)** die oben erstellte Rolle aus.

   1. Wählen Sie **Funktion erstellen**.

   1. Fügen Sie unter **Function code (Funktionscode)** den folgenden Code ein.

      ```
      # 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. UNDER**Umgebungsvariablen**, wählen Sie**Bearbeiten**und fügen Sie optional die folgenden Variablen hinzu.
      + (Optional) EXPIRY\$1DAYS

        Gibt an, wie viel Vorlaufzeit in Tagen vor dem Versenden der Zertifikatablaufbenachrichtigung gesendet wird. Die Funktion ist standardmäßig 45 Tage, Sie können jedoch benutzerdefinierte Werte angeben.
      + (Optional) SNS\$1TOPIC\$1ARN

        Gibt einen ARN für einen Amazon SNS an. Geben Sie den vollständigen ARN im Format arn:aws:sns::: an. *<region>* *<account-number>* *<topic-name>*
      + (Optional) SECURITY\$1HUB\$1REGION

        Gibt eine in einer anderen Region an AWS Security Hub CSPM . Wenn dies nicht angegeben ist, wird die Region der laufenden Lambda Funktion verwendet. Wenn die Funktion in mehreren Regionen ausgeführt wird, kann es wünschenswert sein, dass alle Zertifikatsnachrichten in einer einzigen Region an Security Hub CSPM gesendet werden. 

   1. Legen Sie unter **Basic settings (Grundlegende Einstellungen)** die Zeitüberschreitung unter **Timeout** auf 30 Sekunden fest.

   1. Wählen Sie oben auf der Seite **Deploy**.

Führen Sie die Aufgaben im folgenden Verfahren aus, um mit der Verwendung dieser Lösung zu beginnen.

**So automatisieren Sie eine E-Mail-Benachrichtigung über das Ablaufdatum**

In diesem Beispiel stellen wir für jedes abgelaufene Zertifikat eine einzige E-Mail bereit, sobald das Ereignis über Amazon EventBridge ausgelöst wird. Standardmäßig löst ACM jeden Tag ein Ereignis für ein Zertifikat aus, das 45 Tage oder weniger nach Ablauf beträgt. (Dieser Zeitraum kann mithilfe der[PutAccountConfiguration](https://docs.aws.amazon.com/acm/latest/APIReference/API_PutAccountConfiguration.html)Betrieb der ACM-API.) Jedes dieser Ereignisse löst die folgende Kaskade automatisierter Aktionen aus:

```
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. Erstellen Sie die Lambda -Funktion und konfigurieren Sie Berechtigungen. (Bereits abgeschlossen — siehe[So richten Sie eine Lambda Funktion und IAM-Rolle ein](#lambda-setup)) enthalten.

1. Erstellen eines*-Standard*SNS-Thema für die Lambda Funktion, die zum Senden von Benachrichtigungen verwendet werden soll. Weitere Informationen finden Sie unter[Erstellen eines Amazon SNS -Themas](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html)aus.

1. Abonnieren Sie alle Interessenten zum neuen SNS-Thema. Weitere Informationen finden Sie unter [Tutorial: Abonnieren eines Endpunkts für ein Amazon SNS-Thema](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).

1. Erstellen Sie eine EventBridge Amazon-Regel, um die Lambda-Funktion auszulösen. Weitere Informationen finden Sie unter [ EventBridge Amazon-Regeln erstellen, die auf Ereignisse reagieren](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html).

   Navigieren Sie in der EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/)zur Seite **Ereignisse** > **Regeln** und wählen Sie **Regel erstellen** aus. Geben Sie **Service-Name**,**Ereignistyp**, und**Lambda-Funktion**an. In der**Vorschau auf Ereignismuster**Fügen Sie in folgenden Code ein:

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

   Ein Ereignis wie Lambda empfängt, wird unter**Beispielereignis anzeigen**:

   ```
   {
     "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"
     }
   }
   ```

**So bereinigen Sie**

Wenn Sie die Beispielkonfiguration oder eine Konfiguration nicht mehr benötigen, empfiehlt es sich, alle Spuren davon zu entfernen, um Sicherheitsprobleme und unerwartete zukünftige Gebühren zu vermeiden:
+ IAM-Richtlinie und -Rolle
+ Lambda-Funktion
+ CloudWatch Die Regel für Ereignisse
+ CloudWatch Logs im Zusammenhang mit Lambda
+ &SNS;-Thema