Implementieren Sie präventive Kontrollen für Lambda mit AWS Config

Es ist wichtig, so früh wie möglich im Entwicklungsprozess die Konformität Ihrer Serverless-Anwendungen sicherzustellen. In diesem Thema behandeln wir die Implementierung präventiver Kontrollen mithilfe von AWS Config. Ziel ist es, Konformitätsprüfungen frühzeitig im Entwicklungsprozess zu implementieren und dieselben Kontrollen in den CI/CD-Pipelines zu verwenden. Auf diese Weise werden die Kontrollen in einem zentral verwalteten Regelspeicher standardisiert, sodass sie konsistent auf alle AWS-Konten angewendet werden können.

Angenommen, Ihre Compliance-Administratoren haben festgelegt, dass alle Lambda-Funktionen die AWS X-Ray-Ablaufverfolgung beinhalten müssen. Mit dem proaktiven Modus von AWS Config können Sie Ihre Lambda-Funktionsressourcen vor der Bereitstellung auf Konformität prüfen und das Risiko falsch konfigurierter Lambda-Funktionen verringern. Die Entwickler sparen Zeit, indem sie schneller als über Codevorlagen Feedback zur Infrastruktur erhalten. Im Folgenden ist der Ablauf präventiver Kontrollen mit AWS Config bildlich dargestellt.

Nehmen wir an, es wird festgelegt, dass für alle Lambda-Funktionen die Ablaufverfolgung aktiviert sein muss. Als Reaktion darauf stellt das Plattformteam fest, dass eine bestimmte AWS Config-Regel proaktiv für alle Konten ausgeführt werden muss. Diese Regel kennzeichnet jede Lambda-Funktion, für die keine X-Ray-Ablaufverfolgung konfiguriert ist, als nicht konforme Ressource. Das Team entwickelt eine Regel, verpackt sie in ein Konformitätspaket und stellt dieses für alle Konten bereit, um dafür zu sorgen, dass alle AWS-Konten in der Organisation diese Kontrollen einheitlich anwenden. Sie können die Regel in der AWS CloudFormation Guard 2.x.x-Syntax schreiben, die folgende Form hat:

rule name when condition { assertion }

Im Folgenden finden Sie ein Beispiel für eine Guard-Regel, die überprüft, ob für Lambda-Funktionen die Ablaufverfolgung aktiviert ist:

rule lambda_tracing_check {
  when configuration.tracingConfig exists {
      configuration.tracingConfig.mode == "Active"
  }
}

Das Plattformteam ergreift zusätzliche Maßnahmen und schreibt vor, dass bei jeder AWS CloudFormation-Bereitstellung ein Pre-Create/Update-Hook aufgerufen wird. Das Team übernimmt die volle Verantwortung für die Entwicklung dieses Hooks und die Konfiguration der Pipeline, mit dem Ziel, die zentrale Kontrolle der Compliance-Regeln zu stärken und ihre konsistente Anwendung in allen Implementierungen sicherzustellen. Informationen zum Entwickeln, Verpacken und Registrieren eines Hooks finden Sie unter Entwickeln von AWS CloudFormation-Hooks in der Dokumentation der CloudFormation-Befehlszeilenschnittstelle (CFN-CLI). Sie können die CloudFormation CLI verwenden, um das Hook-Projekt zu erstellen:

cfn init

Der Befehl fragt Sie nach einigen grundlegenden Informationen zu Ihrem Hook-Projekt und erstellt ein Projekt mit den folgenden Dateien:

README.md
<hook-name>.json
rpdk.log
src/handler.py
template.yml
hook-role.yaml

Der Hook-Entwickler fügt der Konfigurationsdatei <hook-name>.json den gewünschten Zielressourcentyp hinzu. In der folgenden Konfiguration ist ein Hook so konfiguriert, dass er ausgeführt wird, bevor eine Lambda-Funktion mit CloudFormation erstellt wird. Sie können ähnliche Handler auch für die Aktionen preUpdate und preDelete hinzufügen.

    "handlers": {
        "preCreate": {
            "targetNames": [
                "AWS::Lambda::Function"
            ],
            "permissions": []
        }
    }

Stellen Sie sicher, dass der CloudFormation-Hook über die entsprechenden Berechtigungen zum Aufrufen der AWS Config-APIs verfügt. Aktualisieren Sie dazu die Rollendefinitionsdatei hook-role.yaml. Die Rollendefinitionsdatei hat standardmäßig die folgende Vertrauensrichtlinie, die es CloudFormation erlaubt, die Rolle zu übernehmen.

      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - hooks.cloudformation.amazonaws.com
                - resources.cloudformation.amazonaws.com

Damit der Hook Konfigurations-APIs aufrufen kann, müssen Sie der Policy-Anweisung die folgenden Berechtigungen hinzufügen. Anschließend senden Sie das Hook-Projekt mit dem Befehl cfn submit, wobei CloudFormation eine Rolle mit den erforderlichen Berechtigungen für Sie erstellt.

      Policies:
        - PolicyName: HookTypePolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - "config:Describe*"
                  - "config:Get*"
                  - "config:List*"
                  - "config:SelectResourceConfig"
                Resource: "*

Als Nächstes müssen Sie eine Lambda-Funktion in eine src/handler.py-Datei schreiben. In dieser Datei finden Sie Methoden mit dem Namen und preCreate, preUpdate und preDelete, die bereits bei der Initiierung des Projekts erstellt wurden. Ziel ist es, eine allgemeine, wiederverwendbare Funktion schreiben, die die AWS Config StartResourceEvaluation API im proaktiven Modus aufruft und dafür AWS SDK für Python (Boto3) verwendet. Dieser API-Aufruf verwendet Ressourceneigenschaften als Eingabe und vergleicht die Ressource mit der Regeldefinition.

