View a markdown version of this page

AWS Integrazione zero-ETL per fonti di database autogestite - AWS Servizio di migrazione del database
Come funziona l'integrazione zero-ETL per fonti di database autogestiteConfigurazione del database di origine prima della creazione dell'integrazioneConfigurazione delle autorizzazioni e della crittografia IAM per l'integrazione zero-ETL

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

AWS Integrazione zero-ETL per fonti di database autogestite

AWS L'integrazione Zero-ETL è una soluzione completamente gestita che rende disponibili i dati transazionali e operativi in Amazon Redshift, Amazon S3 e Amazon S3 Tables da più fonti di database operative e transazionali. Utilizzando Zero-ETL, puoi replicare i dati dai tuoi database di origine autogestiti come MySQL, PostgreSQL, SQL Server e Oracle su Amazon Redshift tramite endpoint di origine esistenti (). AWS Database Migration Service AWS DMS La sincronizzazione automatica evita il tradizionale processo di estrazione, trasformazione e caricamento (ETL). Consente inoltre l'analisi in tempo reale e i carichi di lavoro AI. Per ulteriori informazioni, consulta le integrazioni Zero-ETL nella Amazon Redshift Management Guide.

Zero-ETL l'integrazione offre i seguenti vantaggi:

  • Real-time replica dei dati: sincronizzazione continua dei dati dai database Oracle ad Amazon Redshift con latenza minima.

  • Eliminazione di pipeline ETL complesse: non è necessario creare e mantenere soluzioni di integrazione dei dati personalizzate.

  • Costo operativo ridotto: configurazione e gestione automatizzate tramite API. AWS

  • Architettura di integrazione dei dati semplificata: perfetta integrazione tra database autogestiti e servizi di analisi. AWS

  • Sicurezza avanzata: Built-in crittografia e controlli degli accessi IAM.

Come funziona l'integrazione zero-ETL per fonti di database autogestite

Puoi utilizzare AWS DMS endpoint esistenti creati in precedenza per database autogestiti o crearne di nuovi.

  • Usa la AWS Glue console o l'interfaccia a riga di comando per creare l'integrazione Zero-ETL con Amazon Redshift come destinazione nel catalogo. AWS Glue Puoi specificare lo schema e il filtro della tabella durante la creazione di integrazioni Zero-ETL.

  • Le risorse aggiuntive di sola lettura relative alle integrazioni vengono create automaticamente all'interno del servizio. AWS DMS Queste risorse, incluso il motore Zero-ETL, vengono utilizzate per avviare processi a pieno carico e di modifica continua dei dati, per sincronizzare i dati con il database di destinazione di Amazon Redshift.

  • Puoi controllare la crittografia dei dati quando crei l’origine di integrazione, quando crei l’integrazione Zero-ETL e quando crei il data warehouse Amazon Redshift.

  • L’integrazione monitora lo stato della pipeline dei dati ed esegue il ripristino in caso di problemi quando possibile.

  • Puoi creare integrazioni da origini dello stesso tipo in un unico data warehouse Amazon Redshift per ottenere approfondimenti olistici da più applicazioni.

Una volta replicati i dati, puoi utilizzare le funzionalità di analisi di Amazon Redshift. Ad esempio, il machine learning (ML) integrato, le viste materializzate, la condivisione dei dati e l'accesso diretto a più datastore e data lake. Per gli ingegneri dei dati, le integrazioni zero-ETL forniscono l'accesso a dati sensibili al fattore tempo che altrimenti potrebbero essere ritardati da errori intermittenti in pipeline di dati complesse. Puoi eseguire query analitiche e modelli di ML sui dati transazionali per ottenere informazioni tempestive per eventi e decisioni aziendali sensibili al fattore tempo.

