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. Mit AWS Config können Sie Konformitätsprüfungen zu einem früheren Zeitpunkt im Entwicklungsprozess implementieren und dieselben Kontrollen in Ihren Pipelines implementieren. CI/CD Dadurch werden auch Ihre Kontrollen in einem zentral verwalteten Regelarchiv standardisiert, sodass Sie Ihre Kontrollen konsistent auf alle Ihre Konten anwenden können. AWS

Nehmen wir zum Beispiel an, Ihre Compliance-Administratoren haben eine Anforderung definiert, um sicherzustellen, dass alle Lambda-Funktionen Tracing beinhalten AWS X-Ray . Im proaktiven Modus können Sie vor der Bereitstellung Konformitätsprüfungen für Ihre Lambda-Funktionsressourcen durchführen. So reduzieren Sie das Risiko, falsch konfigurierte Lambda-Funktionen bereitzustellen, und Entwickler sparen Zeit, indem Sie ihnen schnelleres Feedback zur Infrastruktur in Form von Codevorlagen geben. AWS Config Im Folgenden finden Sie eine Visualisierung des Ablaufs präventiver Kontrollen mit: AWS Config

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 gelten muss. Diese Regel kennzeichnet jede Lambda-Funktion, für die keine konfigurierte X-Ray Ablaufverfolgungskonfiguration vorhanden ist, als nicht konforme Ressource. Das Team entwickelt eine Regel, verpackt sie in einem Konformitätspaket und verteilt das Konformitätspaket für alle Konten, um sicherzustellen, dass alle AWS Konten im Unternehmen 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 weitere Maßnahmen, indem es vorschreibt, dass bei jeder AWS CloudFormation Bereitstellung ein Pre-Hook aufgerufen wird. create/update https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/hooks-structure.html 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 CloudFormation Dokumentation zur 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 wird 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": []
        }
    }

Sie müssen außerdem sicherstellen, 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 ermöglicht, die Rolle CloudFormation 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. Dann reichen Sie das Hook-Projekt mit dem cfn submit Befehl ein, mit dem eine Rolle mit den erforderlichen Berechtigungen für Sie CloudFormation erstellt wird.

      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. Ihr Ziel ist es, eine gemeinsame, wiederverwendbare Funktion zu schreiben, die die AWS Config StartResourceEvaluation API im proaktiven Modus aufruft, indem Sie die verwenden AWS SDK for Python (Boto3). 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 Ereignisse zur AWS Lambda Funktionserstellung abhört.

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.14
    TracingConfig:
        Mode: PassThrough
    MemorySize: 256
    Timeout: 10

Als Teil des CI/CD Prozesses ruft der CloudFormation Dienst bei der Bereitstellung der CloudFormation Vorlage den create/update Pre-Hook direkt vor der Bereitstellung des AWS::Lambda::Function Ressourcentyps auf. Der Hook verwendet AWS Config Regeln, die im proaktiven Modus ausgeführt werden, um zu überprüfen, ob die Lambda-Funktionskonfiguration die vorgeschriebene Tracing-Konfiguration enthält. Die Antwort des Hooks bestimmt den nächsten Schritt.

Wenn die Anforderungen erfüllt sind, signalisiert der Hook Erfolg und CloudFormation fährt mit der Bereitstellung der Ressourcen fort. Andernfalls schlägt die CloudFormation Stack-Bereitstellung fehl, die Pipeline kommt sofort zum Stillstand und das System zeichnet die Details zur späteren Überprüfung auf. An die relevanten Stakeholder werden Compliance-Benachrichtigungen gesendet.

Sie finden die success/fail Hook-Informationen in der CloudFormation Konsole:

Wenn Sie Logs für Ihren CloudFormation Hook aktiviert haben, können Sie das Ergebnis der Hook-Bewertung erfassen. Hier ist ein Beispielprotokoll für einen Hook mit dem Status „Fehlgeschlagen“, was darauf hinweist, dass die Lambda-Funktion nicht X-Ray 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 präventive Kontrollen AWS Config im proaktiven Modus implementieren, wenn Sie serverlose Ressourcen in Ihren Konten entwickeln und bereitstellen. AWS 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, für die keine aktive Ablaufverfolgungskonfiguration vorhanden ist. Dadurch wird sichergestellt, dass nur Ressourcen in Ihren Umgebungen bereitgestellt werden, die den neuesten Governance-Richtlinien entsprechen. AWS