def validate_lambda_tracing_config(resource_type, function_properties: MutableMapping[str, Any]) -> ProgressEvent:
  LOG.info("Fetching proactive data")
  config_client = boto3.client('config')
  resource_specs = {
      'ResourceId': 'MyFunction',
      'ResourceType': resource_type,
      'ResourceConfiguration': json.dumps(function_properties),
      'ResourceConfigurationSchemaType': 'CFN_RESOURCE_SCHEMA'
  }
  LOG.info("Resource Specifications:", resource_specs)
  eval_response = config_client.start_resource_evaluation(EvaluationMode='PROACTIVE', ResourceDetails=resource_specs, EvaluationTimeout=60)
  ResourceEvaluationId = eval_response.ResourceEvaluationId
  compliance_response = config_client.get_compliance_details_by_resource(ResourceEvaluationId=ResourceEvaluationId)
  LOG.info("Compliance Verification:", compliance_response.EvaluationResults[0].ComplianceType)
  if "NON_COMPLIANT" == compliance_response.EvaluationResults[0].ComplianceType:
      return ProgressEvent(status=OperationStatus.FAILED, message="Lambda function found with no tracing enabled : FAILED", errorCode=HandlerErrorCode.NonCompliant)
  else:
      return ProgressEvent(status=OperationStatus.SUCCESS, message="Lambda function found with tracing enabled : PASS.")

Jetzt können Sie die allgemeine Funktion vom Handler für den Pre-Create-Hook aus aufrufen. Ein Beispiel für den Handler:

@hook.handler(HookInvocationPoint.CREATE_PRE_PROVISION)
def pre_create_handler(
        session: Optional[SessionProxy],
        request: HookHandlerRequest,
        callback_context: MutableMapping[str, Any],
        type_configuration: TypeConfigurationModel
) -> ProgressEvent:
    LOG.info("Starting execution of the hook")
    target_name = request.hookContext.targetName
    LOG.info("Target Name:", target_name)
    if "AWS::Lambda::Function" == target_name:
        return validate_lambda_tracing_config(target_name,
            request.hookContext.targetModel.get("resourceProperties")
        )
    else:
        raise exceptions.InvalidRequest(f"Unknown target type: {target_name}")

Nach diesem Schritt können Sie den Hook registrieren und ihn so konfigurieren, dass er alle AWS Lambda Funktionserstellungsereignisse überwacht.

Ein Entwickler bereitet die IaC-Vorlage (Infrastructure as Code) für einen Serverless-Microservice mithilfe von Lambda vor. Diese Vorbereitung umfasst die Einhaltung interner Standards, gefolgt von lokalen Tests und dem Commit der Vorlage in das Repository. Hier ist ein Beispiel für eine IaC-Vorlage:

  MyLambdaFunction:
  Type: 'AWS::Lambda::Function'
  Properties:
    Handler: index.handler
    Role: !GetAtt LambdaExecutionRole.Arn
    FunctionName: MyLambdaFunction
    Code:
      ZipFile: |
        import json

        def handler(event, context):
            return {
                'statusCode': 200,
                'body': json.dumps('Hello World!')
            }
    Runtime: python3.13
    TracingConfig:
        Mode: PassThrough
    MemorySize: 256
    Timeout: 10

Als Teil des CI/CD-Prozesses ruft der CloudFormation-Dienst bei der Bereitstellung der CloudFormation-Vorlage den Pre-Create/Update-Hook unmittelbar vor der Bereitstellung des Ressourcentyps AWS::Lambda::Function auf. Der Hook verwendet AWS Config Regeln, die im proaktiven Modus ausgeführt werden, um zu überprüfen, ob die Lambda-Funktionskonfiguration die vorgeschriebene Ablaufverfolgungskonfiguration enthält. Die Antwort des Hooks bestimmt den nächsten Schritt. Bei Konformität signalisiert der Hook Erfolg, und CloudFormation fährt mit der Bereitstellung der Ressourcen fort. Wenn nicht, schlägt die CloudFormation-Stack-Bereitstellung fehl, die Pipeline wird sofort gestoppt und das System zeichnet Details zur späteren Überprüfung auf. An die relevanten Stakeholder werden Compliance-Benachrichtigungen gesendet.

Sie finden die Informationen zum Erfolg/Fehlschlag des Hooks in der CloudFormation-Konsole:

Wenn Sie für Ihren CloudFormation-Hook die Protokollierung aktiviert haben, können Sie das Ergebnis der Hook-Auswertung erfassen. Hier ist ein Beispielprotokoll für einen Hook mit dem Status „Fehlgeschlagen“, was darauf hinweist, dass für die Lambda-Funktion X-Ray nicht aktiviert ist:

Hat der Entwickler entschieden, die IaC so zu ändern, dass der Wert TracingConfig Mode in Active aktualisiert wird und die Bereitstellung erneut erfolgt, wird der Hook erfolgreich ausgeführt und der Stack fährt mit der Erstellung der Lambda-Ressource fort.

Auf diese Weise können Sie bei der Entwicklung und Bereitstellung von Serverless-Ressourcen in Ihren AWS-Konten präventive Kontrollen mit AWS Config im proaktiven Modus implementieren. Durch die Integration von AWS Config-Regeln in die CI/CD-Pipeline können Sie nicht konforme Ressourcenbereitstellungen identifizieren und optional blockieren, z. B. Lambda-Funktionen, denen eine aktive Ablaufverfolgungskonfiguration fehlt. Dadurch wird sichergestellt, dass nur Ressourcen in Ihren AWS-Umgebungen eingesetzt werden, die den neuesten Governance-Richtlinien entsprechen.