Puoi creare sottoscrizioni per la notifica degli eventi di Amazon Redshift per ricevere una notifica automatica in caso di problemi relativi a qualsiasi integrazione zero-ETL. Per visualizzare l'elenco delle notifiche di eventi relative all'integrazione, consulta Notifiche di eventi di integrazione con Amazon. Zero-ETL EventBridge Il modo più semplice per creare un abbonamento è con la console Amazon Simple Notification Service. Per informazioni sulla creazione di un argomento Amazon SNS e sul relativo abbonamento, consulta Nozioni di base su Amazon SNS nella Guida per sviluppatori di Amazon Simple Notification Service.

Configurazione del database di origine prima della creazione dell'integrazione

Prima di configurare le integrazioni zero-ETL, è necessario configurare correttamente il database di origine in base ai requisiti del motore di database. Ogni motore ha requisiti e limitazioni di configurazione specifici.

SQL Server

Nota

RDS SQL Server e Azure SQL Server non possono essere utilizzati come fonti per integrazioni zero-ETL autogestite.

Oracle

MySQL

PostgreSQL

Configurazione delle autorizzazioni e della crittografia IAM per l'integrazione zero-ETL

Per creare e gestire integrazioni zero-ETL, devi configurare le autorizzazioni IAM appropriate, () le chiavi di crittografia e le policy relative alle risorse. AWS Key Management Service AWS KMS Questa sezione fornisce indicazioni sulla configurazione dei componenti di sicurezza richiesti.

Prerequisiti

Prima di creare un'integrazione Zero-ETL, assicurati di disporre di quanto segue:

  • Un utente o ruolo IAM con le autorizzazioni appropriate per creare e gestire integrazioni

  • Configura gli endpoint AWS DMS di origine per i tuoi database autogestiti. Per ulteriori informazioni, consulta Configurazione del database di origine prima della creazione dell'integrazione.

  • Un cluster con provisioning di Amazon Redshift come destinazione

    Nota

    Amazon Redshift Serverless non può essere utilizzato come destinazione per integrazioni zero-ETL da fonti autogestite.

  • Configurazione di rete che include sottoreti VPC e gruppi di sicurezza

Creazione di una chiave KMS

Innanzitutto, crea una AWS KMS chiave gestita dal cliente per crittografare i dati nella tua integrazione Zero-ETL. L'esempio seguente crea una chiave di crittografia simmetrica: 

aws kms create-key \
  --description "On-prem Zero-ETL Integration Encryption Key" \
  --key-usage ENCRYPT_DECRYPT \
  --key-spec SYMMETRIC_DEFAULT \
  --region region

Annota le KeyId e Arn della risposta, poiché ti serviranno per configurare la policy chiave e creare l'integrazione.

Output di esempio:

{
    "KeyMetadata": {
        "AWSAccountId": "account-id",
        "KeyId": "4e2c14f8-7abe-4aec-851a-379f6ed973a8",
        "Arn": "arn:aws:kms:region:account-id:key/4e2c14f8-7abe-4aec-851a-379f6ed973a8",
        "CreationDate": 1763155061.148,
        "Enabled": true,
        "Description": "Zero-ETL Integration Encryption Key",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "KeyState": "Enabled",
        "Origin": "AWS_KMS",
        "KeyManager": "CUSTOMER",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "KeySpec": "SYMMETRIC_DEFAULT",
        "EncryptionAlgorithms": [
            "SYMMETRIC_DEFAULT"
        ],
        "MultiRegion": false
    }
}

Configurazione della politica chiave del KMS

Dopo aver creato la chiave KMS, configura la policy chiave per consentire ad Amazon Redshift e ai AWS Glue servizi di utilizzare la chiave per le operazioni di crittografia e decrittografia. La policy chiave deve concedere le autorizzazioni necessarie ai principali del servizio e includere il contesto di crittografia che verrà utilizzato durante la creazione dell'integrazione.

L'esempio seguente mostra una politica chiave per le integrazioni zero-ETL:

{
    "Version": "2012-10-17",
    "Id": "key-default-1",
    "Statement": [
        {
            "Sid": "Enable IAM User Permissions",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::111122223333:root"
            },
            "Action": "kms:*",
            "Resource": "*"
        },
        {
            "Sid": "Allows the Redshift and glue service principal to add a grant to a KMS key",
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "redshift.amazonaws.com",
                    "glue.amazonaws.com"
                ]
            },
            "Action": "kms:CreateGrant",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
	              "kms:EncryptionContext:context-key": "context-value"
                },
                "ForAllValues:StringEquals": {
                    "kms:GrantOperations": [
                        "Decrypt",
                        "GenerateDataKey",
                        "CreateGrant",
                        "GenerateDataKeyWithoutPlaintext",
                        "ReEncryptTo"
                    ]
                }
            }
        }
    ]
}

La kms:EncryptionContext condizione deve corrispondere al contesto di crittografia aggiuntivo specificato durante la creazione dell'integrazione. È possibile aggiornare la policy chiave utilizzando la AWS KMS console o il seguente comando CLI: 

aws kms put-key-policy \
  --key-id key-id \
  --policy-name default \
  --policy file://kms-key-policy.json

Creazione di un utente IAM e configurazione AWS CLI

Crea un utente IAM che verrà utilizzato per gestire le integrazioni zero-ETL e configurare la CLI con le AWS credenziali appropriate.

  1. Crea un utente IAM:

    aws iam create-user --user-name cli-user

  2. Crea chiavi di accesso per l'utente:

    aws iam create-access-key --user-name cli-user

    Salva le AccessKeyId e SecretAccessKey dall'output, poiché ti serviranno per configurare la AWS CLI.

Creazione e collegamento di una policy IAM

Crea una policy IAM che conceda le autorizzazioni per le operazioni di integrazione zero-ETL. La policy deve includere le autorizzazioni per AWS Glue AWS DMS, Amazon Redshift e. AWS KMS

Salva la seguente policy in un file (ad esempio,/tmp/zetl-policy.json):

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "ZetlGlueIntegrationAccess",
            "Effect": "Allow",
            "Action": [
                "glue:CreateIntegration",
                "glue:ModifyIntegration",
                "glue:DeleteIntegration",
                "glue:DescribeIntegrations",
                "glue:DescribeInboundIntegrations"
            ],
            "Resource": "*"
        },
        {
            "Sid": "DMSIntegrationAccess",
            "Effect": "Allow",
            "Action": [
                "dms:CreateOutboundIntegration",
                "dms:ModifyOutboundIntegration",
                "dms:CreateEndpoint",
                "dms:DescribeEndpoints",
                "dms:ModifyEndpoint",
                "dms:DeleteEndpoint",
                "dms:TestConnection"
            ],
            "Resource": "*"
        },
        {
            "Sid": "ZetlRedshiftFullAccess",
            "Effect": "Allow",
            "Action": [
                "redshift:*",
                "ec2:DescribeAccountAttributes",
                "ec2:DescribeAddresses",
                "ec2:DescribeAvailabilityZones",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeSubnets",
                "ec2:DescribeVpcs",
                "ec2:DescribeInternetGateways",
                "sns:CreateTopic",
                "sns:Get*",
                "sns:List*",
                "cloudwatch:Describe*",
                "cloudwatch:Get*",
                "cloudwatch:List*",
                "cloudwatch:PutMetricAlarm",
                "cloudwatch:EnableAlarmActions",
                "cloudwatch:DisableAlarmActions",
                "tag:GetResources",
                "tag:UntagResources",
                "tag:GetTagValues",
                "tag:GetTagKeys",
                "tag:TagResources"
            ],
            "Resource": "*"
        },
        {
            "Sid": "ZetlRedshiftDataAPI",
            "Effect": "Allow",
            "Action": [
                "redshift-data:ExecuteStatement",
                "redshift-data:CancelStatement",
                "redshift-data:ListStatements",
                "redshift-data:GetStatementResult",
                "redshift-data:DescribeStatement",
                "redshift-data:ListDatabases",
                "redshift-data:ListSchemas",
                "redshift-data:ListTables",
                "redshift-data:DescribeTable"
            ],
            "Resource": "*"
        },
        {
            "Sid": "ZetlKMSAccess",
            "Effect": "Allow",
            "Action": [
                "kms:CreateKey",
                "kms:DescribeKey",
                "kms:Encrypt",
                "kms:Decrypt",
                "kms:GenerateDataKey",
                "kms:ListKeys",
                "kms:CreateAlias",
                "kms:ListAliases",
                "kms:CreateGrant"
            ],
            "Resource": "*"
        },
        {
            "Sid": "ZetlSecretsManagerAccess",
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue",
                "secretsmanager:PutSecretValue",
                "secretsmanager:CreateSecret",
                "secretsmanager:UpdateSecret",
                "secretsmanager:DeleteSecret",
                "secretsmanager:DescribeSecret",
                "secretsmanager:ListSecrets",
                "secretsmanager:GetResourcePolicy",
                "secretsmanager:PutResourcePolicy",
                "secretsmanager:ValidateResourcePolicy"
            ],
            "Resource": "*"
        }
    ]
}

