Implementa controlli preventivi per Lambda con AWS Config

È essenziale garantire la conformità delle applicazioni serverless il più presto possibile nel processo di sviluppo. In questo argomento, spieghiamo come implementare controlli preventivi utilizzando AWS Config. Ciò ti consente di implementare i controlli di conformità nelle fasi iniziali del processo di sviluppo e di implementare i medesimi controlli nelle pipeline CI/CD. Ciò standardizza anche i controlli in un archivio di regole gestito centralmente in modo da poter applicare i controlli in modo uniforme su tutti gli account. AWS

Ad esempio, supponiamo che gli amministratori della conformità abbiano definito un requisito per garantire che tutte le funzioni Lambda includano il tracciamento. AWS X-Ray Con AWS Config la modalità proattiva, puoi eseguire controlli di conformità sulle risorse delle funzioni Lambda prima dell'implementazione, riducendo il rischio di implementare funzioni Lambda configurate in modo errato e facendo risparmiare tempo agli sviluppatori fornendo loro un feedback più rapido sull'infrastruttura sotto forma di modelli di codice. Di seguito è riportata una visualizzazione del flusso per i controlli preventivi con: AWS Config

Immagina che vi sia un requisito per cui il tracciamento deve essere abilitato in tutte le funzioni Lambda. In risposta, il team della piattaforma identifica la necessità di una AWS Config regola specifica da applicare in modo proattivo su tutti gli account. Questa regola contrassegna come risorsa non conforme ogni funzione Lambda priva di una configurazione di tracciamento X-Ray configurata. Il team sviluppa una regola, la racchiude in un pacchetto di conformità e distribuisce il pacchetto di conformità su tutti gli AWS account per garantire che tutti gli account dell'organizzazione applichino questi controlli in modo uniforme. Puoi scrivere la regola nella sintassi 2.x.x di AWS CloudFormation Guard , che assume la forma seguente:

rule name when condition { assertion }

Di seguito è riportato un esempio di regola Guard che verifica l'abilitazione del tracciamento nelle funzioni Lambda:

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

Il team della piattaforma intraprende ulteriori azioni imponendo che ogni implementazione richiami un hook di pre-creazione/aggiornamento. AWS CloudFormation Il team si assume la piena responsabilità dello sviluppo di tale hook e di configurare la pipeline, rafforzando il controllo centralizzato delle regole di conformità e sostenendo l'applicazione coerente in tutte le implementazioni. Per sviluppare, creare pacchetti e registrare un hook, consulta Developing AWS CloudFormation Hooks nella documentazione dell' CloudFormation interfaccia a riga di comando (-). CFN CLI Puoi usare il CloudFormation CLIper creare il progetto hook:

cfn init

Questo comando richiede alcune informazioni di base sul progetto hook e crea un progetto contenente i file seguenti:

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

Come sviluppatore di hook, devi aggiungere il tipo di risorsa di destinazione desiderato nel file di configurazione <hook-name>.json. Nella configurazione seguente, un hook è configurato per l'esecuzione prima di creare qualsiasi funzione Lambda utilizzando. CloudFormation Puoi anche aggiungere gestori simili per le azioni preUpdate e preDelete.

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

È inoltre necessario assicurarsi che l' CloudFormation hook disponga delle autorizzazioni appropriate per chiamare il. AWS Config APIs Puoi farlo aggiornando il file di definizione del ruolo denominato hook-role.yaml. Per impostazione predefinita, il file di definizione del ruolo ha la seguente politica di fiducia, che consente di CloudFormation assumere il ruolo.

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

Per consentire a questo hook di chiamare configAPIs, è necessario aggiungere le seguenti autorizzazioni all'istruzione Policy. Quindi invii il progetto hook utilizzando il cfn submit comando, dove CloudFormation crea un ruolo per te con le autorizzazioni richieste.

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

Successivamente, devi scrivere una funzione Lambda in un file src/handler.py. All'interno di tale file, troverai i metodi denominati preCreate, preUpdate e preDelete già creati all'avvio del progetto. Il tuo obiettivo è scrivere una funzione comune e riutilizzabile che li chiami AWS Config StartResourceEvaluation API in modalità proattiva utilizzando il. AWS SDK for Python (Boto3) Questa API chiamata accetta le proprietà della risorsa come input e valuta la risorsa rispetto alla definizione della regola.

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.")

Ora puoi effettuare la chiamata alla funzione comune dal gestore per l'hook di pre-creazione. Di seguito è riportato un esempio del gestore:

@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}")

Dopo questo passaggio è possibile registrare l'hook e configurarlo per ascoltare tutti gli eventi di creazione delle AWS Lambda funzioni.

Uno sviluppatore prepara il modello di infrastructure as code (IaC) per un microservizio serverless utilizzando Lambda. La preparazione prevede il rispetto degli standard interni, a cui seguono il test e il commit locale del modello nel repository. Ecco un esempio di modello IaC:

  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

Come parte del processo CI/CD, quando il CloudFormation modello viene distribuito, il CloudFormation servizio richiama l'hook di pre-creazione/aggiornamento subito prima del provisioning del tipo di risorsa. AWS::Lambda::Function L'hook utilizza AWS Config regole eseguite in modalità proattiva per verificare che la configurazione della funzione Lambda includa la configurazione di tracciamento obbligatoria. La risposta dell'hook determina la fase successiva. Se conforme, l'hook segnala l'esito positivo e procede alla fornitura delle risorse. CloudFormation In caso contrario, l'implementazione CloudFormation dello stack fallisce, la pipeline si arresta immediatamente e il sistema registra i dettagli per la successiva revisione. Le notifiche di conformità vengono inviate ai soggetti interessati.

Puoi trovare le informazioni relative al successo/fallimento dell'hook nella console: CloudFormation

Se hai abilitato i log per il tuo CloudFormation hook, puoi acquisire il risultato della valutazione dell'hook. Di seguito è riportato un log di esempio relativo a un hook con stato non riuscito, che indica il fatto che nella funzione Lambda non è abilitato X-Ray:

Se lo sviluppatore sceglie di modificare l'IaC per aggiornare il valore TracingConfig Mode in Active ed eseguire nuovamente l'implementazione, l'hook viene eseguito correttamente e lo stack procede alla creazione della risorsa Lambda.

In questo modo, puoi implementare controlli preventivi AWS Config in modalità proattiva durante lo sviluppo e la distribuzione di risorse serverless nei tuoi account. AWS Integrando regole AWS Config nella pipeline CI/CD, puoi identificare e, facoltativamente, bloccare le implementazioni di risorse non conformi, come funzioni Lambda prive di una configurazione del tracciamento attiva. Ciò garantisce che negli ambienti vengano implementate solo le risorse conformi alle più recenti politiche di governance. AWS