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. Dadurch werden auch Ihre Kontrollen in einem zentral verwalteten Regelspeicher standardisiert, sodass Sie Ihre Kontrollen konsistent auf alle Konten anwenden können. AWS

Nehmen wir zum Beispiel an, Ihre Compliance-Administratoren haben eine Anforderung definiert, um sicherzustellen, dass alle Lambda-Funktionen die AWS X-Ray Ablaufverfolgung beinhalten. Mit dem AWS Config proaktiven Modus können Sie vor der Bereitstellung Konformitätsprüfungen Ihrer Lambda-Funktionsressourcen durchführen, wodurch das Risiko der Bereitstellung falsch konfigurierter Lambda-Funktionen verringert und Entwicklern Zeit gespart wird, indem sie ihnen schnelleres Feedback zur Infrastruktur als Codevorlagen geben. Im Folgenden wird der Ablauf präventiver Kontrollen visualisiert 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 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 das Konformitätspaket für alle Konten bereit, um sicherzustellen, 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 weitere 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 zur Entwicklung, Paketierung und Registrierung eines AWS CloudFormation Hooks finden Sie in der Dokumentation zur CloudFormation Befehlszeilenschnittstelle (CFN-CLI) unter Developing Hooks. 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": []
        }
    }

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. Anschließend reichen Sie das Hook-Projekt mit dem cfn submit Befehl ein, der eine Rolle mit den erforderlichen Berechtigungen für Sie CloudFormation 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. Ihr Ziel ist es, eine allgemeine, wiederverwendbare Funktion zu schreiben, die die AWS Config StartResourceEvaluation API im proaktiven Modus aufruft, und zwar mithilfe von 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 bei der 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.8
    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 auf. AWS::Lambda::Function 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. Wenn die Vorschriften eingehalten werden, signalisiert der Hook den 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 die Details zur späteren Überprüfung auf. An die relevanten Stakeholder werden Compliance-Benachrichtigungen gesendet.

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

Wenn Sie Logs für Ihren CloudFormation Hook 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 präventive Kontrollen AWS Config im proaktiven Modus implementieren, wenn Sie serverlose Ressourcen in Ihren AWS Konten entwickeln und bereitstellen. 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.