Crea la policy e allegala all'utente IAM:

aws iam create-policy \
  --policy-name ZetlCustomPolicy \
  --policy-document file:///tmp/zetl-policy.json

aws iam attach-user-policy \
  --policy-arn arn:aws:iam::account-id:policy/ZetlCustomPolicy \
  --user-name cli-user

Configurazione della AWS Profilo CLI

Configura un profilo AWS CLI con le credenziali utente create nei passaggi precedenti:

aws configure set aws_access_key_id ACCESS_KEY_ID --profile cli-user
aws configure set aws_secret_access_key SECRET_ACCESS_KEY --profile cli-user
aws configure set region region --profile cli-user
aws configure set output json --profile cli-user

Verifica la configurazione del profilo:

aws sts get-caller-identity --profile cli-user

L'output dovrebbe mostrare l'ID dell'account, l'ID utente e l'ARN dell'utente, confermando che il profilo è configurato correttamente.

Creazione di una politica sulle risorse di Redshift

Crea una policy sulle risorse di Amazon Redshift per autorizzare l'endpoint di AWS DMS origine a creare integrazioni in entrata con il tuo namespace Amazon Redshift. Questa policy è allegata allo spazio dei nomi Amazon Redshift e controlla quali fonti possono replicare i dati al suo interno.

L'esempio seguente mostra come creare una policy sulle risorse per uno spazio dei nomi Amazon Redshift:

aws redshift put-resource-policy \
  --policy '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Principal": {
          "Service": ["redshift.amazonaws.com"]
        },
        "Action": ["redshift:AuthorizeInboundIntegration"],
        "Resource": "arn:aws:redshift:region:account-id:namespace:namespace-id",
        "Condition": {
          "StringEquals": {
            "aws:SourceArn": "arn:aws:dms:region:account-id:endpoint:endpoint-id"
          }
        }
      },
      {
        "Effect": "Allow",
        "Principal": {
          "AWS": "account-id"
        },
        "Action": [
          "redshift:CreateInboundIntegration",
          "redshift:ModifyInboundIntegration"
        ],
        "Resource": "arn:aws:redshift:region:account-id:namespace:namespace-id"
      }
    ]
  }' \
  --resource-arn arn:aws:redshift:region:account-id:namespace:namespace-id \
  --region region

Sostituire i seguenti segnaposto:

  • region— La AWS regione in cui si trovano le tue risorse

  • account-id— L'ID AWS del tuo account

  • endpoint-id— L'ID dell'endpoint AWS DMS di origine

  • namespace-id— L'ID del tuo namespace Amazon Redshift

Esempio: creazione di un'integrazione zero-ETL con crittografia

Dopo aver impostato le autorizzazioni e le chiavi di crittografia necessarie, puoi creare un'integrazione Zero-ETL utilizzando l'API. AWS Glue L'esempio seguente dimostra la creazione di un'integrazione da una fonte MySQL a un target Amazon Redshift con crittografia KMS: 

aws glue create-integration \
  --integration-name mysql-onprem-integration \
  --source-arn arn:aws:dms:region:account-id:endpoint:source-endpoint-id \
  --target-arn arn:aws:redshift:region:account-id:namespace:namespace-id \
  --description "MySQL to Redshift integration" \
  --integration-config '{"SourceProperties":{"SubnetIds":"subnet-id1,subnet-id2,subnet-id3","VpcSecurityGroupIds":"sg-id"}}' \
  --data-filter "include: mysql.*" \
  --kms-key-id arn:aws:kms:region:account-id:key/key-id \
  --additional-encryption-context '{"context-key": "context-value"}' \
  --profile cli-user \
  --region region

Il comando include i seguenti parametri chiave:

  • --integration-name— Un nome univoco per l'integrazione

  • --source-arn— L'ARN dell'endpoint di AWS DMS origine

  • --target-arn— L'ARN del tuo namespace Amazon Redshift

  • --integration-config— Configurazione di rete, inclusi ID di sottorete e gruppi di sicurezza

  • --data-filter— Specifica quali schemi e tabelle replicare

  • --kms-key-id— L'ARN della chiave per la crittografia AWS KMS

  • --additional-encryption-context— Coppie chiave-valore del contesto di crittografia che devono corrispondere alla politica delle chiavi del KMS (ad es.) {"context-key": "context-value"}

  • --profile— Il profilo AWS CLI da utilizzare (il profilo cli-user creato in precedenza)

Una volta creato correttamente, il comando restituisce i dettagli dell'integrazione, inclusi l'ARN di integrazione, lo stato e i parametri di configurazione. Output di esempio: 

{
    "SourceArn": "arn:aws:dms:region:account-id:endpoint:endpoint-id",
    "TargetArn": "arn:aws:redshift:region:account-id:namespace:namespace-id",
    "IntegrationName": "mysql-onprem-integration",
    "IntegrationArn": "arn:aws:glue:region:account-id:integration:integration-id",
    "KmsKeyId": "arn:aws:kms:region:account-id:key/key-id",
    "AdditionalEncryptionContext": {
	  "context-key": "context-value"
    },
    "Status": "CREATED",
    "CreateTime": 1763234086.001,
    "DataFilter": "include: mysql.*",
    "IntegrationConfig": {
        "SourceProperties": {
            "SubnetIds": "subnet-id1,subnet-id2,subnet-id3",
            "VpcSecurityGroupIds": "sg-id"
        }
    }
}

Best practice di sicurezza

Segui queste best practice di sicurezza quando configuri le integrazioni Zero-ETL:

  • Utilizza l'accesso con privilegi minimi: concedi solo le autorizzazioni minime richieste per creare e gestire le integrazioni. Prendi in considerazione l'utilizzo di autorizzazioni a livello di risorsa laddove possibile.

  • Abilita la crittografia: utilizza sempre le AWS KMS chiavi gestite dal cliente per crittografare i dati di integrazione. Specifica il contesto di crittografia per una maggiore sicurezza.

  • Ruota le credenziali regolarmente: se utilizzi le chiavi di accesso utente IAM, ruotale regolarmente. Prendi in considerazione invece l'utilizzo di ruoli IAM con credenziali temporanee.

  • Monitora l'accesso: AWS CloudTrail da utilizzare per monitorare le chiamate API relative alla creazione e alla gestione dell'integrazione.

  • Limita l'accesso alla rete: configura i gruppi di sicurezza VPC per limitare l'accesso alla rete solo alle risorse necessarie.

  • Utilizza le politiche sulle risorse: implementa le politiche sulle risorse di Amazon Redshift per controllare quali fonti possono creare integrazioni con il tuo data warehouse.

  • Assegna tag alle risorse: applica i tag alle integrazioni e alle risorse correlate per una migliore organizzazione e monitoraggio dei costi.