$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 22:44:49 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 11.00 KByte/s
Instance(s):
ORCL
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | | Modifica l'impostazione del trasporto dei log connettendoti a DGMGRL dal nodo primario. | Cambia la modalità di trasporto dei log in`FastSync`, corrispondente all'impostazione di redo transport. `SYNC+NOAFFIRM` Per assicurarti di avere impostazioni valide dopo il cambio di ruolo, modificale sia per il database primario che per il database di standby.**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 20:24:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
DGMGRL>**CDB**
DGMGRL> edit database orcl_d set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_d LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database orcl_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;| DBA | | Cambia la modalità di protezione in. MaxAvailability | Cambia la modalità di protezione in `MaxAvailability` collegandoti a `DGMGRL` dal nodo principale.**Non CDB**
Property "logxptmode" updated
DGMGRL> show database rdscdb_b LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database rdscdb_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database rdscdb_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit configuration set protection mode as maxavailability;**CDB**
Succeeded.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 38 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | ### Modifica lo stato della replica da mount a read-only e abilita Redo Apply | Operazione | Description | Competenze richieste | | --- | --- | --- | | Stop Redo Apply per il database in standby. | Per impostazione predefinita, la replica di lettura viene creata in `MOUNT` modalità. Per aprirla in modalità di sola lettura, è innanzitutto necessario disattivare Redo Apply collegandosi a `DGMGRL` dal nodo primario o di standby.**Non CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL>
DGMGRL> show database orcl_dDGMGRL> show database orcl_d**CDB**
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 11.00 KByte/s
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL> edit database orcl_d set state=apply-off;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 42 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
DGMGRL> show configurationDGMGRL> show configuration| DBA | | Aprire l'istanza di lettura della replica in modalità di sola lettura. | Connettiti al database di standby utilizzando la voce TNS e aprilo in modalità di sola lettura collegandoti al database dal nodo primario o di standby.**Non CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> edit database rdscdb_b set state=apply-off;
Succeeded.
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg**CDB**
-bash-4.2$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg
SQL*Plus: Release 19.0.0.0.0 - Production on Fri Sep 30 23:00:14 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2020, Oracle. All rights reserved.
Enter password:
Last Successful login time: Fri Sep 30 2022 22:48:27 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.10.0.0.0
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY
SQL>
-bash-4.2$ sqlplus C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B as sysdg| DBA | | Attiva redo apply sull'istanza di replica letta. | Attiva redo apply sull'istanza di replica letta utilizzando `DGMGR` L dal nodo primario o di standby.**Non CDB**
SQL*Plus: Release 19.0.0.0.0 - Production on Wed Jan 11 21:14:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2022, Oracle. All rights reserved.
Enter password:
Last Successful login time: Wed Jan 11 2023 21:12:05 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.16.0.0.0
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB READ ONLY
SQL>
$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 23:02:16 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
edit database orcl_d set state=apply-on;
DGMGRL> edit database orcl_d set state=apply-on;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 496.00 KByte/s
Real Time Query: ON
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | ## Risorse correlate + [Configurazione di Amazon RDS come PeopleSoft database Oracle (white paper](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) AWS) + [Guida Oracle Data Guard Broker (documentazione di riferimento](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) Oracle) + [Concetti e amministrazione di Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (documentazione di riferimento Oracle) ## Informazioni aggiuntive **Seleziona la modalità di protezione del database** Oracle Data Guard offre tre modalità di protezione per configurare l'ambiente Data Guard in base ai requisiti di disponibilità, protezione e prestazioni. La tabella seguente riassume queste tre modalità. | | | Modalità di protezione | Redo (impostazione di trasporto) | Description | | --- |--- |--- | | ***PRESTAZIONI MASSIME*** | `ASYNC` | Per le transazioni che avvengono sul database primario, i redo data vengono trasmessi e scritti in modo asincrono nel redo log del database di standby. Pertanto, l'impatto sulle prestazioni è minimo.`MaxPerformance`non è possibile fornire RPO=0 a causa della spedizione asincrona dei log. | | ***PROTEZIONE MASSIMA*** | `SYNC+AFFIRM` | Per le transazioni sul database primario, i redo data vengono trasmessi e scritti in modo sincrono sul redo log on del database di standby prima che la transazione venga confermata. Se il database in standby non è più disponibile, il database primario si chiude automaticamente per garantire la protezione delle transazioni. | | ***DISPONIBILITÀ MASSIMA*** | `SYNC+AFFIRM` | È simile alla `MaxProtection` modalità, tranne quando non viene ricevuta alcuna conferma dal database di standby. In tal caso, funziona come se fosse in `MaxPerformance` modalità tale da preservare la disponibilità del database primario fino a quando non sarà nuovamente in grado di scrivere il redo stream su un database di standby sincronizzato. | | `SYNC+NOAFFIRM` | Per le transazioni sul database primario, il ripristino viene trasmesso in modo sincrono al database di standby e il primario attende solo la conferma che il ripristino è stato ricevuto in standby e non che è stato scritto sul disco di standby. Questa modalità, nota anche come`FastSync`, può offrire un vantaggio in termini di prestazioni a scapito della potenziale esposizione alla perdita di dati in un caso speciale di più errori simultanei. | Le repliche di lettura in RDS Custom for Oracle vengono create con la modalità di protezione delle massime prestazioni, che è anche la modalità di protezione predefinita per Oracle Data Guard. La modalità a prestazioni massime offre il minor impatto sulle prestazioni sul database primario, il che può aiutarti a soddisfare il requisito RPO (Recovery Point Objective) misurato in secondi. Per raggiungere l'obiettivo di zero perdite di dati (RPO=0), è possibile personalizzare la modalità di protezione di Oracle Data Guard `MaxAvailability` con l'`SYNC+NOAFFIRM`impostazione Redo Transport per migliorare le prestazioni. Poiché i commit sul database primario vengono riconosciuti solo dopo che i vettori di ripristino corrispondenti sono stati trasmessi correttamente al database di standby, la latenza di rete tra l'istanza principale e la replica può essere fondamentale per i carichi di lavoro sensibili al commit. Si consiglia di eseguire test di carico per il carico di lavoro per valutare l'impatto sulle prestazioni quando la replica di lettura è personalizzata per l'esecuzione in modalità. `MaxAvailability` L'implementazione della replica di lettura nella stessa zona di disponibilità del database principale offre una latenza di rete inferiore rispetto alla distribuzione della replica di lettura in una zona di disponibilità diversa. Tuttavia, l'implementazione della replica primaria e di lettura nella stessa zona di disponibilità potrebbe non soddisfare i requisiti di disponibilità elevata perché, nell'improbabile caso di indisponibilità della zona di disponibilità, ne risentono sia l'istanza principale che l'istanza di replica di lettura. # Analizza le dipendenze degli oggetti per le migrazioni parziali del database da Oracle a PostgreSQL *Nome utente, Amazon Web Services* ## Riepilogo Questo modello descrive l'importanza di identificare e gestire sistematicamente le dipendenze del sistema durante la migrazione di un database Oracle parziale su Amazon Relational Database Service (Amazon RDS) o Amazon Aurora PostgreSQL. In una migrazione parziale, viene migrato solo un sottoinsieme di oggetti e dati del database originale, mentre il database di origine continua a funzionare e servire applicazioni che dipendono da componenti non migrati È necessario identificare e analizzare l'ambito della migrazione quando si gestiscono database su larga scala con applicazioni strettamente collegate con dipendenze upstream e downstream. Per iniziare una migrazione parziale, identificate gli oggetti dell'ambito, tra cui tabelle, trigger, viste, stored procedure, funzioni e pacchetti. Il processo di identificazione dell'ambito segue un approccio globale: + Gli oggetti dell'ambito di primo livello vengono identificati tramite riferimenti diretti nel codice dell'applicazione e nei lavori critici specifici del modulo. + Gli oggetti di secondo livello sono derivati attraverso un'analisi completa delle dipendenze. Una volta compreso come interagiscono le diverse parti del sistema, è possibile pianificare meglio l'ordine corretto per lo spostamento dei componenti del database e ridurre il rischio di errori di migrazione. La tabella seguente elenca diversi tipi di analisi delle dipendenze. | | | Tipo di analisi | Aree di interesse | Scopo | | --- |--- |--- | | Dipendenze dagli oggetti | TabelleVisualizzazioniProcedure archiviateFunzioniTriggers | Identifica le relazioni tra gli oggetti del database e le relative strutture gerarchiche | | Dipendenze dei segmenti | Relazioni con chiave esternaPortachiavi primariRiferimenti tra schemi | Mappa le relazioni tra i dati e mantiene l'integrità referenziale | | Dipendenze di sicurezza | Autorizzazioni degli utentiGerarchie di ruoliPrivilegi degli oggetti | Garantisce il corretto controllo degli accessi, la migrazione e la manutenzione della sicurezza | | Modelli di accesso | Operazioni di letturaOperazioni di scrittura | Determina i modelli di interazione del database | Per mantenere la coerenza tra i sistemi di origine e di destinazione, stabilisci meccanismi di sincronizzazione dei dati durante il periodo di transizione. È inoltre necessario modificare il codice e le funzioni dell'applicazione per gestire la distribuzione dei dati tra i database Oracle di origine e PostgreSQL di destinazione. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS + Un database Oracle (origine) + Un Amazon RDS o Amazon Aurora PostgreSQL (destinazione) **Versioni del prodotto** + Oracle 19c o versioni successive + PostgreSQL 16 o versione successiva ## Architecture **Stack tecnologico di origine** + Oracle 19c o versione successiva **Stack tecnologico Target** + Amazon RDS o Amazon Aurora PostgreSQL **Architettura Target** Il diagramma seguente mostra il processo di migrazione da un database Oracle locale ad Amazon RDS for Oracle, che prevede quanto segue: + Identificazione delle dipendenze del database + Migrazione del codice e degli oggetti del database utilizzando AWS Schema Conversion Tool ()AWS SCT + Migrazione dei dati utilizzando AWS Database Migration Service ()AWS DMS + Replica delle modifiche in corso tramite Change Data Capture (CDC) utilizzando AWS DMS Per ulteriori informazioni, consulta [Integrazione AWS Database Migration Service con AWS Schema Conversion Tool nella documentazione](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_DMSIntegration.html). AWS ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/90160825-3199-4382-95a8-ad63139c5c89/images/b09c36a4-27fa-412e-877e-57a31bcce0dc.png) ## Tools (Strumenti) **Servizi AWS** + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html)) per Oracle ti aiuta a configurare, gestire e scalare un database relazionale Oracle in. Cloud AWS + Amazon Aurora è un motore di database relazionale completamente gestito creato per il cloud e compatibile con MySQL e PostgreSQL. + AWS Schema Conversion Tool (AWS SCT) supporta migrazioni di database eterogenee convertendo automaticamente lo schema del database di origine e la maggior parte del codice personalizzato in un formato compatibile con il database di destinazione. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) consente di migrare gli archivi di dati all'interno Cloud AWS o tra combinazioni di configurazioni cloud e locali. **Altri servizi** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) è un ambiente di sviluppo integrato che semplifica lo sviluppo e la gestione dei database Oracle nelle implementazioni tradizionali e basate sul cloud. [Per questo modello, è possibile utilizzare SQL\$1Plus.](https://docs.oracle.com/cd/B19306_01/server.102/b14357/qstart.htm) ## Best practice Per le best practice relative al provisioning e alla migrazione di un database Oracle, consulta [Best practice per la migrazione ad Amazon RDS for](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html) Oracle. ## Epiche ### Identifica le dipendenze degli oggetti | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una tabella di oggetti. | Identifica gli oggetti essenziali per la funzionalità dell'applicazione e crea una tabella denominata`DEPENDENT_ANALYSIS_BASELINE`. Aggiungi record per ogni oggetto alla tabella. Per un esempio, consulta la sezione *Informazioni aggiuntive*. | Ingegnere dei dati, DBA | | Crea una procedura di database. | Create una procedura memorizzata denominata `sp_object_dependency_analysis` per analizzare le dipendenze degli oggetti in entrambe le direzioni (avanti e indietro) utilizzando i dati della `DBA_DEPENDENCIES` tabella. Per un esempio, consultate la sezione *Informazioni aggiuntive*. | Ingegnere dei dati, DBA | | Esegui la procedura. | Esegui gli script a ogni livello successivo fino a quando non vengono trovate nuove dipendenze tra gli oggetti. Tutte le dipendenze e i livelli vengono memorizzati nella tabella. `DEPENDENT_ANALYSIS_BASELINE` | DBA, ingegnere dei dati | ### Crea una procedura per le dipendenze a livello di segmento | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una tabella delle dipendenze. | Crea una tabella delle dipendenze a livello di segmento denominata. `REFERENTIAL_ANALYSIS_BASELINE` Quando vengono scoperte tutte le dipendenze a livello di oggetto, controlla le tabelle principali interrogando la tabella. `DEPENDENT_ANALYSIS_BASELINE` `DBA_CONSTRAINT`Escludi le dipendenze in cui le tabelle di base sono referenziate da altre tabelle. Il backfilling gestisce queste relazioni. Quello che segue è uno script di esempio:
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 21:21:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL> edit database rdscdb_b set state=apply-on;
Succeeded.
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 35.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 16.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
CREATE TABLE REFERENTIAL_ANALYSIS_BASELINE| Ingegnere dei dati, DBA | | Crea una procedura di database. | Crea una procedura chiamata `SP_OBJECT_REFERENTIAL_ANALYSIS` e genera un'analisi referenziale per tutti gli oggetti identificati. Per un esempio, consultate la sezione *Informazioni aggiuntive*. | Ingegnere dei dati, DBA | | Esegui la procedura. | Esegui la procedura per ottenere dipendenze referenziali. Genera i dettagli dell'oggetto di analisi referenziale in. `REFERENTIAL_ANALYSIS_BASELINE` | Ingegnere dei dati, DBA | ### Identifica oggetti che leggono e scrivono | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea tabelle per leggere e scrivere oggetti. | Utilizzate il seguente script per creare una tabella di oggetti di lettura denominata `TABLE_READ_OBJECT_DETAILS` e una tabella di oggetti di scrittura denominata`TABLE_WRITE_OBJECT_DETAILS`:
(CHILD_OWNER VARCHAR2(50 BYTE),
CHILD_NAME VARCHAR2(100 BYTE),
PARENT_OWNER VARCHAR2(50 BYTE),
PARENT_NAME VARCHAR2(50 BYTE),
REFERENCE_PATH VARCHAR2(1000 BYTE));
CREATE TABLE TABLE_READ_OBJECT_DETAILS
(OWNER VARCHAR2(50 BYTE),
TAB_NAME VARCHAR2(50 BYTE),
READER_OWNER VARCHAR2(50 BYTE),
READER_NAME VARCHAR2(50 BYTE),
READER_TYPE VARCHAR2(50 BYTE));
CREATE TABLE TABLE_WRITE_OBJECT_DETAILS| Ingegnere dei dati, DBA | | Crea una procedura per l'analisi. | Create rispettivamente le procedure `SP_READER_OBJECTS_ANALYSIS` e `SP_WRITER_OBJECTS_ANALYSIS` quelle per l'analisi degli oggetti di lettura e degli oggetti di scrittura. Queste procedure utilizzano il pattern matching per trovare oggetti correlati. Per un esempio, consultate la sezione *Informazioni aggiuntive*. | Ingegnere dei dati, DBA | | Esegui le procedure. | Eseguite queste procedure per identificare gli oggetti dipendenti. | DBA, ingegnere dei dati | ### Rivedi i privilegi del database | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una tabella per la revisione dei privilegi. | Crea una tabella per analizzare i privilegi denominati. `OBJECT_PRIVS_ANALYSIS` Per acquisire in modo ricorsivo i privilegi degli oggetti nella `DEPENDENT_ANALYSIS_BASELINE` tabella, utilizzate lo script seguente:
(TABLE_NAME VARCHAR2(100 BYTE),
WRITEOBJ_OWNER VARCHAR2(100 BYTE),
WRITEOBJ_NAME VARCHAR2(100 BYTE),
WRITEOBJ_TYPE VARCHAR2(100 BYTE),
LINE VARCHAR2(100 BYTE),
TEXT VARCHAR2(4000 BYTE),
OWNER VARCHAR2(50 BYTE));
CREATE TABLE OBJECT_PRIVS_ANALYSIS| Ingegnere dei dati, DBA | | Creare una procedura per la revisione dei privilegi. | Crea una procedura denominata`SP_OBJECT_PRIVS_ANALYSIS`. Genera un'analisi dei privilegi per gli oggetti identificati. Per un esempio, consulta la sezione *Informazioni aggiuntive*. | DBA, ingegnere dei dati | | Esegui la procedura. | Esegui la procedura per acquisirli nella `OBJECT_PRIVS_ANALYSIS` tabella. | DBA, ingegnere dei dati | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Impossibile accedere alle tabelle dei dizionari | Assicuratevi che l'utente che ha creato gli oggetti di analisi possa accedere alle tabelle DBA. | ## Risorse correlate **Documentazione AWS** + [Documentazione di Amazon RDS e Aurora](https://docs.aws.amazon.com/rds/) + [Playbook di migrazione da Oracle Database 19c ad Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) + [AWS Database Migration Service Che cos'è?](https://docs.aws.amazon.com/dms/latest/userguide/) + [Cos'è AWS Schema Conversion Tool?](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/) **Altra documentazione** + [Oggetti del database Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Database-Objects.html) ## Informazioni aggiuntive **Script per `DEPENDENT_ANALYSIS_BASELINE`** ``` CREATE TABLE DEPENDENT_ANALYSIS_BASELINE (OWNER VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_NAME VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_TYPE VARCHAR2(20 BYTE), DEPEDNCY_LEVEL NUMBER, PROJECT_NEED VARCHAR2(20 BYTE), CATAGORY VARCHAR2(4000 BYTE), COMMENTS VARCHAR2(4000 BYTE), CATAGORY1 CLOB, COMMENTS1 CLOB, CUSTOMER_COMMENTS VARCHAR2(1000 BYTE), BACKFILL_TO_GUS VARCHAR2(1000 BYTE), BACKFILL_NEAR_REAL_TIME_OR_BATCH VARCHAR2(1000 BYTE), PK_EXISTS VARCHAR2(3 BYTE), UI_EXISTS VARCHAR2(3 BYTE), LOB_EXISTS VARCHAR2(3 BYTE), MASTER_LINK VARCHAR2(100 BYTE), CONSTRAINT PK_DEPENDENT_ANALYSIS_BASELINE PRIMARY KEY (OWNER,OBJECT_NAME,OBJECT_TYPE)); ``` **Procedura per `SP_WRITER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_WRITER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_WRITE_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_WRITE_OBJECT_DETAILS(OWNER, TABLE_NAME, WRITEOBJ_OWNER, WRITEOBJ_NAME, WRITEOBJ_TYPE, LINE, TEXT) SELECT DISTINCT I.OWNER, I.OBJECT_NAME, OWNER WRITEOBJ_OWNER, NAME, TYPE, LINE, TRIM(TEXT) FROM DBA_SOURCE WHERE UPPER(TEXT) LIKE '%' || I.OBJECT_NAME || '%' AND (UPPER(TEXT) LIKE '%INSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPDATE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%DELETE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%MERGE%' || I.OBJECT_NAME || '%') AND UPPER(TEXT) NOT LIKE '%PROCEDURE%' AND UPPER(TEXT) NOT LIKE 'PROCEDURE%' AND UPPER(TEXT) NOT LIKE '%FUNCTION%' AND UPPER(TEXT) NOT LIKE 'FUNCTION%' AND UPPER(TEXT) NOT LIKE '%TRIGGER%' AND UPPER(TEXT) NOT LIKE 'TRIGGER%' AND UPPER(TRIM(TEXT)) NOT LIKE '%AFTER UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE '%GGLOGADM.GG_LOG_ERROR%' AND (TRIM(TEXT) NOT LIKE '/*%' AND TRIM(TEXT) NOT LIKE '--%' ) AND (OWNER, NAME, TYPE) IN (SELECT OWNER, NAME, TYPE FROM DBA_DEPENDENCIES WHERE REFERENCED_NAME = I.OBJECT_NAME); END LOOP; END; ``` **Script per `SP_READER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_READER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_READ_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_READ_OBJECT_DETAILS SELECT DISTINCT i.owner, i.object_name, owner, name, type FROM dba_dependencies WHERE referenced_name = I.OBJECT_NAME AND referenced_type = 'TABLE' AND type NOT IN ('SYNONYM', 'MATERIALIZED VIEW', 'VIEW') AND (owner, name, type) NOT IN ( SELECT DISTINCT owner, trigger_name, 'TRIGGER' FROM dba_triggers WHERE table_name = I.OBJECT_NAME AND table_owner = i.owner UNION ALL SELECT DISTINCT owner, name, type FROM dba_source WHERE upper(text) LIKE '%' || I.OBJECT_NAME || '%' AND (upper(text) LIKE '%INSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPDATE% ' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%DELETE %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%MERGE %' || I.OBJECT_NAME || '%') AND upper(text) NOT LIKE '%PROCEDURE %' AND upper(text) NOT LIKE 'PROCEDURE %' AND upper(text) NOT LIKE '%FUNCTION %' AND upper(text) NOT LIKE 'FUNCTION %' AND upper(text) NOT LIKE '%TRIGGER %' AND upper(text) NOT LIKE 'TRIGGER %' AND upper(trim(text)) NOT LIKE 'BEFORE INSERT %' AND upper(trim(text)) NOT LIKE 'BEFORE UPDATE %' AND upper(trim(text)) NOT LIKE 'BEFORE DELETE %' AND upper(trim(text)) NOT LIKE 'AFTER INSERT %' AND upper(trim(text)) NOT LIKE 'AFTER UPDATE %' AND upper(trim(text)) NOT LIKE 'AFTER DELETE %' AND (trim(text) NOT LIKE '/*%' AND trim(text) NOT LIKE '--%')); END LOOP; END; ``` **Script per `SP_OBJECT_REFERENTIAL_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_REFERENTIAL_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE REFERENTIAL_ANALYSIS_BASELINE'; INSERT INTO REFERENTIAL_ANALYSIS_BASELINE WITH rel AS ( SELECT DISTINCT c.owner, c.table_name, c.r_owner r_owner, (SELECT table_name FROM dba_constraints WHERE constraint_name = c.r_constraint_name AND owner = c.r_owner) r_table_name FROM dba_constraints c WHERE constraint_type = 'R' AND c.owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y') AND c.r_owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y')), tab_list AS ( SELECT OWNER, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE UPPER(OBJECT_TYPE) = 'TABLE') SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(r_table_name, ' -> ') || ' -> ' || table_name PATH FROM rel START WITH (r_owner, r_table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (r_owner, r_table_name) = ((PRIOR owner, PRIOR table_name)) UNION SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(table_name, ' -> ') || ' -> ' || r_table_name PATH FROM rel START WITH (owner, table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (owner, table_name) = ((PRIOR r_owner, PRIOR r_table_name)); END; ``` **Script per `SP_OBJECT_PRIVS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_PRIVS_ANALYSIS IS V_SQL VARCHAR2(4000); V_CNT NUMBER; BEGIN V_SQL := 'TRUNCATE TABLE OBJECT_PRIVS_ANALYSIS'; EXECUTE IMMEDIATE V_SQL; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO OBJECT_PRIVS_ANALYSIS(OWNER, OBJECT_NAME, USER_NAME, PRIVS) WITH obj_to_role AS ( SELECT DISTINCT GRANTEE role_name, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS t, DBA_ROLES r WHERE OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME AND t.GRANTEE = r.ROLE AND r.ROLE IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') ) SELECT I.OWNER, I.OBJECT_NAME, grantee, privs FROM ( -- Recursively Role to User mapping with privilege SELECT DISTINCT grantee, privs FROM (SELECT rp.granted_role, rp.grantee, privs, (SELECT DECODE(COUNT(*), 0, 'ROLE', 'USER') FROM (SELECT 'User' FROM DBA_users WHERE username = rp.GRANTEE)) grantee_type FROM DBA_role_privs rp, obj_to_role r WHERE rp.granted_role = r.role_name AND grantee IN ((SELECT USERNAME FROM DBA_USERS WHERE ORACLE_MAINTAINED = 'N') UNION (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N')) AND granted_role IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') START WITH granted_role IN (SELECT DISTINCT role_name FROM obj_to_role) CONNECT BY granted_role = PRIOR grantee) WHERE grantee_type = 'USER' ) UNION ( -- Direct Object grants to User SELECT I.OWNER, I.OBJECT_NAME, GRANTEE, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS, DBA_USERS WHERE GRANTEE = USERNAME AND OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME ) ORDER BY 2 DESC; END LOOP; END; ``` **Procedura per `SP_OBJECT_DEPENDENCY_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_DEPENDENCY_ANALYSIS (v_level NUMBER) IS TYPE typ IS RECORD ( schema VARCHAR2(100), obj_type VARCHAR2(100), obj_name VARCHAR2(100), path VARCHAR2(5000) ); TYPE array IS TABLE OF typ; l_data array; c SYS_REFCURSOR; l_errors NUMBER; l_errno NUMBER; l_msg VARCHAR2(4000); l_idx NUMBER; l_level NUMBER; BEGIN l_level := v_level + 1; OPEN c FOR WITH obj_list AS ( SELECT owner schema_name, object_type, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE depedncy_level = v_level ), fw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' -> ') || ' -> ' || referenced_name PATH FROM dba_dependencies START WITH (owner, CASE WHEN type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE type END, name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (owner, type, name) = ((PRIOR referenced_owner, PRIOR referenced_type, PRIOR referenced_name)) ), bw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' <- ') || ' <- ' || referenced_name PATH FROM dba_dependencies START WITH (referenced_owner, CASE WHEN referenced_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE referenced_type END, referenced_name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (referenced_owner, referenced_type, referenced_name) = ((PRIOR owner, PRIOR type, PRIOR name)) ) SELECT * FROM ( (SELECT DISTINCT referenced_owner schema, referenced_type obj_type, referenced_name obj_name, path FROM fw_dep_objects) UNION (SELECT DISTINCT owner schema, type obj_type, name obj_name, path FROM bw_dep_objects) ) WHERE schema IN (SELECT username FROM all_users WHERE oracle_maintained = 'N') ORDER BY obj_type; LOOP FETCH c BULK COLLECT INTO l_data LIMIT 100; BEGIN FORALL i IN 1..l_data.count SAVE EXCEPTIONS INSERT INTO DEPENDENT_ANALYSIS_BASELINE ( owner, object_name, object_type, catagory, depedncy_level, project_need, comments ) VALUES ( l_data(i).schema, l_data(i).obj_name, CASE WHEN l_data(i).obj_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE l_data(i).obj_type END, 'level ' || l_level || ' dependency', l_level, '', 'from dependency proc' || l_data(i).path ); EXCEPTION WHEN OTHERS THEN l_errors := sql%bulk_exceptions.count; FOR i IN 1..l_errors LOOP l_errno := sql%bulk_exceptions(i).error_code; l_msg := SQLERRM(-l_errno); l_idx := sql%bulk_exceptions(i).error_index; UPDATE DEPENDENT_ANALYSIS_BASELINE SET catagory1 = catagory1 || ', found in level' || l_level || ' dependent of ' || l_data(l_idx).path, comments1 = comments1 || ', from dependency proc exception ' || l_data(i).path WHERE owner = l_data(l_idx).schema AND object_name = l_data(l_idx).obj_name AND object_type = l_data(l_idx).obj_type; END LOOP; END; EXIT WHEN c%NOTFOUND; END LOOP; CLOSE c; END; ``` # Valuta le prestazioni delle query per la migrazione dei database SQL Server su MongoDB Atlas su AWS *Battulga Purevragcha, Amazon Web Services* *Krishnakumar PeerIslands Sathyanarayana, US Inc* *Babu Srinivasan, MongoDB* ## Riepilogo Questo modello fornisce indicazioni per caricare MongoDB con dati simili a quelli reali e valutare le prestazioni delle query di MongoDB che si avvicinano il più possibile allo scenario di produzione. La valutazione fornisce input per aiutarti a pianificare la migrazione a MongoDB da un database relazionale. Il modello utilizza [PeerIslands Test Data Generator e Performance Analyzer per testare le prestazioni delle](https://tools.peerislands.io/) query. Questo modello è particolarmente utile per la migrazione di Microsoft SQL Server a MongoDB, poiché eseguire trasformazioni dello schema e caricare dati dalle istanze correnti di SQL Server a MongoDB può essere molto complesso. Invece, puoi caricare dati quasi reali in MongoDB, comprendere le prestazioni di MongoDB e perfezionare la progettazione dello schema prima di iniziare la migrazione vera e propria. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Familiarità con [MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) + Schema MongoDB di destinazione + Schemi di interrogazione tipici **Limitazioni** + I tempi di caricamento dei dati e le prestazioni saranno limitati dalla dimensione dell'istanza del cluster MongoDB. Ti consigliamo di scegliere istanze consigliate per l'uso in produzione per comprendere le prestazioni del mondo reale. + PeerIslands Test Data Generator and Performance Analyzer attualmente supportano solo caricamenti e interrogazioni di dati online. L'elaborazione batch offline (ad esempio, il caricamento di dati in MongoDB utilizzando i connettori Spark) non è ancora supportata. + PeerIslands Test Data Generator and Performance Analyzer supportano le relazioni tra campi all'interno di una raccolta. Non supporta le relazioni tra le raccolte. **Edizioni del prodotto** + [Questo modello supporta sia [MongoDB Atlas che MongoDB Enterprise Advanced](https://www.mongodb.com/atlas).](https://www.mongodb.com/products/mongodb-enterprise-advanced) ## Architecture **Stack tecnologico Target** + MongoDB Atlas o MongoDB Enterprise Advanced **Architettura** ![\[Architettura per valutare le prestazioni delle query per la migrazione del database SQL Server a MongoDB Atlas su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/25f0ab73-d587-4bd0-9fc0-ac675d5aa349/images/717caae4-d52e-4c78-bb7d-2ecb5acccd42.png) PeerIslands Test Data Generator and Performance Analyzer è stato creato utilizzando Java e Angular e archivia i dati generati su Amazon Elastic Block Store (Amazon EBS). Lo strumento è composto da due flussi di lavoro: generazione di dati di test e test delle prestazioni. + Nella generazione dei dati di test, si crea un modello, che è la rappresentazione JSON del modello di dati che deve essere generato. Dopo aver creato il modello, è possibile generare i dati in una raccolta di destinazione, come definito dalla configurazione di generazione del carico. + Nei test delle prestazioni, si crea un profilo. Un profilo è uno scenario di test in più fasi in cui è possibile configurare le operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD), le pipeline di aggregazione, il peso per ogni operazione e la durata di ogni fase. Dopo aver creato il profilo, è possibile eseguire test delle prestazioni sul database di destinazione in base alla configurazione. PeerIslands Test Data Generator and Performance Analyzer archivia i dati su Amazon EBS, in modo da poter connettere Amazon EBS a MongoDB utilizzando qualsiasi meccanismo di connessione supportato da MongoDB, tra cui peering, elenchi di autorizzazione ed endpoint privati. Per impostazione predefinita, lo strumento non include componenti operativi; tuttavia, può essere configurato con Amazon Managed Service for Prometheus, Amazon Managed Grafana, Amazon CloudWatch e AWS Secrets Manager, se necessario. ## Tools (Strumenti) + [PeerIslands Test Data Generator and Performance Analyzer](https://tools.peerislands.io/) include due componenti. Il componente Test Data Generator ti aiuta a generare dati reali altamente specifici per il cliente in base al tuo schema MongoDB. Lo strumento è completamente basato sull'interfaccia utente con una ricca libreria di dati e può essere utilizzato per generare rapidamente miliardi di record su MongoDB. Lo strumento fornisce anche funzionalità per implementare relazioni tra i campi nello schema MongoDB. Il componente Performance Analyzer ti aiuta a generare query e aggregazioni altamente specifiche per il cliente ed eseguire test realistici delle prestazioni su MongoDB. Puoi utilizzare Performance Analyzer per testare le prestazioni di MongoDB con profili di carico avanzati e query parametrizzate per il tuo caso d'uso specifico. ## Best practice Consulta le seguenti risorse: + [Best practice per la progettazione di schemi MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (sito Web per sviluppatori MongoDB) + [Best practice per la distribuzione di MongoDB Atlas su AWS (sito Web MongoDB)](https://www.mongodb.com/presentation/best-practices-of-deploying-mongodb-atlas-on-aws) + [Connessione sicura delle applicazioni a un piano dati MongoDB Atlas con AWS PrivateLink (post sul blog AWS](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/)) + [Guida alle migliori pratiche per le prestazioni di MongoDB (sito Web MongoDB](https://www.mongodb.com/basics/best-practices)) ## Epiche ### Comprendi i tuoi dati di origine | Operazione | Description | Competenze richieste | | --- | --- | --- | | Comprendi l'impronta del database dell'attuale sorgente di SQL Server. | Comprendi il tuo attuale footprint di SQL Server. Ciò può essere ottenuto eseguendo query sullo `INFORMATION` schema del database. Determina il numero di tabelle e le dimensioni di ciascuna tabella. Analizza l'indice associato a ciascuna tabella. Per ulteriori informazioni sull'analisi SQL, consulta il post di blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) sul PeerIslands sito Web. | DBA | | Comprendi lo schema sorgente. | Determina lo schema della tabella e la rappresentazione aziendale dei dati (ad esempio codici postali, nomi e valuta). Utilizza il diagramma ER (Entity Relationship) esistente o genera il diagramma ER dal database esistente. Per ulteriori informazioni, consulta il post del blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) sul sito web. PeerIslands | DBA | | Comprendi i modelli di interrogazione. | Documenta le 10 principali query SQL che utilizzi. Puoi utilizzare le tabelle **performance\$1schema.events\$1statements\$1summary\$1by\$1digest disponibili nel database per comprendere le query** principali. Per ulteriori informazioni, consulta il post del blog Mongo: Data Migration [Journey sul SQL2 sito](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) PeerIslands web. | DBA | | Comprendi gli impegni SLA. | Documenta gli accordi sui livelli di servizio (SLAs) previsti per le operazioni del database. Le misure tipiche includono la latenza delle query e le query al secondo. Le misure e i relativi obiettivi sono in genere disponibili nei documenti sui requisiti non funzionali (NFR). | DBA | ### Definire lo schema MongoDB | Operazione | Description | Competenze richieste | | --- | --- | --- | | Definire lo schema di destinazione. | Definisci varie opzioni per lo schema MongoDB di destinazione. Per ulteriori informazioni, consulta [Schemi nella documentazione](https://www.mongodb.com/docs/atlas/app-services/schemas/) di MongoDB Atlas. Considerate le migliori pratiche e i modelli di progettazione basati sulle relazioni tra tabelle. | Ingegnere MongoDB | | Definisci modelli di query target. | Definisci le query e le pipeline di aggregazione di MongoDB. Queste query sono l'equivalente delle principali query acquisite per il carico di lavoro di SQL Server. [Per capire come costruire pipeline di aggregazione MongoDB, consulta la documentazione di MongoDB.](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) | Ingegnere MongoDB | | Definire il tipo di istanza MongoDB. | Determina la dimensione dell'istanza che intendi utilizzare per il test. Per informazioni, consulta la documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/). | Ingegnere MongoDB | ### Preparare il database di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura il cluster MongoDB Atlas. | [Per configurare un cluster MongoDB su AWS, segui le istruzioni nella documentazione di MongoDB.](https://www.mongodb.com/docs/atlas/tutorial/create-new-cluster/) | Ingegnere MongoDB | | Crea utenti nel database di destinazione. | [Configura il cluster MongoDB Atlas per l'accesso e la sicurezza della rete seguendo le istruzioni nella documentazione di MongoDB.](https://www.mongodb.com/docs/atlas/connect-to-database-deployment/) | Ingegnere MongoDB | | Crea ruoli appropriati in AWS e configura il controllo degli accessi basato sui ruoli per Atlas. | Se necessario, configura altri utenti seguendo le istruzioni nella documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/security/set-up-unified-aws-access/). Configura [l'autenticazione e l'autorizzazione](https://www.mongodb.com/docs/atlas/security/config-db-auth/) tramite i ruoli AWS. | Ingegnere MongoDB | | Configura Compass per l'accesso a MongoDB Atlas. | Configura l'utilità [MongoDB Compass GUI](https://www.mongodb.com/products/compass) per facilitare la navigazione e l'accesso. | Ingegnere MongoDB | ### Imposta il carico di base utilizzando Test Data Generator | Operazione | Description | Competenze richieste | | --- | --- | --- | | Installa Test Data Generator. | Installa [PeerIsland Test Data Generator](https://github.com/PeerIslands/loadgen_binary) nel tuo ambiente. | Ingegnere MongoDB | | Configura Test Data Generator per generare i dati appropriati. | Crea un modello utilizzando la libreria di dati per generare dati specifici per ogni campo dello schema MongoDB. Per ulteriori informazioni, consulta [MongoDB Data Generator & Perf. Video sull'analizzatore.](https://vimeo.com/570068857) | Ingegnere MongoDB | | Generatore di dati di test scalabile orizzontalmente per generare il carico richiesto. | Utilizza il modello che hai creato per avviare la generazione del carico sulla raccolta di destinazione configurando il parallelismo richiesto. Determina i tempi e la scala per generare i dati necessari. | Ingegnere MongoDB | | Convalida il carico in MongoDB Atlas. | Controlla i dati caricati in MongoDB Atlas. | Ingegnere MongoDB | | Genera gli indici richiesti su MongoDB. | Definisci gli indici come richiesto, in base ai modelli di query. Per le best practice, consulta la documentazione di [MongoDB](https://www.mongodb.com/docs/manual/applications/indexes/). | Ingegnere MongoDB | ### Effettuare test delle prestazioni | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura i profili di carico in Performance Analyzer. | Crea un profilo di test delle prestazioni in Performance Analyzer configurando query specifiche e il peso, la durata dell'esecuzione del test e le fasi corrispondenti. Per ulteriori informazioni, consulta [MongoDB Data Generator & Perf. Video sull'analizzatore.](https://vimeo.com/570068857) | Ingegnere MongoDB | | Esegui test delle prestazioni. | Utilizza il profilo di test delle prestazioni che hai creato per avviare il test rispetto alla raccolta target configurando il parallelismo richiesto. Scala orizzontalmente lo strumento di test delle prestazioni per eseguire query su MongoDB Atlas. | Ingegnere MongoDB | | Registra i risultati dei test. | Registra la latenza P95, P99 per le query. | Ingegnere MongoDB | | Ottimizza lo schema e i modelli di query. | Modifica gli indici e i modelli di query per risolvere eventuali problemi di prestazioni. | Ingegnere MongoDB | ### Chiudi il progetto | Operazione | Description | Competenze richieste | | --- | --- | --- | | Chiudi le risorse AWS temporanee. | Elimina tutte le risorse temporanee utilizzate per Test Data Generator e Performance Analyzer. | Amministratore AWS | | Aggiorna i risultati dei test delle prestazioni. | Comprendi le prestazioni delle query di MongoDB e confrontale con le tue. SLAs Se necessario, perfeziona lo schema MongoDB ed esegui nuovamente il processo. | Ingegnere MongoDB | | Concludi il progetto. | Chiudi il progetto e fornisci feedback. | Ingegnere MongoDB | ## Risorse correlate + GitHub [archivio: S3ToAtlas](https://github.com/mongodb-partners/S3toAtlas) + Schema: progettazione dello schema [MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) + [Pipeline di aggregazione: pipeline di aggregazione MongoDB](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) + [Dimensionamento MongoDB Atlas: selezione del livello di dimensionamento](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) + Video: Generatore di [dati MongoDB](https://vimeo.com/570068857) e Perf. Analizzatore + Riferimenti: documentazione [MongoDB](https://www.mongodb.com/docs/) + [Tutorial: guida per sviluppatori MongoDB, MongoDB****[Jumpstart](https://www.mongodb.com/docs/develop-applications/)](https://www.youtube.com/playlist?list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) + AWS Marketplace:**** [MongoDB Atlas](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) su AWS Marketplace + Soluzioni per partner AWS:**** [MongoDB Atlas sulla](https://aws.amazon.com/quickstart/architecture/mongodb-atlas/) distribuzione di riferimento AWS Risorse aggiuntive: + [Analisi SQL](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) + [Forum della comunità di sviluppatori MongoDB](https://www.mongodb.com/community/forums/) + [Domande sull'ottimizzazione delle prestazioni di MongoDB](https://www.mongodb.com/developer/products/mongodb/performance-tuning-tips/) + [Analisi operativa con Atlas e Redshift](https://github.com/mongodb-partners/Atlas_to_Redshift) + [Modernizzazione delle applicazioni con MongoDB Atlas e AWS Elastic Beanstalk](https://github.com/mongodb-partners/MEANStack_with_Atlas_on_AWS_EB) # Automatizza le blue/green implementazioni dei database globali di Amazon Aurora utilizzando i principi IaC *Ishwar Chauthaiwale, ANKIT JAIN e Ramu Jagini, Amazon Web Services* ## Riepilogo La gestione degli aggiornamenti, delle migrazioni o degli sforzi di scalabilità dei database può essere difficile per le organizzazioni che eseguono carichi di lavoro critici sui database globali di [Amazon](https://aws.amazon.com/rds/aurora/global-database/) Aurora. Garantire che queste operazioni vengano eseguite senza interruzioni, senza interruzioni, è essenziale per mantenere la disponibilità del servizio ed evitare interruzioni per gli utenti. Una strategia di blue/green implementazione offre una soluzione a questa sfida in quanto consente di eseguire due ambienti identici contemporaneamente: blu (l'ambiente corrente) e verde (il nuovo ambiente). Una blue/green strategia consente di implementare modifiche, eseguire test e spostare il traffico tra ambienti con rischi e tempi di inattività minimi. Questo modello consente di automatizzare il processo di blue/green distribuzione per i database globali Aurora utilizzando i principi dell'infrastruttura come codice (IaC). Utilizza [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)Amazon Route 53 e [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) per semplificare le blue/green distribuzioni. [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) Per migliorare l'affidabilità, utilizza gli identificatori di transazione globali (GTIDs) per la replica. La replica basata su GTID offre una migliore coerenza dei dati e funzionalità di failover tra ambienti rispetto alla replica con log binario (binlog). **Nota** Questo modello presuppone che si stia utilizzando un cluster di database globale Edition compatibile con Aurora MySQL. Se invece utilizzi Aurora compatibile con PostgreSQL, utilizza gli equivalenti PostgreSQL dei comandi MySQL. Seguendo i passaggi di questo schema, puoi: + Esegui il provisioning di un database globale Aurora verde: utilizzando CloudFormation i modelli, crei un ambiente verde che rispecchia l'ambiente blu esistente. + Imposta la replica basata su GTID: configuri la replica GTID per mantenere sincronizzati gli ambienti blu e verdi. + Cambia traffico senza interruzioni: utilizzi Route 53 e Lambda per passare automaticamente il traffico dall'ambiente blu a quello verde dopo la sincronizzazione completa. + Finalizza la distribuzione: verifichi che l'ambiente verde sia pienamente operativo come database principale, quindi interrompi la replica e pulisci eventuali risorse temporanee. L'approccio in questo modello offre i seguenti vantaggi: + Riduce i tempi di inattività durante gli aggiornamenti o le migrazioni critiche del database: l'automazione garantisce una transizione fluida tra gli ambienti con interruzioni minime del servizio. + Consente un ripristino rapido: se si verifica un problema dopo che il traffico è passato all'ambiente verde, è possibile tornare rapidamente all'ambiente blu e mantenere la continuità del servizio. + Migliora i test e le verifiche: l'ambiente verde può essere completamente testato senza influire sull'ambiente blu in tempo reale, il che riduce la probabilità di errori nella produzione. + Garantisce la coerenza dei dati: la replica basata su GTID mantiene sincronizzati gli ambienti blu e verde, prevenendo la perdita di dati o le incongruenze durante la migrazione. + Mantiene la continuità aziendale: l'automazione delle blue/green implementazioni aiuta a evitare lunghe interruzioni e perdite finanziarie mantenendo i servizi disponibili durante gli aggiornamenti o le migrazioni. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo. Account AWS + Un cluster di database globale di origine compatibile con Aurora MySQL (ambiente blu). I database globali forniscono una configurazione multiregionale per l'elevata disponibilità e il disaster recovery. Per istruzioni sulla configurazione di un cluster di database globale, consulta la documentazione di [Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html). + [Replica basata su GTID abilitata nel cluster di](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) origine. **Limitazioni** + Alcuni Servizi AWS non sono disponibili in tutti. Regioni AWS Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. **Versioni del prodotto** + Aurora, compatibile con MySQL 8.0 o versione successiva ## Architecture ![\[Utilizzo della replica GTID per sincronizzare ambienti blu e verdi in diverse regioni.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/19922266-c2e5-460b-9a0f-22e6d6736094/images/7a8c3095-7904-4080-906f-0c403c289a4f.png) Il diagramma illustra quanto segue: + Configurazione globale del database: un cluster di database globale Aurora viene distribuito strategicamente su due. Regioni AWS Questa configurazione consente la distribuzione geografica e la ridondanza regionale per funzionalità avanzate di disaster recovery. + Replica da regione primaria a regione secondaria: il meccanismo di replica logica garantisce una perfetta sincronizzazione dei dati dalla regione primaria alla regione secondaria. Questa replica mantiene la coerenza dei dati con una latenza minima su distanze geografiche. + Replica basata su GTID tra cluster: la replica basata su GTID mantiene la coerenza transazionale e il flusso di dati ordinato tra il cluster primario blu e il cluster primario verde e garantisce una sincronizzazione affidabile dei dati. + Replica blu da principale a secondaria: la replica logica stabilisce una solida pipeline di dati tra il cluster primario blu e il relativo cluster secondario. Questa replica consente la sincronizzazione continua dei dati e l'elevata disponibilità. + Configurazione DNS di Route 53: i record delle zone ospitate di Route 53 gestiscono la risoluzione DNS per tutti gli endpoint blu e verdi del database del cluster. Questa configurazione fornisce una mappatura degli endpoint senza interruzioni e consente un routing efficiente del traffico durante gli scenari di failover. ## Tools (Strumenti) **Servizi AWS** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) è un motore di database relazionale completamente gestito creato per il cloud e compatibile con MySQL e PostgreSQL. + [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a modellare e configurare AWS le tue risorse in modo da poter dedicare meno tempo alla gestione di tali risorse e più tempo a concentrarti sulle applicazioni in esecuzione. AWS Crei un modello che descrive tutte le AWS risorse che desideri e si CloudFormation occupa del provisioning e della configurazione di tali risorse per te. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)è un servizio di elaborazione che supporta l'esecuzione di codice senza fornire o gestire server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) è un servizio Web DNS altamente scalabile e disponibile. ## Best practice [Si consiglia di esaminare attentamente la AWS documentazione per approfondire la comprensione della [strategia di distribuzione blu/verde](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html), della [replica basata su GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) e delle politiche di routing ponderate in Route 53.](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Questa conoscenza è fondamentale per implementare e gestire efficacemente le migrazioni dei database, garantire la coerenza dei dati e ottimizzare il routing del traffico. Acquisendo una comprensione completa di queste AWS funzionalità e best practice, sarai meglio attrezzato per gestire gli aggiornamenti futuri, ridurre al minimo i tempi di inattività e mantenere un ambiente di database resiliente e sicuro. Per le linee guida sull'utilizzo di Servizi AWS for this pattern, consulta la seguente documentazione: AWS + [Le migliori pratiche con Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.BestPractices.html) + [CloudFormation migliori pratiche](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Le migliori pratiche per l'utilizzo delle AWS Lambda funzioni](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) + [Le migliori pratiche per Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/best-practices.html) ## Epiche ### Crea l'ambiente verde | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un backup istantaneo dal cluster blu. | In una blue/green distribuzione, l'ambiente verde rappresenta una nuova versione identica dell'ambiente di database corrente (blu). L'ambiente verde viene utilizzato per testare in sicurezza gli aggiornamenti, convalidare le modifiche e garantire la stabilità prima di passare al traffico di produzione. Funge da base di partenza per l'implementazione delle modifiche al database con interruzioni minime dell'ambiente live.Per creare un ambiente verde, devi prima creare un'istantanea del cluster primario (blu) nel database globale compatibile con Aurora MySQL. Questa istantanea funge da base per la creazione dell'ambiente verde.Per creare un'istantanea:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)In alternativa, puoi usare il AWS Command Line Interface (AWS CLI) per creare l'istantanea:
(OWNER VARCHAR2(50 BYTE),
OBJECT_NAME VARCHAR2(50 BYTE),
USER_NAME VARCHAR2(50 BYTE),
PRIVS VARCHAR2(50 BYTE));
aws rds create-db-cluster-snapshot --db-cluster-snapshot-identifier blue-green-demo --db-cluster-identifier ex-global-cluster --region eu-west-1Assicurati che l'istantanea sia stata completata correttamente prima di procedere al passaggio successivo. | DBA | | Genera il CloudFormation modello per il tuo database globale e le sue risorse. | Il generatore CloudFormation IAc consente di generare CloudFormation modelli a partire da AWS risorse esistenti. Usa questa funzionalità per creare un CloudFormation modello per il tuo database globale compatibile con Aurora MySQL esistente e le risorse associate. Questo modello configura gruppi di sottoreti, gruppi di sicurezza, gruppi di parametri e altre impostazioni.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Modifica il CloudFormation modello per l'ambiente verde. | Personalizza il CloudFormation modello in modo che rifletta le impostazioni per l'ambiente verde. Ciò include l'aggiornamento dei nomi e degli identificatori delle risorse per garantire che l'ambiente verde funzioni indipendentemente dal cluster blu.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se utilizzate la `SnapshotIdentifier` proprietà per ripristinare un cluster DB, evitate di specificare proprietà come `GlobalClusterIdentifier``MasterUsername`, o. `MasterUserPassword` | DBA | | Implementa lo CloudFormation stack per creare risorse per l'ambiente verde. | In questo passaggio, si distribuisce il CloudFormation modello personalizzato per creare le risorse per l'ambiente verde.Per distribuire lo stack: CloudFormation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)CloudFormation avvia il processo di creazione delle risorse ambientali verdi. Il completamento di questo processo potrebbe richiedere alcuni minuti. | DBA | | Convalida lo CloudFormation stack e le risorse. | Una volta completata l'implementazione CloudFormation dello stack, dovrai verificare che l'ambiente verde sia stato creato correttamente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Dopo la verifica, l'ambiente verde è pronto per un'ulteriore configurazione, inclusa la replica dall'ambiente blu. | DBA | ### Configura la replica basata su GTID | Operazione | Description | Competenze richieste | | --- | --- | --- | | Verifica le impostazioni GTID sul cluster blu. | GTIDs forniscono un metodo altamente affidabile per replicare i dati tra gli ambienti blu e verdi. La [replica basata su GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) offre un approccio resiliente e semplificato assegnando un identificatore univoco a ogni transazione nell'ambiente blu. Questo metodo garantisce che la sincronizzazione dei dati tra gli ambienti sia fluida, coerente e più facile da gestire rispetto alla tradizionale replica binlog.Prima di configurare la replica, è necessario assicurarsi che la replica basata su GTID sia abilitata correttamente sul cluster blu. Questo passaggio garantisce che ogni transazione nell'ambiente blu sia tracciata in modo univoco e possa essere replicata nell'ambiente verde.Per confermare che GTID è abilitato:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Queste impostazioni abilitano il tracciamento GTID per tutte le transazioni future nell'ambiente blu. Dopo aver confermato queste impostazioni, puoi iniziare a configurare la replica. | DBA | | Crea un utente di replica. | Per replicare i dati dall'ambiente blu all'ambiente verde, è necessario creare un utente di replica dedicato sul cluster blu. Questo utente sarà responsabile della gestione del processo di replica.Per configurare l'utente di replica:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Questo utente dispone ora delle autorizzazioni necessarie per replicare i dati tra i due ambienti. | DBA | | Configura la replica basata su GTID sul cluster verde. | Il passaggio successivo consiste nel configurare il cluster verde per la replica basata su GTID. Questa configurazione garantisce che l'ambiente verde rispecchi continuamente tutte le transazioni che avvengono nell'ambiente blu.Per configurare il cluster verde:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Avvia la replica sul cluster verde. | È ora possibile avviare il processo di replica. Sul cluster verde, esegui il comando:
START SLAVE;Ciò consente all'ambiente verde di iniziare a sincronizzare i dati e a ricevere e applicare transazioni dall'ambiente blu. | DBA | | Verifica il processo di replica. | Per verificare che l'ambiente verde stia replicando accuratamente i dati dal cluster blu:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se tutti gli indicatori sono corretti, la replica basata su GTID funziona senza problemi e l'ambiente verde è completamente sincronizzato con l'ambiente blu. | DBA | ### Passa il traffico dal cluster blu a quello verde | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura le politiche di routing ponderate di Route 53. | Dopo aver verificato la coerenza dei dati tra gli ambienti blu e verde, puoi spostare il traffico dal cluster blu al cluster verde. Questa transizione dovrebbe essere fluida e dovrebbe ridurre al minimo i tempi di inattività e garantire l'integrità del database dell'applicazione. Per soddisfare questi requisiti, puoi utilizzare Route 53 per il routing DNS e Lambda per automatizzare il cambio di traffico. Inoltre, un piano di rollback ben definito garantisce la possibilità di tornare al cluster blu in caso di problemi.Il primo passo consiste nel configurare il routing ponderato in Route 53. Il routing ponderato consente di controllare la distribuzione del traffico tra i cluster blu e verdi e di spostare gradualmente il traffico da un ambiente all'altro.Per configurare il routing ponderato:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Per ulteriori informazioni sulle politiche di routing ponderate, consulta la documentazione di [Route](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) 53. | AWS DevOps | | Implementa una funzione Lambda per monitorare il ritardo di replica. | Per garantire che l'ambiente verde sia completamente sincronizzato con l'ambiente blu, implementa una funzione Lambda che monitora il ritardo di replica tra i cluster. Questa funzione può controllare lo stato della replica, in particolare la metrica **Seconds\$1Behind\$1Master**, per determinare se il cluster verde è pronto a gestire tutto il traffico.Ecco un esempio di funzione Lambda che puoi usare:
import boto3Questa funzione controlla il ritardo di replica e restituisce il valore. Se il ritardo è zero, il cluster verde è completamente sincronizzato con il cluster blu. | AWS DevOps | | Automatizza la regolazione del peso del DNS utilizzando Lambda. | Quando il ritardo di replica raggiunge lo zero, è il momento di trasferire tutto il traffico sul cluster verde. Puoi automatizzare questa transizione utilizzando un'altra funzione Lambda che regola i pesi DNS in Route 53 per indirizzare il 100% del traffico verso il cluster verde.Ecco un esempio di funzione Lambda che automatizza l'interruttore del traffico:
def check_replication_lag(event, context):
client = boto3.client('rds')
response = client.describe_db_instances(DBInstanceIdentifier='green-cluster-instance')
replication_status = response['DBInstances'][0]['ReadReplicaDBInstanceIdentifiers']
if replication_status:
lag = replication_status[0]['ReplicationLag']
return lag
return -1
import boto3Questa funzione controlla il ritardo di replica e aggiorna i pesi DNS di Route 53 quando il ritardo è zero per spostare completamente il traffico verso il cluster verde.****Durante il processo di cutover, se il cluster blu presenta un traffico di scrittura intenso, prendi in considerazione la possibilità di sospendere temporaneamente le operazioni di scrittura durante il cutover. Ciò garantisce che la replica recuperi il ritardo e previene le incongruenze dei dati tra i cluster blu e verdi. | AWS DevOps | | Verifica l'interruttore del traffico. | Dopo che la funzione Lambda ha regolato i pesi DNS, è necessario verificare che tutto il traffico sia indirizzato al cluster verde e che il passaggio sia avvenuto correttamente.Per verificare:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se tutto funziona come previsto, l'interruttore del traffico è completo. | AWS DevOps | | In caso di problemi, ripristina le modifiche. | Avere un piano di rollback è fondamentale in caso di problemi dopo il cambio di traffico. Ecco come tornare rapidamente al cluster blu, se necessario:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Implementando questo piano di rollback, puoi garantire interruzioni minime agli utenti in caso di problemi imprevisti. | AWS DevOps | ### Convalida e interrompi la replica basata su GTID | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi la replica basata su GTID sul cluster verde. | Dopo aver spostato il traffico dall'ambiente blu a quello verde, è necessario convalidare il successo della transizione e assicurarsi che il cluster verde funzioni come previsto. Inoltre, la replica basata su GTID tra i cluster blu e verdi deve essere interrotta, poiché l'ambiente verde ora funge da database primario. Il completamento di queste attività garantisce che l'ambiente sia sicuro, semplificato e ottimizzato per le operazioni in corso.Per interrompere la replica:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Quando si interrompe la replica, il cluster verde diventa completamente indipendente e funge da ambiente di database principale per i carichi di lavoro. | DBA | | Eliminare le risorse. | La pulizia di tutte le risorse temporanee o inutilizzate create durante la migrazione dal cluster blu a quello verde garantisce che l'ambiente rimanga ottimizzato, sicuro ed economico. La pulizia include la regolazione delle impostazioni di sicurezza, l'esecuzione dei backup finali e la disattivazione delle risorse non necessarie.Per ripulire le risorse:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)La pulizia delle risorse aiuta a mantenere un ambiente sicuro e semplificato, riduce i costi e garantisce che rimanga solo l'infrastruttura necessaria. | AWS DevOps | ## Risorse correlate CloudFormation: + [CloudFormation Guida per l'utente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + [CloudFormation migliori pratiche](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Genera modelli da risorse esistenti con iAc Generator](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC.html) + [Importa intere applicazioni in CloudFormation](https://aws.amazon.com/blogs/devops/import-entire-applications-into-aws-cloudformation/) (post AWS del blog) Amazon Aurora: + [Guida per l'utente di Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Welcome.html) + [Gestione di un cluster Amazon Aurora DB](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) Strategia di implementazione blu/verde: + [Panoramica delle implementazioni di Amazon Aurora Blue/Green ](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) Replica basata su GTID: + [Utilizzo della replica basata su GTID (documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) Amazon RDS) AWS Lambda: + [AWS Lambda Guida per gli sviluppatori](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Le migliori pratiche per lavorare con le funzioni AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) Amazon Route 53: + [Guida per gli sviluppatori di Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) + [Routing ponderato](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Strumenti client MySQL: + [PyMySQL](https://github.com/PyMySQL/PyMySQL) # Automatizza la replica delle istanze Amazon RDS su Account AWS *Parag Nagwekar e Arun Chandapillai, Amazon Web Services* ## Riepilogo Questo modello mostra come automatizzare il processo di replica, tracciamento e ripristino delle istanze DB di Amazon Relational Database Service (Amazon RDS) tra diverse istanze database utilizzando e. Account AWS AWS Step Functions AWS Lambda Puoi utilizzare questa automazione per eseguire repliche su larga scala di istanze DB RDS senza alcun impatto sulle prestazioni o sovraccarico operativo, indipendentemente dalle dimensioni dell'organizzazione. È inoltre possibile utilizzare questo modello per aiutare l'organizzazione a rispettare le strategie obbligatorie di governance dei dati o i requisiti di conformità che richiedono la replica e la ridondanza dei dati su aree diverse. Account AWS Regioni AWS La replica su più account dei dati di Amazon RDS su larga scala è un processo manuale inefficiente e soggetto a errori che può essere costoso e dispendioso in termini di tempo, ma l'automazione in questo modello può aiutarti a ottenere la replica tra account in modo sicuro, efficace ed efficiente. ## Prerequisiti e limitazioni **Prerequisiti** + Due Account AWS + Un'istanza DB RDS, attiva e funzionante nell'origine Account AWS + Un gruppo di sottoreti per l'istanza DB RDS nella destinazione Account AWS + Una chiave AWS Key Management Service (AWS KMS) creata nell'origine Account AWS e condivisa con l'account di destinazione (per ulteriori informazioni sui dettagli delle politiche, consulta la sezione [Informazioni aggiuntive](#automate-the-replication-of-amazon-rds-instances-across-aws-accounts-additional) di questo modello). + Un AWS KMS key nella destinazione Account AWS per crittografare il database nell'account di destinazione **Limitazioni** + Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. **Versioni del prodotto** + Python 3.9 (utilizzo) AWS Lambda + PostgreSQL 11.3, 13.x e 14.x ## Architecture **Stack tecnologico** + Amazon Relational Database Service (Amazon RDS) + Amazon Simple Notification Service (Amazon SNS) + AWS Key Management Service (AWS KMS) + AWS Lambda + Gestione dei segreti AWS + AWS Step Functions **Architettura Target** Il diagramma seguente mostra un'architettura per l'utilizzo di Step Functions per orchestrare la replica pianificata e su richiesta delle istanze DB RDS da un account di origine (account A) a un account di destinazione (account B). ![\[Replica delle istanze DB di Amazon RDS tra account di origine e destinazione utilizzando Step Functions.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/6310ad9b-1b1a-4a67-b684-ef605fef3e87/images/001550bb-cf6b-493d-9de9-0229a43753a1.png) Nell'account di origine (account A nel diagramma), la macchina a stati Step Functions esegue le seguenti operazioni: 1. Crea un'istantanea dall'istanza DB RDS nell'account A. 1. Copia e crittografa lo snapshot con un account di origine A. Per garantire la crittografia in transito, lo snapshot viene crittografato indipendentemente AWS KMS key dal fatto che l'istanza DB sia crittografata o meno. 1. Condivide lo snapshot DB con l'account B dando all'account B l'accesso allo snapshot. 1. Invia una notifica all'argomento SNS, quindi l'argomento SNS richiama la funzione Lambda nell'account B. Nell'account di destinazione (account B nel diagramma), la funzione Lambda esegue la macchina a stati Step Functions per orchestrare quanto segue: 1. Copia l'istantanea condivisa dall'account A all'account B, mentre utilizza prima l'account AWS KMS key dall'account A per decrittografare i dati e poi crittografa i dati utilizzando l'account B. AWS KMS key 1. Legge il segreto da Secrets Manager per acquisire il nome dell'istanza DB corrente. 1. Ripristina l'istanza DB dallo snapshot con un nuovo nome e un valore predefinito per AWS KMS key Amazon RDS. 1. Legge l'endpoint del nuovo database e aggiorna il segreto in Secrets Manager con il nuovo endpoint del database, quindi etichetta l'istanza DB precedente in modo che possa essere eliminata in un secondo momento. 1. Mantiene le ultime N istanze dei database ed elimina tutte le altre istanze. ## Tools (Strumenti) **Servizi AWS** + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale in. Cloud AWS + [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) ti aiuta a coordinare e gestire lo scambio di messaggi tra editori e clienti, inclusi server Web e indirizzi e-mail. + [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, fornirle in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita su e. Account AWS Regioni AWS + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) consente di creare e controllare chiavi crittografiche per proteggere i dati. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. + [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)è un kit di sviluppo software che ti aiuta a integrare la tua applicazione, libreria o script Python con. Servizi AWS + Con [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) puoi sostituire le credenziali nel codice,incluse le password, con una chiamata API a Secrets Manager in modo da recuperare il segreto a livello di codice. + [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)è un servizio di orchestrazione serverless che consente di combinare funzioni Lambda e altro Servizi AWS per creare applicazioni aziendali critiche. **Archivio di codice** Il codice per questo pattern è disponibile nel repository GitHub [Crossaccount RDS Replication.](https://github.com/aws-samples/aws-rds-crossaccount-replication) ## Epiche ### Automatizza la replica delle istanze DB RDS con un solo clic Account AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Implementa lo CloudFormation stack nell'account di origine. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Amministratore del cloud, architetto del cloud | | Implementa lo CloudFormation stack nell'account di destinazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Architetto cloud, DevOps ingegnere, amministratore del cloud | | Verifica la creazione dell'istanza DB RDS nell'account di destinazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Amministratore cloud, architetto cloud, DevOps ingegnere | | Sottoscrivi la funzione Lambda all'argomento SNS. | È necessario eseguire i seguenti comandi AWS Command Line Interface (AWS CLI) per sottoscrivere la funzione Lambda nell'account di destinazione (account B) all'argomento SNS nell'account di origine (account A).Nell'account A, esegui il seguente comando:
def switch_traffic(event, context):
route53 = boto3.client('route53')
lag = check_replication_lag(event, context)
if lag == 0:
response = route53.change_resource_record_sets(
HostedZoneId='YOUR_HOSTED_ZONE_ID',
ChangeBatch={
'Changes': [
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'GreenCluster',
'Weight': 100,
'TTL': 60,
'ResourceRecords': [{'Value': 'green-cluster-endpoint'}]
}
},
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'BlueCluster',
'Weight': 0,
'TTL': 60,
'ResourceRecords': [{'Value': 'blue-cluster-endpoint'}]
}
}
]
}
)
return response
aws sns add-permission \Nell'account B, esegui il seguente comando:
--label lambda-access --aws-account-id\
--topic-arn\
--action-name Subscribe ListSubscriptionsByTopic
aws lambda add-permission \Nell'account B, esegui il seguente comando:
--function-name\
--source-arn\
--statement-id function-with-sns \
--action lambda:InvokeFunction \
--principal sns.amazonaws.com
aws sns subscribe \| Amministratore cloud, architetto cloud, DBA | | Sincronizza l'istanza DB RDS dall'account di origine con l'account di destinazione. | Avvia la replica del database su richiesta avviando la macchina a stati Step Functions nell'account di origine.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html)È disponibile uno scheduler che consente di eseguire la replica automaticamente nei tempi previsti, ma per impostazione predefinita è disattivato. Puoi trovare il nome della CloudWatch regola Amazon per lo scheduler nella scheda **Risorse** dello CloudFormation stack nell'account di destinazione. Per istruzioni su come modificare la regola degli CloudWatch eventi, consulta [Eliminazione o disabilitazione di una regola relativa CloudWatch agli eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Delete-or-Disable-Rule.html) nella documentazione. CloudWatch | Architetto cloud, DevOps ingegnere, amministratore del cloud | | Ripristina il database su una delle copie precedenti quando necessario. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Amministratore cloud, DBA, ingegnere DevOps | ## Risorse correlate + [Repliche di lettura tra regioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html) (documentazione Amazon RDS) + [Implementazioni blu/verdi (documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.BlueGreenDeployments.html) Amazon RDS) ## Informazioni aggiuntive Puoi utilizzare la seguente policy di esempio per condividere le tue informazioni. AWS KMS key Account AWS ``` { "Version": "2012-10-17", "Id": "cross-account-rds-kms-key", "Statement": [ { "Sid": "Enable user permissions", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::
--protocol "lambda" \
--topic-arn\
--notification-endpoint
sqlcmd -S servername -U username -P password -i[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)
| AWS DevOps, DBA | | Crea attività in Task Scheduler. | Per creare un'attività in Task Scheduler, utilizza i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)**Per eseguire l'operazione manualmente, fate clic con il pulsante destro del mouse sull'attività appena creata, quindi selezionate Esegui.** | DBA | | Visualizza lo stato delle attività. | Per visualizzare lo stato di un'attività in Task Scheduler, utilizza i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | DBA, AWS DevOps | ### Automatizza le attività con AWS Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Implementa la soluzione. | Per implementare la soluzione di questo modello, utilizzare i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | AWS DevOps, DevOps ingegnere | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Problemi con Lambda | Per informazioni su errori e problemi che potresti riscontrare durante l'utilizzo AWS Lambda, consulta [Risoluzione dei problemi in Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-troubleshooting.html) nella AWS documentazione. | ## Risorse correlate + [Tipi di EC2 istanze Amazon](https://aws.amazon.com/ec2/instance-types/) + [AWS Lambda documentazione](https://docs.aws.amazon.com/lambda/latest/dg/with-eventbridge-scheduler.html) + [AWS Lambda prezzi](https://aws.amazon.com/lambda/pricing/) + [Task Scheduler per sviluppatori](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) (sito Web Microsoft) # Automatizza il failover e il failback tra regioni utilizzando DR Orchestrator Framework *Jitendra Kumar, Pavithra Balasubramanian e Oliver Francis, Amazon Web Services* ## Riepilogo Questo modello descrive come utilizzare [DR Orchestrator Framework](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) per orchestrare e automatizzare i passaggi manuali, soggetti a errori, per eseguire il disaster recovery nelle regioni di Amazon Web Services ().AWS Il modello copre i seguenti database: + Amazon Relational Database Service (Amazon RDS) per MySQL, Amazon RDS per PostgreSQL o Amazon RDS per MariaDB + Edizione compatibile con Amazon Aurora MySQL o edizione compatibile con Amazon Aurora PostgreSQL (utilizzando un file centralizzato) + Amazon ElastiCache (sistema operativo Redis) Per dimostrare la funzionalità di DR Orchestrator Framework, crei due istanze o cluster DB. Il primario è in e il Regione AWS `us-east-1` secondario è in. `us-west-2` Per creare queste risorse, si utilizzano i AWS CloudFormation modelli nella `App-Stack` cartella del GitHub repository [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases). ## Prerequisiti e limitazioni **Prerequisiti generali** + DR Orchestrator Framework distribuito sia in modalità primaria che secondaria Regioni AWS + Due [bucket Amazon Simple Storage Service](https://aws.amazon.com/s3/) + Un [cloud privato virtuale (VPC)](https://aws.amazon.com/vpc/) con due sottoreti e un gruppo di sicurezza AWS **Prerequisiti specifici del motore** + **Amazon Aurora**: almeno un database globale di Aurora deve essere disponibile in due. Regioni AWSÈ possibile utilizzare `us-east-1` come regione principale e `us-west-2` come regione secondaria. + **Amazon ElastiCache (Redis OSS)**: un datastore ElastiCache globale deve essere disponibile in due. Regioni AWS Puoi `use us-east-1` utilizzarla come regione principale e `us-west-2` come regione secondaria. **Limitazioni di Amazon RDS** + DR Orchestrator Framework non verifica il ritardo di replica prima di eseguire un failover o un failback. Il ritardo di replica deve essere controllato manualmente. + Questa soluzione è stata testata utilizzando un'istanza di database principale con una replica di lettura. Se desideri utilizzare più di una replica di lettura, testa accuratamente la soluzione prima di implementarla in un ambiente di produzione. **Limitazioni di Aurora** + La disponibilità e il supporto delle funzionalità variano a seconda delle versioni specifiche di ciascun motore di database e tra Regioni AWS di loro. Per ulteriori informazioni sulle funzionalità e sulla disponibilità regionale per la replica tra regioni, consulta Repliche di lettura [tra regioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html). + I database globali Aurora hanno requisiti di configurazione specifici per le classi di istanze Aurora DB supportate e il numero massimo di. Regioni AWS Per ulteriori informazioni, consulta [Requisiti di configurazione di un database globale Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.configuration.requirements). + Questa soluzione è stata testata utilizzando un'istanza di database principale con una replica di lettura. Se desideri utilizzare più di una replica di lettura, testa accuratamente la soluzione prima di implementarla in un ambiente di produzione. **ElastiCache limitazioni** + Per informazioni sulla disponibilità regionale per Global Datastore e sui requisiti di ElastiCache configurazione, consulta [Prerequisiti e limitazioni nella documentazione](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html). ElastiCache ****Versioni del prodotto Amazon RDS p**** Amazon RDS supporta le seguenti versioni del motore: + **MySQL** — Amazon RDS supporta istanze DB che eseguono le seguenti versioni di MySQL: MySQL 8.0 e [MySQL 5.7](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html) + **PostgreSQL**[: per informazioni sulle versioni supportate di Amazon RDS for PostgreSQL, consulta Versioni disponibili del database PostgreSQL.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions) + **MariaDB** [— Amazon RDS supporta istanze DB che eseguono le seguenti versioni di MariaDB:](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html) + MariaDB 10.11 + MariaDB 10.6 + MariaDB 10.5 **Versioni del prodotto Aurora** + Il passaggio al database globale di Amazon Aurora richiede Aurora MySQL, compatibile con MySQL 5.7, versione 2.09.1 e successive Per ulteriori informazioni, consulta [Limitazioni dei database globali di Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations). **ElastiCache Versioni del prodotto (Redis OSS)** Amazon ElastiCache (Redis OSS) supporta le seguenti versioni di Redis: + Redis 7.1 (avanzata) + Redis 7.0 (avanzata) + Redis 6.2 (avanzato) + Redis 6.0 (avanzato) + Redis 5.0.6 (potenziato) Per ulteriori informazioni, consulta Versioni [supportate ElastiCache (Redis OSS](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html)). ## Architecture ****Architettura Amazon RDS**** L'architettura Amazon RDS include le seguenti risorse: + L'istanza database Amazon RDS primaria creata nella regione primaria (`us-east-1`) con read/write accesso per i client + Una replica di lettura Amazon RDS creata nella regione secondaria (`us-west-2`) con accesso in sola lettura per i client + DR Orchestrator Framework distribuito sia nella regione primaria che in quella secondaria ![\[Diagramma dell'architettura RDS a due regioni in un singolo account AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/ad217033-600c-40da-929c-b9f9aecb4c2c.png) Il diagramma mostra: 1. Replica asincrona tra l'istanza primaria e l'istanza secondaria 1. Accesso in lettura/scrittura per i client nella regione principale 1. Accesso in sola lettura per i client nella regione secondaria **Architettura Aurora** L'architettura Amazon Aurora include le seguenti risorse: + Il cluster Aurora DB primario creato nella regione primaria (`us-east-1`) con un endpoint active-writer + Un cluster Aurora DB creato nella regione secondaria (`us-west-2`) con un endpoint inactive-writer + DR Orchestrator Framework distribuito sia nella regione primaria che in quella secondaria ![\[Diagramma dell'implementazione di Aurora in due regioni in un singolo account AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/524ec002-5aa7-47b2-8c8d-6d1a3b535e9e.png) Il diagramma mostra: 1. Replica asincrona tra il cluster primario e il cluster secondario 1. Il cluster DB primario con un endpoint active-writer 1. Il cluster DB secondario con un endpoint di scrittura inattiva **ElastiCache Architettura (Redis OSS)** L'architettura Amazon ElastiCache (Redis OSS) include le seguenti risorse: + Un datastore globale ElastiCache (Redis OSS) creato con due cluster: 1. Il cluster primario nella regione primaria () `us-east-1` 1. Il cluster secondario nella regione secondaria (`us-west-2`) + Un collegamento Amazon interregionale con crittografia TLS 1.2 tra i due cluster + DR Orchestrator Framework distribuito nelle regioni primarie e secondarie ![\[Diagramma di una ElastiCache distribuzione in due regioni con collegamento Amazon Cross-region.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/cf6620a0-dd42-4042-8dc2-012bf514ffc0.png) **Automazione e scalabilità** DR Orchestrator Framework è scalabile e supporta il failover o il failback di più di un database in parallelo. AWS Puoi utilizzare il seguente codice di payload per eseguire il failover di più database del tuo account. AWS In questo esempio, tre AWS database (due database globali come Aurora MySQL compatibile o Aurora PostgreSQL e un'istanza Amazon RDS for MySQL) eseguono il failover nella regione DR: ``` { "StatePayload": [ { "layer": 1, "resources": [ { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (MySQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-mysql-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-mysql-cluster-identifier" } }, { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (PostgreSQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-postgres-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-postgres-cluster-identifier" } }, { "resourceType": "PromoteRDSReadReplica", "resourceName": "Promote RDS for MySQL Read Replica", "parameters": { "RDSInstanceIdentifier": "!Import rds-mysql-instance-identifier", "TargetClusterIdentifier": "!Import rds-mysql-instance-global-arn" } } ] } ] } ``` ## Tools (Strumenti) **AWS servizi** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) è un motore di database relazionale completamente gestito creato per il cloud e compatibile con MySQL e PostgreSQL. + [Amazon](https://docs.aws.amazon.com/elasticache/) ti ElastiCache aiuta a configurare, gestire e scalare ambienti di cache in memoria distribuiti in. Cloud AWS Questo modello utilizza Amazon ElastiCache (Redis OSS). + [AWS Lambda](https://aws.amazon.com/lambda/) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. In questo modello, le funzioni Lambda vengono utilizzate AWS Step Functions per eseguire i passaggi. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale in. Cloud AWS Questo modello supporta Amazon RDS for MySQL, Amazon RDS per PostgreSQL e Amazon RDS per MariaDB. + [AWS SDK per Python (Boto3)](https://aws.amazon.com/sdk-for-python/)ti aiuta a integrare la tua applicazione, libreria o script Python con. Servizi AWS In questo modello, i Boto3 APIs vengono utilizzati per comunicare con le istanze del database o i database globali. + [AWS Step Functions](https://aws.amazon.com/step-functions/)è un servizio di orchestrazione senza server che consente di combinare AWS Lambda funzioni e altro per creare applicazioni aziendali critiche. Servizi AWS In questo modello, le macchine a stati Step Functions vengono utilizzate per orchestrare ed eseguire il failover e il failback interregionali delle istanze del database o dei database globali. **Archivio di codice** Il codice per questo pattern è disponibile nel repository [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases/tree/main/App-Stack) su. GitHub ## Epiche ### Installa DR Orchestrator Framework | Operazione | Description | Competenze richieste | | --- | --- | --- | | Clona il GitHub repository. | Per clonare il repository, esegui il seguente comando:
@echo off
sqlcmd -S [ServerName] -d [DatabaseName] -U username -P password -i "PathToSQLScript\Script.sql" -o "PathToOutput\Output.txt"
git clone https://github.com/aws-samples/aws-cross-region-dr-databases.git| AWS DevOps, amministratore AWS | | Codice delle funzioni Package Lambda in un archivio di file.zip. | Crea i file di archivio per le funzioni Lambda per includere le dipendenze di DR Orchestrator Framework:
cd| Amministratore AWS | | Crea bucket S3. | I bucket S3 sono necessari per archiviare DR Orchestrator Framework insieme alla configurazione più recente. Crea due bucket S3, uno nella regione principale () e uno nella regione secondaria (`us-east-1`): `us-west-2`[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html)`xxxxxx`Sostituiscili con un valore casuale per rendere unici i nomi dei bucket. | Amministratore AWS | | Crea sottoreti e gruppi di sicurezza. | Sia nella regione principale (`us-east-1`) che nella regione secondaria (`us-west-2`), crea due sottoreti e un gruppo di sicurezza per l'implementazione della funzione Lambda nel tuo VPC:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Amministratore AWS | | Aggiorna i file dei parametri di DR Orchestrator. | Nella `/DR-Orchestration-artifacts
bash scripts/deploy-orchestrator-sh.sh
[| Amministratore AWS | | Carica il codice di DR Orchestrator Framework nel bucket S3. | Il codice sarà più sicuro in un bucket S3 che nella directory locale. Carica la `DR-Orchestration-artifacts` directory, inclusi tutti i file e le sottocartelle, nei bucket S3.Per caricare il codice, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Amministratore AWS | | Implementa DR Orchestrator Framework nella regione principale. | Per distribuire DR Orchestrator Framework nella regione primaria (), esegui i seguenti comandi: `us-east-1`
{
"ParameterKey": "TemplateStoreS3BucketName",
"ParameterValue": "dr-orchestrator-xxxxxx-us-east-1"
},
{
"ParameterKey": "TemplateVPCId",
"ParameterValue": "vpc-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID1",
"ParameterValue": "subnet-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID2",
"ParameterValue": "subnet-yyyyyy"
},
{
"ParameterKey": "TemplateLambdaSecurityGroupID",
"ParameterValue": "sg-xxxxxxxxxx"
}
]
cd| Amministratore AWS | | Implementa DR Orchestrator Framework nella regione secondaria. | Nella regione secondaria (`us-west-2`), esegui i seguenti comandi:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-east-1 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd| Amministratore AWS | | Verifica la distribuzione. | Se il CloudFormation comando viene eseguito correttamente, restituisce il seguente risultato:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-west-2 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
Successfully created/updated stack - dr-orchestratorIn alternativa, puoi accedere alla CloudFormation console e verificare lo stato dello `dr-orchestrator` stack. | Amministratore AWS | ### Crea le istanze o i cluster del database | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare le sottoreti e i gruppi di sicurezza del database. | Nel tuo VPC, crea due sottoreti e un gruppo di sicurezza per l'istanza DB o il database globale nelle regioni primaria (`us-east-1`) e secondaria (): `us-west-2`[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Amministratore AWS | | Aggiorna il file dei parametri per l'istanza o il cluster DB primario. | Nella `
{
"Parameters": {
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId"
}
}
**Amazon Aurora** Nel `Aurora-MySQL-parameter-us-east-1.json` file, aggiorna `SubnetIds` e `DBSecurityGroup` con i nomi delle risorse che hai creato:{
"Parameters": {
"SubnetIds": "subnet1-xxxxxx,subnet2-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (sistema operativo Redis)**Nel `ElastiCache-parameter-us-east-1.json` file, aggiorna `SubnetIds` e `DBSecurityGroup` inserisci i nomi delle risorse che hai creato.{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | Amministratore AWS |
| Distribuisci l'istanza o il cluster di database nella regione principale. | Per distribuire l'istanza o il cluster nella regione primaria (`us-east-1`), esegui i seguenti comandi in base al motore di database.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-Primary.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (sistema operativo Redis)**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-Primary.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdVerifica che le CloudFormation risorse siano state distribuite correttamente. | Amministratore AWS | | Aggiorna il file dei parametri per l'istanza o il cluster DB secondario. | Nella `/App-Stack
aws cloudformation deploy \
--region us-east-1 --stack-name elasticache-ds-app-stack \
--template-file ElastiCache-Primary.yaml \
--parameter-overrides file://ElastiCache-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
{
"Parameters": {
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId",
"PrimaryRegionKMSKeyArn":"arn:aws:kms:us-east-1:xxxxxxxxx:key/mrk-xxxxxxxxxxxxxxxxxxxxx"
}
} **Amazon Aurora**Nel `Aurora-MySQL-parameter-us-west-2.json` file, aggiorna `SubnetIDs` e inserisci `DBSecurityGroup` i nomi delle risorse che hai creato. Aggiorna il `PrimaryRegionKMSKeyArn` con il valore `AuroraKmsKeyId` preso dalla sezione **Outputs** dello CloudFormation stack per l'istanza DB principale:{
"Parameters": {
"SubnetIds": "subnet1-aaaaaaaaa,subnet2-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (sistema operativo Redis)**Nel `ElastiCache-parameter-us-west-2.json` file, aggiorna `SubnetIDs` e `DBSecurityGroup` inserisci i nomi delle risorse che hai creato. Aggiorna il file `PrimaryRegionKMSKeyArn` con il valore `ElastiCacheKmsKeyId` preso dalla sezione **Outputs** dello CloudFormation stack per l'istanza DB principale:{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-cccccccccc",
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | Amministratore AWS |
| Distribuisci l'istanza o il cluster di database nella regione secondaria. | Esegui i seguenti comandi, in base al tuo motore di database.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-DR.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (sistema operativo Redis)**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-DR.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdVerifica che le CloudFormation risorse siano state distribuite correttamente. | Amministratore AWS | ## Risorse correlate + [Strategia di disaster recovery per i database su AWS(strategia](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/welcome.html)AWS Prescriptive Guidance) + [Automatizza la tua soluzione DR per i database relazionali su AWS(guida Prescriptive Guidance](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html))AWS + [Using Amazon Aurora global databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Replica attraverso l'utilizzo di datastore globali Regioni AWS](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html) + [Automatizza la tua soluzione DR per i database relazionali su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/introduction.html) (guida Prescriptive Guidance)AWS # Esegui automaticamente il backup dei database SAP HANA utilizzando Systems Manager e EventBridge *Ambarish Satarkar e Gaurav Rath, Amazon Web Services* ## Riepilogo Questo modello descrive come automatizzare i backup dei database SAP HANA utilizzando AWS Systems Manager, Amazon, EventBridge Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) e AWS Backint Agent per SAP HANA. Questo modello fornisce un approccio basato su shell script che utilizza il `BACKUP DATA` comando ed elimina la necessità di mantenere script e configurazioni di lavoro per ogni istanza del sistema operativo (OS) su numerosi sistemi. | | | Nota: ad aprile 2023, AWS Backup ha annunciato il supporto per i database SAP HANA su Amazon Elastic Compute Cloud (Amazon). EC2 Per ulteriori informazioni, consulta [Database SAP HANA sul backup delle EC2 istanze Amazon](https://docs.aws.amazon.com/aws-backup/latest/devguide/backup-saphana.html).In base alle esigenze della tua organizzazione, puoi utilizzare il servizio AWS Backup per eseguire automaticamente il backup dei database SAP HANA oppure puoi utilizzare questo schema. | | --- | ## Prerequisiti e limitazioni **Prerequisiti** + Un'istanza SAP HANA esistente con una versione supportata in stato di esecuzione su un'istanza Amazon Elastic Compute Cloud (Amazon EC2) gestita configurata per Systems Manager + Systems Manager Agent (SSM Agent) 2.3.274.0 o versione successiva installata + Un bucket S3 per cui non è abilitato l'accesso pubblico + Una chiave denominata `hdbuserstore` `SYSTEM` + Un ruolo AWS Identity and Access Management (IAM) per il runbook di automazione da eseguire nei tempi previsti + `AmazonSSMManagedInstanceCore`e `ssm:StartAutomationExecution` le policy sono associate al ruolo del servizio Systems Manager Automation. **Limitazioni** + AWS Backint Agent per SAP HANA non supporta la deduplicazione. + AWS Backint Agent per SAP HANA non supporta la compressione dei dati. **Versioni del prodotto** AWS Backint Agent è supportato sui seguenti sistemi operativi: + SUSE Linux Enterprise Server + SUSE Linux Enterprise Server per SAP + Red Hat Enterprise Linux per SAP AWS Backint Agent supporta i seguenti database: + SAP HANA 1.0 SP12 (nodo singolo e nodi multipli) + SAP HANA 2.0 e versioni successive (nodo singolo e nodi multipli) ## Architecture **Stack tecnologico Target** + Agente AWS Backint + Simple Storage Service (Amazon S3) + AWS Systems Manager + Amazon EventBridge + SAP HANA **Architettura Target** Il diagramma seguente mostra gli script di installazione che installano AWS Backint Agent, il bucket S3 e Systems EventBridge Manager e che utilizzano un documento Command per pianificare backup regolari. ![\[Flusso di lavoro per la pianificazione di backup regolari.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/0aa22a27-d100-483d-95f9-c3101f40402c/images/201d2b9a-b88e-4432-82cd-240b81da981e.png) **Automazione e scalabilità** + È possibile installare più agenti AWS Backint utilizzando un runbook Systems Manager Automation. + Ogni esecuzione del runbook Systems Manager può essere scalata fino a un numero *n* di istanze SAP HANA, in base alla selezione del target. + EventBridge può automatizzare i backup SAP HANA. ## Tools (Strumenti) + [AWS Backint Agent per SAP](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) HANA è un'applicazione autonoma che si integra con i flussi di lavoro esistenti per eseguire il backup del database SAP HANA in un bucket S3 specificato nel file di configurazione. AWS Backint Agent supporta backup completi, incrementali e differenziali dei database SAP HANA. Funziona su un server di database SAP HANA, dove i backup e i cataloghi vengono trasferiti dal database SAP HANA all'AWS Backint Agent. + [Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) è un servizio di bus eventi senza server che puoi utilizzare per connettere le tue applicazioni con dati provenienti da una varietà di fonti. EventBridge fornisce un flusso di dati in tempo reale dalle tue applicazioni, dalle applicazioni SaaS (SaaS) e dai servizi AWS a target come funzioni AWS Lambda, endpoint di invocazione HTTP che utilizzano destinazioni API o bus di eventi in altri account. + [Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html)) è un servizio di storage di oggetti. È possibile utilizzare Amazon S3 per memorizzare e recuperare qualsiasi volume di dati, in qualunque momento e da qualunque luogo tramite il Web. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ti aiuta a visualizzare e controllare la tua infrastruttura su AWS. Utilizzando la console Systems Manager, puoi visualizzare i dati operativi da più servizi AWS e automatizzare le attività operative tra le tue risorse AWS. **Codice** Il codice per questo pattern è disponibile nel [aws-backint-automated-backup](https://github.com/aws-samples/aws-backint-automated-backup) GitHub repository. ## Epiche ### Crea un sistema di chiavi hdbuserstore | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una chiave hdbuserstore. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Amministratore AWS, amministratore SAP HANA | ### Installa AWS Backint Agent | Operazione | Description | Competenze richieste | | --- | --- | --- | | Installa AWS Backint Agent. | Segui le istruzioni in [Installare e configurare AWS Backint Agent per SAP](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) HANA nella documentazione di AWS Backint Agent. | Amministratore AWS, amministratore SAP HANA | ### Creare il documento Systems Manager Command | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare il documento Systems Manager Command. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Amministratore AWS, amministratore SAP HANA | ### Pianifica i backup con una frequenza regolare | Operazione | Description | Competenze richieste | | --- | --- | --- | | Pianifica backup regolari con Amazon EventBridge. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html)Puoi verificare il successo del backup dal percorso del bucket S3./App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name elasticache-ds-app-stack \
--template-file ElastiCache-DR.yaml \
--parameter-overrides file://ElastiCache-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
s3:/Puoi anche verificare i backup dal catalogo di backup SAP HANA. | Amministratore AWS, amministratore SAP HANA | ## Risorse correlate + [AWS Backint Agent per SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) + [Installa e configura AWS Backint Agent per SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) # Genera automaticamente un modello PynamoDB e funzioni CRUD per Amazon DynamoDB utilizzando un'applicazione Python *Vijit Vashishtha, Dheeraj Alimchandani e Dhananjay Karanjkar, Amazon Web Services* ## Riepilogo È comune richiedere entità e funzioni operative di creazione, lettura, aggiornamento ed eliminazione (CRUD) per eseguire in modo efficiente le operazioni del database Amazon DynamoDB. PynamoDB è un'interfaccia basata su Python che supporta Python 3. Fornisce inoltre funzionalità come il supporto per le transazioni Amazon DynamoDB, la serializzazione e la deserializzazione automatiche dei valori degli attributi e la compatibilità con i framework Python più comuni, come Flask e Django. Questo modello aiuta gli sviluppatori a lavorare con Python e DynamoDB fornendo una libreria che semplifica la creazione automatica di modelli PynamoDB e funzioni operative CRUD. Oltre a generare funzioni CRUD essenziali per le tabelle del database, può anche decodificare i modelli PynamoDB e le funzioni CRUD dalle tabelle Amazon DynamoDB. Questo modello è progettato per semplificare le operazioni del database utilizzando un'applicazione basata su Python. Le caratteristiche principali di questa soluzione sono le seguenti: + **Da schema JSON a modello PynamoDB: genera automaticamente modelli PynamoDB** in Python importando un file di schema JSON. + **Generazione di funzioni CRUD**: genera automaticamente funzioni per eseguire operazioni CRUD sulle tabelle DynamoDB. + **Reverse engineering da DynamoDB**: utilizza la mappatura relazionale degli oggetti (ORM) di PynamoDB per decodificare i modelli PynamoDB e le funzioni CRUD per le tabelle Amazon DynamoDB esistenti. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS + [Python versione 3.8 o successiva, scaricata e installata](https://www.python.org/downloads/) + [Jinja2 versione 3.1.2 o successiva, scaricato e installato](https://pypi.org/project/Jinja2/#files) + Tabelle Amazon DynamoDB per le quali desideri generare ORM + AWS Command Line Interface [https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [PynamoDB versione 5.4.1 o successiva, installato](https://pynamodb.readthedocs.io/en/stable/tutorial.html#installation) ## Architecture **Stack tecnologico Target** + Script JSON + Applicazione Python + Modello PynamoDB + Istanza di database Amazon DynamoDB **Architettura di destinazione** ![\[Utilizzo di un'app Python per generare funzioni CRUD e modelli PynamoDB dalle tabelle DynamoDB.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/74cc4c73-5c8b-448d-98fb-b681cfa5f860/images/c2c367d6-d88a-4f49-8571-89160539eb08.png) 1. Si crea un file di schema JSON di input. Questo file di schema JSON rappresenta gli attributi delle rispettive tabelle DynamoDB da cui si desidera creare i modelli PynamoDB e le funzioni CRUD. Contiene le seguenti tre chiavi importanti: + `name`—Il nome della tabella DynamoDB di destinazione. + `region`— Il Regione AWS luogo in cui è ospitata la tabella + `attributes`[— Gli attributi che fanno parte della tabella di destinazione, come la [chiave di partizione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) (nota anche come *attributo hash*), la chiave di [ordinamento, gli [indici secondari locali, gli indici secondari](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html)[globali](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) e tutti gli attributi non chiave](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey).](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) Questo strumento prevede che lo schema di input fornisca solo gli attributi non chiave poiché l'applicazione recupera gli attributi chiave direttamente dalla tabella di destinazione. Per un esempio di come specificare gli attributi nel file di schema JSON, consultate la sezione [Informazioni aggiuntive](#automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application-additional) di questo modello. 1. Esegui l'applicazione Python e fornisci il file di schema JSON come input. 1. L'applicazione Python legge il file di schema JSON. 1. L'applicazione Python si connette alle tabelle DynamoDB per derivare lo schema e i tipi di dati. L'applicazione esegue l'operazione [describe\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_table.html) e recupera gli attributi chiave e indice per la tabella. 1. L'applicazione Python combina gli attributi del file di schema JSON e della tabella DynamoDB. Utilizza il motore di template Jinja per generare un modello Pynamodb e le funzioni CRUD corrispondenti. 1. Si accede al modello PynamoDB per eseguire operazioni CRUD sulla tabella DynamoDB. ## Tools (Strumenti) **Servizi AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. **Altri strumenti** + [Jinja](https://jinja.palletsprojects.com/en/) è un motore di template estensibile che compila i modelli in codice Python ottimizzato. Questo modello utilizza Jinja per generare contenuti dinamici incorporando segnaposto e logica nei modelli. + [PynamoDB](https://pynamodb.readthedocs.io/en/stable/) è un'interfaccia basata su Python per Amazon DynamoDB. + [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico. **Deposito di codice** Il codice per questo modello è disponibile nel repository di modelli [PynamoDB a GitHub generazione automatica](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb) e funzioni CRUD. Il repository è diviso in due parti principali: il pacchetto controller e i modelli. *Pacchetto controller* Il pacchetto Python del controller contiene la logica dell'applicazione principale che aiuta a generare il modello PynamoDB e le funzioni CRUD. Contiene i seguenti dati: + `input_json_validator.py`— Questi script Python convalidano il file di schema JSON di input e creano gli oggetti Python che contengono l'elenco delle tabelle DynamoDB di destinazione e gli attributi richiesti per ciascuna di esse. + `dynamo_connection.py`— Questo script stabilisce una connessione alla tabella DynamoDB e utilizza `describe_table` l'operazione per estrarre gli attributi necessari per creare il modello PynamoDB. + `generate_model.py`— Questo script contiene una classe Python `GenerateModel` che crea il modello PynamoDB basato sul file di schema JSON di input e sull'operazione. `describe_table` + `generate_crud.py`— Per le tabelle DynamoDB definite nel file di schema JSON, questo script utilizza l'operazione per creare `GenerateCrud` le classi Python. *Modelli* Questa directory Python contiene i seguenti modelli Jinja: + `model.jinja`— Questo modello Jinja contiene l'espressione del modello per generare lo script del modello PynamoDB. + `crud.jinja`— Questo modello Jinja contiene l'espressione del modello per la generazione dello script delle funzioni CRUD. ## Poemi epici ### Configura l'ambiente | Operazione | Description | Competenze richieste | | --- | --- | --- | | Clonare il repository. | Immettere il seguente comando per clonare il repository di modelli [PynamoDB e funzioni CRUD a generazione automatica](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb)./ / /usr/sap/ /SYS/global/hdb/backint/DB_ /
git clone https://github.com/aws-samples/amazon-reverse-engineer-dynamodb.git| Sviluppatore di app | | Configura l'ambiente Python. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Sviluppatore di app | ### Genera il modello PynamoDB e le funzioni CRUD | Operazione | Description | Competenze richieste | | --- | --- | --- | | Modifica il file dello schema JSON. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Sviluppatore di app | | Esegui l'applicazione Python. | Inserisci il seguente comando per generare i modelli Pynamodb e le funzioni CRUD, `
python main.py --file| Sviluppatore di app | ### Verifica il modello PynamoDB e le funzioni CRUD | Operazione | Description | Competenze richieste | | --- | --- | --- | | Verifica il modello Pynamodb generato. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Sviluppatore di app | | Verifica le funzioni CRUD generate. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Sviluppatore di app | ## Risorse correlate + [Componenti principali di Amazon DynamoDB (documentazione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html) DynamoDB) + [Miglioramento dell'accesso ai dati con indici secondari](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) (documentazione DynamoDB) ## Informazioni aggiuntive **Attributi di esempio per il file di schema JSON** ``` [ { "name": "test_table", "region": "ap-south-1", "attributes": [ { "name": "id", "type": "UnicodeAttribute" }, { "name": "name", "type": "UnicodeAttribute" }, { "name": "age", "type": "NumberAttribute" } ] } ] ``` # Blocca l'accesso pubblico ad Amazon RDS utilizzando Cloud Custodian *abhay kumar e Dwarika Patra, Amazon Web Services* ## Riepilogo Molte organizzazioni gestiscono i propri carichi di lavoro e servizi su più fornitori di cloud. In questi ambienti cloud ibridi, l'infrastruttura cloud richiede una rigida governance del cloud, oltre alla sicurezza fornita dai singoli provider di cloud. Un database cloud come Amazon Relational Database Service (Amazon RDS) è un servizio importante che deve essere monitorato per eventuali vulnerabilità di accesso e autorizzazione. Sebbene sia possibile limitare l'accesso al database Amazon RDS configurando un gruppo di sicurezza, è possibile aggiungere un secondo livello di protezione per vietare azioni come l'accesso pubblico. Il blocco dell'accesso pubblico ti aiuta a rispettare il Regolamento generale sulla protezione dei dati (GDPR), l'Health Insurance Portability and Accountability Act (HIPAA), il National Institute of Standards and Technology (NIST) e il Payment Card Industry Data Security Standard (PCI DSS). Cloud Custodian è un motore di regole open source che puoi utilizzare per imporre restrizioni di accesso a risorse Amazon Web Services (AWS) come Amazon RDS. Con Cloud Custodian, puoi impostare regole che convalidano l'ambiente rispetto a standard di sicurezza e conformità definiti. Puoi utilizzare Cloud Custodian per gestire i tuoi ambienti cloud contribuendo a garantire la conformità con le politiche di sicurezza, le politiche di tag e la raccolta dei rifiuti di risorse inutilizzate e la gestione dei costi. Con Cloud Custodian, puoi utilizzare un'unica interfaccia per implementare la governance in un ambiente cloud ibrido. Ad esempio, puoi usare l'interfaccia Cloud Custodian per interagire con e con AWS Microsoft Azure, riducendo lo sforzo di lavorare con meccanismi come gruppi di AWS sicurezza e AWS Config policy di Azure. Questo modello fornisce istruzioni per utilizzare Cloud Custodian on per AWS imporre la restrizione dell'accessibilità pubblica sulle istanze Amazon RDS. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS + [Una key pair](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-creds-create) + AWS Lambda installato ## Architecture Il diagramma seguente mostra Cloud Custodian che implementa la policy su AWS Lambda, AWS CloudTrail avvia l'evento e l'impostazione della `CreateDBInstance` funzione Lambda su false su Amazon RDS. `PubliclyAccessible` ![\[Utilizzo di Cloud Custodian su AWS per limitare l'accesso pubblico alle istanze Amazon RDS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/90f9537e-9365-4da2-8a28-da0ff374743c/images/6d04ca3b-6aa4-4c62-ade9-8b7474928c5e.png) ## Tools (Strumenti) **Servizi AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)ti aiuta a verificare la governance, la conformità e il rischio operativo del tuo. Account AWS + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che consente di interagire Servizi AWS tramite comandi nella shell della riga di comando. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale in. Cloud AWS **Altri strumenti** + [Cloud Custodian](https://cloudcustodian.io/) unifica gli strumenti e gli script utilizzati da molte organizzazioni per gestire i propri account cloud pubblici in un unico strumento open source. Utilizza un motore di regole stateless per la definizione e l'applicazione delle politiche, con metriche, output strutturati e report dettagliati per l'infrastruttura cloud. Si integra perfettamente con un runtime serverless per fornire correzioni e risposte in tempo reale con un basso sovraccarico operativo. ## Epiche ### Configura il AWS CLI | Operazione | Description | Competenze richieste | | --- | --- | --- | | Installa il AWS CLI. | Per installare il AWS CLI, segui le istruzioni nella [AWS documentazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html). | Amministratore AWS | | Configura AWS le credenziali. | Configura le impostazioni AWS CLI con cui interagisce AWS, incluso Regione AWS il formato di output che desideri utilizzare.
$>aws configurePer ulteriori informazioni, consulta la [documentazione relativa ad AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). | Amministratore AWS | | Crea un ruolo IAM. | Per creare un ruolo IAM con il ruolo di esecuzione Lambda, esegui il comando seguente.
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
aws iam create-role --role-name lambda-ex --assume-role-policy-document '{"Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"}, "Action": "sts:AssumeRole"}]} | AWS DevOps |
### Configura Cloud Custodian
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa Cloud Custodian. | [Per installare Cloud Custodian per il tuo sistema operativo e il tuo ambiente, segui le istruzioni nella documentazione di Cloud Custodian.](https://cloudcustodian.io/docs/quickstart/index.html#install-cc) | DevOps ingegnere |
| Controlla lo schema Cloud Custodian. | Per visualizzare l'elenco completo delle risorse Amazon RDS su cui è possibile eseguire le policy, usa il comando seguente.custodian schema aws.rds| DevOps ingegnere | | Crea la policy Cloud Custodian. | Salva il codice contenuto nel file di *policy di Cloud Custodian nella sezione [Informazioni aggiuntive](#block-public-access-to-amazon-rds-by-using-cloud-custodian-additional) utilizzando un'estensione* YAML. | DevOps ingegnere | | Definisci le azioni di Cloud Custodian per modificare il flag accessibile al pubblico. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/block-public-access-to-amazon-rds-by-using-cloud-custodian.html) | DevOps ingegnere | | Esegui una corsa a secco. | (Facoltativo) Per verificare quali risorse sono identificate dalla policy senza eseguire alcuna azione sulle risorse, utilizzate il comando seguente.
custodian run -dryrun| DevOps ingegnere | ### Implementa la politica | Operazione | Description | Competenze richieste | | --- | --- | --- | | Implementa la policy utilizzando Lambda. | Per creare la funzione Lambda che eseguirà la policy, utilizzare il comando seguente..yaml -s
custodian run -s policy.yamlQuesta politica verrà quindi avviata dall' AWS CloudTrail `CreateDBInstance`evento.Di conseguenza, AWS Lambda imposterà il flag accessibile al pubblico `false` per i casi che soddisfano i criteri. | DevOps ingegnere | ## Risorse correlate + [AWS Lambda website](https://aws.amazon.com/lambda/) + [Sito Web Amazon RDS](https://aws.amazon.com/rds/) + [Documentazione Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html) ## Informazioni aggiuntive **File YAML della politica di Cloud Custodian** ``` policies: - name: "block-public-access" resource: rds description: | This Enforcement blocks public access for RDS instances. mode: type: cloudtrail events: - event: CreateDBInstance # Create RDS instance cloudtrail event source: rds.amazonaws.com ids: requestParameters.dBInstanceIdentifier role: arn:aws:iam::1234567890:role/Custodian-compliance-role filters: - type: event key: 'detail.requestParameters.publiclyAccessible' value: true actions: - type: set-public-access state: false ``` **file rds.py di risorse c7n** ``` @actions.register('set-public-access') class RDSSetPublicAvailability(BaseAction): schema = type_schema( "set-public-access", state={'type': 'boolean'}) permissions = ('rds:ModifyDBInstance',) def set_accessibility(self, r): client = local_session(self.manager.session_factory).client('rds') waiter = client.get_waiter('db_instance_available') waiter.wait(DBInstanceIdentifier=r['DBInstanceIdentifier']) client.modify_db_instance( DBInstanceIdentifier=r['DBInstanceIdentifier'], PubliclyAccessible=self.data.get('state', False)) def process(self, rds): with self.executor_factory(max_workers=2) as w: futures = {w.submit(self.set_accessibility, r): r for r in rds} for f in as_completed(futures): if f.exception(): self.log.error( "Exception setting public access on %s \n %s", futures[f]['DBInstanceIdentifier'], f.exception()) return rds ``` **Integrazione con Security Hub CSPM** Cloud Custodian può essere integrato con [AWS Security Hub CSPM](https://aws.amazon.com/security-hub/)per inviare risultati di sicurezza e tentare azioni correttive. Per ulteriori informazioni, consulta [Annuncio dell'integrazione di Cloud](https://aws.amazon.com/blogs/opensource/announcing-cloud-custodian-integration-aws-security-hub/) Custodian con. AWS Security Hub CSPM # Configurare l'autenticazione Windows per Amazon RDS for Microsoft SQL Server utilizzando AWS Managed Microsoft AD *Ramesh Babu Donti, Amazon Web Services* ## Riepilogo Questo modello mostra come configurare l'autenticazione Windows per un Amazon Relational Database Service (Amazon RDS) per istanze AWS Directory Service for Microsoft Active Directory di SQL Server utilizzando ().AWS Managed Microsoft AD L'autenticazione Windows consente agli utenti di connettersi all'istanza RDS utilizzando le proprie credenziali di dominio anziché nomi utente e password specifici del database. È possibile abilitare l'autenticazione di Windows durante la creazione di un nuovo database RDS SQL Server o aggiungendolo a un'istanza di database esistente. L'istanza del database si integra con AWS Managed Microsoft AD per fornire autenticazione e autorizzazione centralizzate per gli utenti del dominio che accedono al database SQL Server. Questa configurazione migliora la sicurezza sfruttando l'infrastruttura Active Directory esistente ed elimina la necessità di gestire credenziali di database separate per gli utenti del dominio. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS con le autorizzazioni appropriate + Un cloud privato virtuale (VPC) con quanto segue: + Gateway Internet e tabelle di routing configurati + Gateway NAT nelle sottoreti pubbliche (se per alcune istanze è richiesto l'accesso a Internet) + AWS Identity and Access Management Ruoli (IAM): + Un ruolo di dominio con le seguenti politiche AWS gestite: + `AmazonSSMManagedInstanceCore`per abilitare AWS Systems Manager + `AmazonSSMDirectoryServiceAccess`per fornire le autorizzazioni per unire le istanze alle directory + Un ruolo di monitoraggio avanzato RDS (se il monitoraggio avanzato è abilitato) + Gruppi di sicurezza: + Gruppo di sicurezza del servizio di directory per consentire le porte di comunicazione di Active Directory + Un gruppo di sicurezza Amazon Elastic Compute Cloud (Amazon EC2) per consentire le comunicazioni RDP `3389` e di dominio + Un gruppo di sicurezza RDS per consentire la `1433` portabilità di SQL Server da fonti autorizzate + Connettività di rete: + Risoluzione DNS e connettività di rete corrette tra le sottoreti **Limitazioni** + Per informazioni su Regioni AWS tale supporto AWS Managed Microsoft AD con RDS per SQL Server, consulta Disponibilità delle [regioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html#USER_SQLServerWinAuth.RegionVersionAvailability) e delle versioni. + Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. ## Architecture **Stack tecnologico di origine** + Un Active Directory locale o AWS Managed Microsoft AD **Stack tecnologico Target** + Amazon EC2 + Amazon RDS per Microsoft SQL Server + AWS Managed Microsoft AD **Architettura Target** ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e02f6059-6631-46f6-819c-5961af7ba4ae/images/1aa50e3b-b4f6-4d44-9f9e-6cbb248a159c.png) L'architettura include quanto segue: + Un ruolo IAM che unisce l' EC2 istanza Amazon al AWS Managed Microsoft AD dominio. + Un'istanza Amazon EC2 Windows per l'amministrazione e il test dei database. + Un Amazon VPC con una sottorete privata per ospitare l'istanza Amazon RDS e le risorse interne nelle zone di disponibilità. + Gruppi di sicurezza per il controllo degli accessi alla rete: + Un gruppo di sicurezza Amazon RDS per controllare l'accesso in entrata alla porta di SQL Server `1433` da fonti autorizzate. + Un gruppo EC2 di sicurezza Amazon per gestire l'accesso RDP tramite porte di comunicazione di porte `3389` e domini. + Un gruppo di sicurezza Directory Services per le comunicazioni Active Directory tramite porte `53``88`,`389`, e`445`. + AWS Managed Microsoft AD per fornire servizi centralizzati di autenticazione e autorizzazione per le risorse Windows. + Un'istanza di database Amazon RDS for SQL Server nella sottorete privata con autenticazione Windows abilitata. ## Tools (Strumenti) **Servizi AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornisce capacità di elaborazione scalabile in. Cloud AWS Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente. + Amazon Relational Database Service (Amazon RDS) ti aiuta a configurare, gestire e scalare un database relazionale in. Cloud AWS + [AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html)offre diversi modi per utilizzare Microsoft Active Directory (AD) con altri Servizi AWS come Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS) per SQL Server e FSx Amazon per Windows File Server. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)consente ai carichi di lavoro e alle risorse compatibili con le directory di AWS utilizzare Microsoft Active Directory in. Cloud AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle. **Altri servizi** + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) è uno strumento per la gestione di SQL Server, che include l'accesso, la configurazione e l'amministrazione dei componenti di SQL Server. ## Best practice + Per le best practice generali, consulta [Best practice for Amazon RDS.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html) ## Epiche ### Configurazione AWS Managed Microsoft AD | Operazione | Description | Competenze richieste | | --- | --- | --- | | Imposta il tipo di directory. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura le informazioni sulla directory. | Nella sezione **Informazioni sulla directory**, inserisci le informazioni richieste e mantieni i valori opzionali:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura il VPC e le sottoreti. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA DevOps , ingegnere | | Rivedi e crea la directory. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | ### Creare e configurare un' EC2 istanza Amazon | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura un'AMI per Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configurazione delle impostazioni di rete. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura l'archiviazione. | Configura i volumi Amazon EBS in base alle esigenze. | DBA, ingegnere DevOps | | Configura i dettagli avanzati e avvia l'istanza. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | ### Crea e configura RDS per SQL Server con autenticazione Windows | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un database e configura le opzioni del motore. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Scegliere un modello. | Scegli un modello di esempio che soddisfi le tue esigenze. | DBA, ingegnere DevOps | | Configura le impostazioni del database. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura l'istanza. | Nella sezione **Configurazione dell'istanza**, in **Classe di istanza DB**, seleziona una dimensione dell'istanza che soddisfi i tuoi requisiti. | DBA, ingegnere DevOps | | Configura l'archiviazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura la connettività. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura l'autenticazione di Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura il monitoraggio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)Nota: le metriche sono utili quando si desidera vedere in che modo processi o thread diversi utilizzano la CPU. Puoi anche esportare i log degli errori su Amazon CloudWatch se il **log degli errori** è abilitato. | DBA, ingegnere DevOps | | Configura impostazioni aggiuntive. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Rivedi i costi e crea un database. | Esamina la sezione **Costi mensili stimati**, quindi scegli **Crea database**. | DBA, ingegnere DevOps | ### Configura l'accesso al database e verifica le connessioni | Operazione | Description | Competenze richieste | | --- | --- | --- | | Connect al computer Windows. | Connect al computer Windows e avvia SQL Server Management Studio.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configura la connessione SSMS. | Configura la connessione al database utilizzando l'autenticazione di Windows.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Configurare le impostazioni di sicurezza. | Imposta i parametri di sicurezza richiesti per SSMS versione 20 o successiva.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | | Crea un accesso a Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)
CREATE LOGIN [| DBA, ingegnere DevOps | | Prova l'autenticazione di Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingegnere DevOps | ## Risorse correlate + [Creando il tuo AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) + [Unire un'istanza Amazon EC2 Windows al tuo AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/launching_instance.html) + [Regioni e motori DB supportati per l'autenticazione Kerberos in Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html) + [Che cos'è SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) # Configurazione dell'accesso multi-account in Amazon DynamoDB *Shashi Dalmia, Imhortha Ojior e Esteban Serna Parra, Amazon Web Services* ## Riepilogo Questo modello spiega i passaggi per configurare l'accesso tra account diversi ad Amazon DynamoDB utilizzando policy basate sulle risorse. Per i carichi di lavoro che utilizzano DynamoDB, sta diventando sempre più comune [utilizzare strategie di isolamento del carico di lavoro](https://aws.amazon.com/solutions/guidance/workload-isolation-on-aws/?did=sl_card&trk=sl_card) per ridurre al minimo le minacce alla sicurezza e soddisfare i requisiti di conformità. L'implementazione di strategie di isolamento del carico di lavoro spesso richiede l'accesso tra account e regioni diverse alle risorse DynamoDB utilizzando policy basate sull'identità (IAM). AWS Identity and Access Management Ciò comporta l'impostazione delle autorizzazioni IAM e la creazione di una relazione di fiducia tra. Account AWS Le policy [basate sulle risorse per DynamoDB semplificano notevolmente il livello di sicurezza per i carichi di lavoro](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) tra account. Questo modello fornisce passaggi e codice di esempio per dimostrare come configurare AWS Lambda le funzioni in una sola Account AWS per scrivere dati su una tabella di database DynamoDB in un account diverso. ## Prerequisiti e limitazioni **Prerequisiti** + Due attivi. Account AWS Questo modello si riferisce a questi conti come *Account A* e *Account B.* + AWS Command Line Interface (AWS CLI) [installato](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [configurato](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) per accedere all'Account A, per creare la tabella DynamoDB. Gli altri passaggi di questo modello forniscono istruzioni per l'utilizzo delle console IAM, DynamoDB e Lambda. Se AWS CLI invece intendi utilizzarla, configurala per accedere a entrambi gli account. **Limitazioni** + Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. ## Architecture Il diagramma seguente mostra un'architettura a account singolo. AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2) e DynamoDB si trovano tutti nello stesso account. In questo scenario, le funzioni Lambda e le EC2 istanze Amazon possono accedere a DynamoDB. Per concedere l'accesso alla tabella DynamoDB, puoi creare una policy basata sull'identità in IAM oppure puoi creare una policy basata sulle risorse in DynamoDB. ![\[Utilizzo delle autorizzazioni IAM per accedere a una tabella DynamoDB nello stesso account.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/cbb009eb-422d-4833-a1bc-0c571d83c21f.png) Il diagramma seguente mostra un'architettura multi-account. Se le risorse di una tabella Account AWS richiedono l'accesso a una tabella DynamoDB in un account diverso, è necessario impostare una policy basata sulle risorse in DynamoDB per concedere l'accesso richiesto. Ad esempio, nel diagramma seguente, l'accesso alla tabella DynamoDB nell'Account A viene concesso a una funzione Lambda nell'Account B utilizzando una politica basata sulle risorse. ![\[Utilizzo di una policy basata sulle risorse per accedere a una tabella DynamoDB in un account diverso.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/9f9165a8-b767-4427-a2ae-31b5b8c83326.png) Questo modello descrive l'accesso tra più account tra Lambda e DynamoDB. È possibile utilizzare passaggi simili per altri Servizi AWS se le autorizzazioni appropriate sono configurate su entrambi gli account. [Ad esempio, se desideri fornire a una funzione Lambda l'accesso a un bucket Amazon Simple Storage Service (Amazon S3) nell'Account A, puoi creare una [policy basata sulle risorse in Amazon S3 e aggiungere le autorizzazioni al ruolo di esecuzione Lambda nell'](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html)Account B.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) ## Tools (Strumenti) **Servizi AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue risorse AWS controllando chi è autenticato e autorizzato a utilizzarle. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. **Codice** Questo modello include un codice di esempio nella sezione [Informazioni aggiuntive](#configure-cross-account-access-to-amazon-dynamodb-additional) per mostrare come configurare una funzione Lambda nell'Account B per scrivere nella tabella DynamoDB nell'Account A. Il codice viene fornito solo a scopo illustrativo e di test. Se stai implementando questo pattern in un ambiente di produzione, usa il codice come riferimento e personalizzalo per il tuo ambiente. ## Best practice + Segui le [best practice per le policy basate sulle risorse](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-best-practices.html) nella documentazione di DynamoDB. + Segui il principio del privilegio minimo e concedi le autorizzazioni minime necessarie per eseguire un'attività. Per ulteriori informazioni, consulta le [best practice relative alla [concessione dei privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e alla sicurezza nella documentazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) IAM. ## Epiche ### Creare una policy e un ruolo IAM per la funzione Lambda nell'Account B | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una politica nell'Account B. | Questa policy IAM consente l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)azione per una tabella DynamoDB nell'Account A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Informazioni generali su AWS | | Crea un ruolo nell'account B. | La funzione Lambda nell'Account B utilizza questo ruolo IAM per accedere alla tabella DynamoDB nell'Account A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Per ulteriori informazioni sulla creazione di ruoli, consulta la [documentazione IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). | Informazioni generali su AWS | | Nota l'ARN del ruolo . | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Informazioni generali su AWS | ### Creare una tabella DynamoDB nell'account A | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una tabella DynamoDB. | Utilizzate il seguente AWS CLI comando per creare una tabella DynamoDB.\ ] FROM WINDOWS;
GO
aws dynamodb create-table \Sostituisci quanto segue in questo esempio di codice:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Si specifica la configurazione della politica basata sulle risorse nell'`create-table`istruzione utilizzando il flag. `--resource-policy` Questa politica si riferisce all'ARN per la tabella DynamoDB nell'account A.Per ulteriori informazioni sulla creazione di tabelle, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html). | Informazioni generali su AWS | ### Creare una funzione Lambda nell'account B | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una funzione Lambda per scrivere dati su DynamoDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)[Per ulteriori informazioni sulla creazione di funzioni Lambda, consulta la documentazione Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) | Informazioni generali su AWS | ### Eliminazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Eliminare le risorse . | Per evitare di incorrere nei costi associati alle risorse create secondo questo schema, procedi come segue per eliminare tali risorse:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Informazioni generali su AWS | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Quando si crea la funzione Lambda, viene visualizzato un `ResourceNotFoundException` errore. | Conferma di aver inserito correttamente l'ID Regione AWS e dell'account A. Questi fanno parte dell'ARN per la tabella DynamoDB. | ## Risorse correlate + [Guida introduttiva a DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) (documentazione su DynamoDB) + [Guida introduttiva a Lambda (documentazione](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) Lambda) + [Utilizzo di policy basate sulle risorse per DynamoDB (documentazione DynamoDB)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) + [Creazione di politiche IAM (documentazione IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) + [Logica di valutazione delle politiche tra account](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) (documentazione IAM) + [Riferimento agli elementi della policy IAM JSON (documentazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) IAM) ## Informazioni aggiuntive *Codice di esempio* ``` import boto3 from datetime import datetime dynamodb_client = boto3.client('dynamodb') def lambda_handler(event, context): now = datetime.now().isoformat() data = dynamodb_client.put_item(TableName='arn:aws:dynamodb:
--table-name Table-Account-A \
--attribute-definitions \
AttributeName=category,AttributeType=S \
AttributeName=item,AttributeType=S \
--key-schema \
AttributeName=category,KeyType=HASH \
AttributeName=item,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=5,WriteCapacityUnits=5 \
--resource-policy \
'{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/ "
},
"Action": "dynamodb:PutItem",
"Resource": "arn:aws:dynamodb:: :table/Table-Account-A"
}
]
}'
SELECT SERVERPROPERTY('ComputernamePhysicalNetBios') .L'output mostrerà il nome corrente della replica secondaria (`WSFCNODE1`). | DBA |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| La creazione del listener non riesce e viene visualizzato il messaggio «Il cluster WSFC non è riuscito a portare online la risorsa Network Name». | Per informazioni, consulta il post sul blog di Microsoft [Create Listener Fails with Message «Il cluster WSFC non è riuscito a portare online la risorsa Network Name](https://techcommunity.microsoft.com/t5/sql-server-support-blog/create-listener-fails-with-message-the-wsfc-cluster-could-not/ba-p/318235)». |
| Potenziali problemi, inclusi altri problemi relativi agli ascoltatori o problemi di accesso alla rete. | Vedi [Risoluzione dei problemi di configurazione dei gruppi di disponibilità Always On (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16) nella documentazione Microsoft. |
## Risorse correlate
+ [Configura il routing di sola lettura per un gruppo di disponibilità Always On](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/configure-read-only-routing-for-an-availability-group-sql-server?view=sql-server-ver16)
+ [Risolvi i problemi di configurazione dei gruppi di disponibilità Always On (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16)
## Informazioni aggiuntive
**Fase 1: Aggiorna le repliche in modalità di sola lettura**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
```
**Fase 2. Crea l'URL di routing**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode1.tagechtalk.com:1433'))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode2.tagechtalk.com:1433'))
GO
```
**Fase 3. Crea la lista di routing**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (PRIMARY_ROLE(READ_ONLY_ROUTING_LIST=('WSFCNODE2','WSFCNODE1')));
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('WSFCNODE1','WSFCNODE2')));
GO
```
**Fase 4. Convalida la lista di routing**
```
SELECT AGSrc.replica_server_name AS PrimaryReplica, AGRepl.replica_server_name AS ReadOnlyReplica, AGRepl.read_only_routing_url AS RoutingURL , AGRL.routing_priority AS RoutingPriority FROM sys.availability_read_only_routing_lists AGRL INNER JOIN sys.availability_replicas AGSrc ON AGRL.replica_id = AGSrc.replica_id INNER JOIN sys.availability_replicas AGRepl ON AGRL.read_only_replica_id = AGRepl.replica_id INNER JOIN sys.availability_groups AV ON AV.group_id = AGSrc.group_id ORDER BY PrimaryReplica
```
**Fase 5: Utilità di comando SQL**
```
sqlcmd -S SQLAG1,1433 -E -d test -K ReadOnly
```
# Connect utilizzando un tunnel SSH in pGAdmin
*Jeevan Shetty e Bhanu Ganesh Gudivada, Amazon Web Services*
## Riepilogo
Per motivi di sicurezza, è sempre consigliabile collocare i database in una sottorete privata. Le query sul database possono essere eseguite connettendosi tramite un host bastion Amazon Elastic Compute Cloud EC2 (Amazon) in una sottorete pubblica sul cloud Amazon Web Services (AWS). Ciò richiede l'installazione di software, come pgAdmin DBeaver o, comunemente utilizzati dagli sviluppatori o dagli amministratori di database, sull'host Amazon. EC2
L'esecuzione di pGAdmin su un server Linux e l'accesso ad esso tramite un browser Web richiedono l'installazione di dipendenze aggiuntive, l'impostazione delle autorizzazioni e la configurazione.
Come soluzione alternativa, gli sviluppatori o gli amministratori di database possono connettersi a un database PostgreSQL utilizzando pgadmin per abilitare un tunnel SSH dal proprio sistema locale. In questo approccio, pgAdmin utilizza l'host EC2 Amazon nella sottorete pubblica come host intermedio prima di connettersi al database. Il diagramma nella sezione *Architettura* mostra la configurazione.
**Nota**
Assicurati che il gruppo di sicurezza collegato al database PostgreSQL consenta la connessione sulla porta 5432 dall'host Amazon. EC2
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS esistente
+ Un cloud privato virtuale (VPC) con una sottorete pubblica e una sottorete privata
+ Un' EC2 istanza con un gruppo di sicurezza collegato
+ Un database Edition compatibile con Amazon Aurora PostgreSQL con un gruppo di sicurezza collegato
+ Una coppia di key pair Secure Shell (SSH) per configurare il tunnel
**Versioni del prodotto**
+ pGAdmin versione 6.2\$1
+ Amazon Aurora versione 12.7\$1 compatibile con PostgreSQL
## Architecture
**Stack tecnologico Target**
+ Amazon EC2
+ Compatibile con Amazon Aurora PostgreSQL
**Architettura Target**
Il diagramma seguente mostra l'utilizzo di pGAdmin con un tunnel SSH per connettersi tramite un gateway Internet all'istanza, che si connette EC2 al database.
![\[pGAdmin con tunnel SSH si connette tramite gateway internet EC2 all'istanza che si connette al database.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/7d25d570-5685-4f1a-bef0-212e257cb589/images/4556d930-f9b3-4b65-be5d-d40dd9437d5a.png)
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Aurora PostgreSQL Compatible Edition è un motore](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) di database relazionale completamente gestito e conforme ad ACID che ti aiuta a configurare, gestire e scalare le distribuzioni PostgreSQL.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fornisce capacità di calcolo scalabile nel cloud AWS. Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente.
**Altri servizi**
+ [pgAdmin](https://www.pgadmin.org/) è uno strumento di gestione open source per PostgreSQL. Fornisce un'interfaccia grafica che consente di creare, gestire e utilizzare oggetti di database.
## Epiche
### Crea la connessione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un server. | **In pgAdmin, **scegli Crea, quindi scegli** Server.** *Per ulteriori informazioni sulla configurazione di pGAdmin per registrare un server, configurare una connessione e connettersi tramite tunneling SSH utilizzando la finestra di dialogo del server, vedere i collegamenti nella sezione Risorse correlate.* | DBA |
| Fornisci un nome per il server. | Nella scheda **Generale**, inserisci un nome. | DBA |
| Inserisci i dettagli del database. | Nella scheda **Connessione**, inserisci i valori seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Inserisci i dettagli EC2 del server Amazon. | Nella scheda **SSH Tunnel**, fornisci i dettagli dell' EC2 istanza Amazon che si trova nella sottorete pubblica.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Salva e connettiti. | Scegli **Salva** per completare la configurazione e connetterti al database Aurora compatibile con PostgreSQL utilizzando il tunnel SSH. | DBA |
## Risorse correlate
+ [Dialogo del server](https://www.pgadmin.org/docs/pgadmin4/latest/server_dialog.html)
+ [Connect al server](https://www.pgadmin.org/docs/pgadmin4/latest/connect_to_server.html)
# Convertire le query JSON Oracle in SQL del database PostgreSQL
*Pinesh Singal e Lokesh Gurram, Amazon Web Services*
## Riepilogo
Questo processo di migrazione per il passaggio dall'ambiente locale al cloud Amazon Web Services (AWS) utilizza AWS Schema Conversion Tool (AWS SCT) per convertire il codice da un database Oracle in un database PostgreSQL. La maggior parte del codice viene convertita automaticamente da AWS SCT. Tuttavia, le query Oracle relative a JSON non vengono convertite automaticamente.
A partire dalla versione Oracle 12.2, Oracle Database supporta varie funzioni JSON che aiutano a convertire i dati basati su JSON in dati basati su Row. Tuttavia, AWS SCT non converte automaticamente i dati basati su JSON in un linguaggio supportato da PostgreSQL.
Questo modello di migrazione si concentra principalmente sulla conversione manuale delle query Oracle relative a JSON con funzioni come `JSON_OBJECT` e `JSON_TABLE` da un database Oracle a un database PostgreSQL. `JSON_ARRAYAGG`
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ Un'istanza di database Oracle locale (attiva e funzionante)
+ Un'istanza di database Amazon Relational Database Service (Amazon RDS) per PostgreSQL o Amazon Aurora PostgreSQL Compatible Edition (attiva e funzionante)
**Limitazioni**
+ Le query `KEY` relative a JSON richiedono un formato e fisso. `VALUE` Il mancato utilizzo di quel formato restituisce un risultato errato.
+ Se una modifica nella struttura JSON aggiunge nuove `KEY` `VALUE` coppie nella sezione dei risultati, è necessario modificare la procedura o la funzione corrispondente nella query SQL.
+ Alcune funzioni relative a JSON sono supportate nelle versioni precedenti di Oracle e PostgreSQL ma con meno funzionalità.
**Versioni del prodotto**
+ Oracle Database versione 12.2 e successive
+ Amazon RDS for PostgreSQL o Aurora PostgreSQL versione 9.5 e successive
+ Versione più recente di AWS SCT (testata utilizzando la versione 1.0.664)
## Architecture
**Stack tecnologico di origine**
+ Un'istanza di database Oracle con versione 19c
**Stack tecnologico Target**
+ Un'istanza di database compatibile con Amazon RDS for PostgreSQL o Aurora PostgreSQL con versione 13
**Architettura Target**
![\[La descrizione segue il diagramma.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5e2c3b07-9ef5-417f-b049-bcea58f2c3ec/images/2ff8b00b-8849-4ef1-9be1-579f7b51be10.png)
1. Usa AWS SCT con il codice della funzione JSON per convertire il codice sorgente da Oracle a PostgreSQL.
1. La conversione produce file.sql migrati supportati da PostgreSQL.
1. Converti manualmente i codici funzione Oracle JSON non convertiti in codici funzione JSON PostgreSQL.
1. Esegui i file.sql sull'istanza DB di destinazione compatibile con Aurora PostgreSQL.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) è un motore di database relazionale completamente gestito creato per il cloud e compatibile con MySQL e PostgreSQL.
+ [Amazon Relational Database Service (Amazon RDS) per PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) ti aiuta a configurare, gestire e scalare un database relazionale PostgreSQL nel cloud AWS.
+ [AWS Schema Conversion Tool (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) supporta migrazioni di database eterogenei convertendo automaticamente lo schema del database di origine e la maggior parte del codice personalizzato in un formato compatibile con il database di destinazione.
**Altri servizi**
+ [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) è un ambiente di sviluppo integrato che semplifica lo sviluppo e la gestione dei database Oracle nelle implementazioni tradizionali e basate sul cloud.
+ pGadmin o DBeaver. [pgAdmin](https://www.pgadmin.org/) è uno strumento di gestione open source per PostgreSQL. Fornisce un'interfaccia grafica che consente di creare, gestire e utilizzare oggetti di database. [DBeaver](https://dbeaver.io/)è uno strumento di database universale.
## Best practice
La query di Oracle ha il tipo `CAST` come impostazione predefinita quando si utilizza la `JSON_TABLE` funzione. Una best practice consiste `CAST` nell'utilizzarla anche in PostgreSQL, utilizzando il doppio dei caratteri maggiori di (). `>>`
*Per ulteriori informazioni, consulta *Postgres\$1SQL\$1read\$1JSON* nella sezione Informazioni aggiuntive.*
## Epiche
### Genera i dati JSON nei database Oracle e PostgreSQL
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Memorizza i dati JSON nel database Oracle. | Crea una tabella nel database Oracle e archivia i dati JSON nella `CLOB` colonna. *Utilizzate *Oracle\$1Table\$1Creation\$1Insert\$1Script che si trova nella sezione* Informazioni aggiuntive.* | Ingegnere della migrazione |
| Archivia i dati JSON nel database PostgreSQL. | Crea una tabella nel database PostgreSQL e archivia i dati JSON nella colonna. `TEXT` *Usa *Postgres\$1Table\$1Creation\$1Insert\$1Script* che si trova nella sezione Informazioni aggiuntive.* | Ingegnere della migrazione |
### Converti il JSON in formato ROW
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Convertire i dati JSON sul database Oracle. | Scrivi una query Oracle SQL per leggere i dati JSON in formato ROW. *Per ulteriori dettagli ed esempi di sintassi, vedere *Oracle\$1SQL\$1read\$1JSON* nella sezione Informazioni aggiuntive.* | Ingegnere della migrazione |
| Converti i dati JSON nel database PostgreSQL. | Scrivi una query PostgreSQL per leggere i dati JSON in formato ROW. *Per maggiori dettagli ed esempi di sintassi, consulta *Postgres\$1SQL\$1read\$1JSON* nella sezione Informazioni aggiuntive.* | Ingegnere della migrazione |
### Converti manualmente i dati JSON utilizzando la query SQL e riporta l'output in formato JSON
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui aggregazioni e convalide sulla query Oracle SQL. | Per convertire manualmente i dati JSON, esegui un'unione, un'aggregazione e una convalida sulla query Oracle SQL e riporta l'output in formato JSON. *Utilizza il codice in *Oracle\$1SQL\$1JSON\$1AGGREGATION\$1join nella sezione Informazioni aggiuntive*.*[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingegnere della migrazione |
| Esegui aggregazioni e convalide sulla query SQL di Postgres. | Per convertire manualmente i dati JSON, esegui un'unione, un'aggregazione e una convalida sulla query PostgreSQL e riporta l'output in formato JSON. **Usa il codice in Postgres\$1SQL\$1JSON\$1Aggregation\$1join nella sezione Informazioni aggiuntive.**[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingegnere della migrazione |
### Convertire la procedura Oracle in una funzione PostgreSQL che contiene query JSON
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Convertire le query JSON nella procedura Oracle in righe. | *Per la procedura Oracle di esempio, utilizzate la precedente query Oracle e il codice in *ORACLE\$1PROCEDURE\$1with\$1JSON\$1Query* nella sezione Informazioni aggiuntive.* | Ingegnere della migrazione |
| Converti le funzioni PostgreSQL che contengono query JSON in dati basati su righe. | **Per le funzioni PostgreSQL di esempio, usa la precedente query PostgreSQL e il codice che si trova in Postgres\$1function\$1with\$1JSON\$1Query nella sezione Informazioni aggiuntive.** | Ingegnere della migrazione |
## Risorse correlate
+ [Funzioni Oracle JSON](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/adjsn/generation.html)
+ [Funzioni PostgreSQL JSON](https://www.postgresql.org/docs/13/functions-json.html)
+ [Esempi di funzioni JSON di Oracle](https://oracle-base.com/articles/12c/sql-json-functions-12cr2)
+ [Esempi di funzioni JSON PostgreSQL](https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg)
+ [Strumento di conversione dello schema AWS](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)
## Informazioni aggiuntive
Per convertire il codice JSON dal database Oracle al database PostgreSQL, utilizzare i seguenti script, nell'ordine.
**1. Oracle\$1Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_table(id number,created_on date default sysdate,modified_on date,json_doc clob);
REM INSERTING into EXPORT_TABLE
SET DEFINE OFF;
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc)
values (1,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -'",
"a]')
|| TO_CLOB(q'[ccount" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
]')
|| TO_CLOB(q'[ "name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc) values (2,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "pqr@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -'",
"account" : {
"companyId" : "CARS",
"busin]')
|| TO_CLOB(q'[essUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
]')
|| TO_CLOB(q'[ "domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
commit;
```
**2. Postgres Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_pg_table(id int,created_on date ,modified_on date,json_doc text);
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(1,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(2,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "a*b**@h**.k**",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -",
"account" : {
"companyId" : "CARS",
"businessUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
```
**3. Oracle\$1SQL\$1read\$1json**
I seguenti blocchi di codice mostrano come convertire i dati Oracle JSON in formato riga.
*Query e sintassi di esempio*
```
SELECT JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) ) FROM
(SELECT tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number );
```
Il documento JSON memorizza i dati come raccolte. Ogni raccolta può avere `KEY` e `VALUE` accoppiare. Ognuno `VALUE` può avere nidi `KEY` e `VALUE` coppie. La tabella seguente fornisce informazioni sulla lettura delle specifiche `VALUE` del documento JSON.
|
|
| KEY | HIERARCHY o PATH da utilizzare per ottenere il VALORE | VALUE |
| --- |--- |--- |
| `profileType` | `metadata` -> `profileType` | «P» |
| `positionId` | `data` -> `positionId` | «100" |
| `accountNumber` | `data`-> conto -> `accountNumber` | 42000 |
Nella tabella precedente, `KEY` `profileType` è un `VALUE` dei `metadata``KEY`. Il `KEY` `positionId` è uno `VALUE` dei `data``KEY`. Il `KEY` `accountNumber` è un `VALUE` dei `account``KEY`, e il `account` `KEY` è un `VALUE` dei `data``KEY`.
*Esempio di documento JSON*
```
{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}
```
*Query SQL utilizzata per ottenere i campi selezionati dal documento JSON*
```
select parent_account_number,account_number,business_unit_id,position_id from aws_test_table aws,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId'
)) as sc
```
Nella query precedente, `JSON_TABLE` è una funzione integrata in Oracle che converte i dati JSON in formato riga. La funzione JSON\$1TABLE prevede parametri in formato JSON.
Ogni elemento `COLUMNS` ha un valore predefinito `PATH` e lì viene restituito un valore appropriato `VALUE` per un dato `KEY` elemento in formato riga.
*Risultato della query precedente*
|
|
| PARENT\$1ACCOUNT\$1NUMBER | NUMERO\$1CONTO | ID\$1UNITÀ\$1AZIENDALE | ID\$1POSIZIONE |
| --- |--- |--- |--- |
| 32000 | 42000 | 7 | 0100 |
| 32001 | 42001 | 6 | 0090 |
**4. Postgres\$1sql\$1read\$1json**
*****Query e sintassi di esempio*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::VARCHAR as positionId
from aws_test_pg_table) d ;
```
In Oracle, `PATH` viene utilizzato per identificare lo specifico `KEY` e`VALUE`. Tuttavia, PostgreSQL utilizza `HIERARCHY` un modello per la lettura e da JSON. `KEY` `VALUE` Gli stessi dati JSON menzionati di seguito vengono utilizzati negli `Oracle_SQL_Read_JSON` esempi seguenti.
*La query SQL di tipo CAST non è consentita*
(Se si forza il tipo`CAST`, la query ha esito negativo e viene generato un errore di sintassi).
```
select *
from (
select (json_doc::json->'data'->'account'->'parentAccountNumber') as parentAccountNumber,
(json_doc::json->'data'->'account'->'accountNumber')as accountNumber,
(json_doc::json->'data'->'account'->'businessUnitId') as businessUnitId,
(json_doc::json->'data'->'positionId')as positionId
from aws_test_pg_table) d ;
```
L'utilizzo di un singolo operatore maggiore di (`>`) restituirà il `VALUE` relativo valore definito. `KEY` Ad esempio,`KEY`: e:`positionId`. `VALUE` `"0100"`
`CAST`Il tipo non è consentito quando si utilizza il singolo operatore maggiore di (). `>`
*È consentita una query SQL di tipo CAST*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) d ;
```
Per utilizzare type`CAST`, è necessario utilizzare l'operatore double greater-than. Se si utilizza il singolo operatore maggiore di, la query restituisce il valore `VALUE` definito (ad esempio,`KEY`: e:). `positionId` `VALUE` `"0100"` L'utilizzo dell'operatore double greater-than (`>>`) restituirà il valore effettivo definito per tale operazione `KEY` (ad esempio,`KEY`: e`VALUE`: `positionId``0100`, senza virgolette doppie).
Nel caso precedente, is type to, `parentAccountNumber` is type `CAST` to`INT`, `accountNumber` is type `CAST` to `INT` e `businessUnitId` is type `CAST` `INT` to. `positionId` `CAST` `VARCHAR`
Le tabelle seguenti mostrano i risultati delle interrogazioni che spiegano il ruolo del singolo operatore maggiore di (`>`) e del doppio operatore maggiore di (). `>>`
Nella prima tabella, la query utilizza il singolo operatore maggiore di (). `>` Ogni colonna è di tipo JSON e non può essere convertita in un altro tipo di dati.
|
|
| parentAccountNumber | Numero di conto | businessUnitId | ID di posizione |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | «0100" |
| 2005284042 | 2005284042 | 6 | «0090" |
| 2000272719 | 2000272719 | 1 | «0100" |
Nella seconda tabella, la query utilizza l'operatore double greater-than (). `>>` Ogni colonna supporta il tipo in `CAST` base al valore della colonna. Ad esempio, `INTEGER` in questo contesto.
|
|
| parentAccountNumber | Numero di conto | businessUnitId | ID di posizione |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | 0100 |
| 2005284042 | 2005284042 | 6 | 0090 |
| 2000272719 | 2000272719 | 1 | 0100 |
**5. Oracle\$1SQL\$1JSON\$1AGGREGATION\$1JOIN**
*Query di esempio*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
Per convertire i dati a livello di riga in formato JSON, Oracle dispone di funzioni integrate come`JSON_OBJECT`,`JSON_ARRAY`, `JSON_OBJECTAGG` e. `JSON_ARRAYAGG`
+ `JSON_OBJECT`accetta due parametri: e. `KEY` `VALUE` Il `KEY` parametro deve essere codificato o di natura statica. Il `VALUE` parametro è derivato dall'output della tabella.
+ `JSON_ARRAYAGG`accetta `JSON_OBJECT` come parametro. Questo aiuta a raggruppare l'insieme di `JSON_OBJECT` elementi in un elenco. Ad esempio, se hai un `JSON_OBJECT` elemento con più record (multipli `KEY` e `VALUE` coppie nel set di dati), `JSON_ARRAYAGG` aggiunge il set di dati e crea un elenco. Secondo il linguaggio Data Structure, `LIST` è un gruppo di elementi. In questo contesto, `LIST` è un gruppo di `JSON_OBJECT` elementi.
L'esempio seguente mostra un `JSON_OBJECT` elemento.
```
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
```
Il prossimo esempio mostra due `JSON_OBJECT` elementi, `LIST` indicati da parentesi quadre (`[ ]`).
```
[
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
,
{
"taxProfessionalCount": 2,
"attorneyCount": 1,
"nonAttorneyCount": 3,
"clerkCount":4
}
]
```
*Esempio di query SQL*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
)
)
)
)
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END
) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END
) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END
) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END
) clerk_count
FROM
aws_test_table scco, JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
*Esempio di output della precedente query SQL*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**6. Postgres\$1SQL\$1JSON\$1AGGREGATION\$1JOIN**
Le `JSON_BUILD_OBJECT` funzioni `JSON_AGG` integrate di PostgreSQL convertono i dati a livello di riga in formato JSON. `JSON_BUILD_OBJECT`PostgreSQL e sono equivalenti a Oracle `JSON_AGG` e. `JSON_OBJECT` `JSON_ARRAYAGG`
*Query di esempio*
```
select
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
)
)
)
)
from (
with tab as (select * from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) a ) ,
tab1 as ( select
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
from (
select '{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}'::json as jc) b)
select
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
from tab1,tab
where tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
and tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
and tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
```
*Esempio di output della query precedente*
L'output di Oracle e PostgreSQL è esattamente lo stesso.
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**7. Oracle\$1procedure\$1with\$1JSON\$1Query**
Questo codice converte la procedura Oracle in una funzione PostgreSQL con query SQL JSON. Mostra come la query traspone JSON in righe e viceversa.
```
CREATE OR REPLACE PROCEDURE p_json_test(p_in_accounts_json IN varchar2, p_out_accunts_json OUT varchar2)
IS
BEGIN
/*
p_in_accounts_json paramter should have following format:
{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}
*/
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
into p_out_accunts_json
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( p_in_accounts_json, '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,'Error while running the JSON query');
END;
/
```
*Esecuzione della procedura*
Il seguente blocco di codice spiega come eseguire la procedura Oracle creata in precedenza con un esempio di input JSON per la procedura. Fornisce inoltre il risultato o l'output di questa procedura.
```
set serveroutput on;
declare
v_out varchar2(30000);
v_in varchar2(30000):= '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}';
begin
p_json_test(v_in,v_out);
dbms_output.put_line(v_out);
end;
/
```
*Output della procedura*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**8. Postgres\$1function\$1with\$1JSON\$1QUERY**
*Funzione di esempio*
```
CREATE OR REPLACE FUNCTION f_pg_json_test(p_in_accounts_json text)
RETURNS text
LANGUAGE plpgsql
AS
$$
DECLARE
v_out_accunts_json text;
BEGIN
SELECT
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
))))
INTO v_out_accunts_json
FROM (
WITH tab AS (SELECT * FROM (
SELECT (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER AS parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER AS accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER AS businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar AS positionId
FROM aws_test_pg_table) a ) ,
tab1 AS ( SELECT
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
FROM (
SELECT p_in_accounts_json::json AS jc) b)
SELECT
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
FROM tab1,tab
WHERE tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
AND tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
AND tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
RETURN v_out_accunts_json;
END;
$$;
```
*Esecuzione della funzione*
```
select f_pg_json_test('{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}') ;
```
*Uscita della funzione*
L'output seguente è simile all'output della procedura Oracle. La differenza è che questo output è in formato testo.
```
{
"accountCounts": [
{
"businessUnitId": "6",
"parentAccountNumber": "32001",
"accountNumber": "42001",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": "7",
"parentAccountNumber": "32000",
"accountNumber": "42000",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
# Copia le tabelle Amazon DynamoDB tra gli account utilizzando AWS Backup
*Ramkumar Ramanujam, Amazon Web Services*
## Riepilogo
Quando si lavora con Amazon DynamoDB AWS on, un caso d'uso comune consiste nel copiare o sincronizzare le tabelle DynamoDB in ambienti di sviluppo, test o staging con i dati delle tabelle presenti nell'ambiente di produzione. Come prassi standard, ogni ambiente ne utilizza uno diverso. Account AWS
AWS Backup supporta il backup e il ripristino dei dati tra regioni e account diversi per DynamoDB, Amazon Simple Storage Service (Amazon S3) e altri. Servizi AWS Questo modello fornisce i passaggi per utilizzare il backup e il ripristino AWS Backup tra account diversi per copiare le tabelle DynamoDB tra di loro. Account AWS
## Prerequisiti e limitazioni
**Prerequisiti**
+ Due attivi Account AWS che appartengono alla stessa organizzazione in AWS Organizations
+ Autorizzazioni per creare tabelle DynamoDB in entrambi gli account
+ AWS Identity and Access Management (IAM) autorizzazioni per creare e utilizzare casseforti AWS Backup
**Limitazioni**
+ L'origine e la destinazione Account AWS devono far parte della stessa organizzazione in. AWS Organizations
## Architecture
**Stack tecnologico di destinazione**
+ AWS Backup
+ Amazon DynamoDB
**Architettura di destinazione**
![\[La descrizione della copia delle tabelle tra gli archivi di backup segue il diagramma.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/ef6e7393-edb6-4744-be26-43f1cbff9de9/images/fa9f3f2f-7a01-4093-9bd5-fc355e57ba67.png)
1. Crea il backup della tabella DynamoDB nell'archivio di backup AWS Backup nell'account di origine.
1. Copia il backup nell'archivio di backup nell'account di destinazione.
1. Ripristina la tabella DynamoDB nell'account di destinazione utilizzando il backup dall'archivio di backup nell'account di destinazione.
**Automazione e scalabilità**
È possibile AWS Backup utilizzarlo per pianificare l'esecuzione dei backup a intervalli specifici.
## Tools (Strumenti)
+ [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html)è un servizio completamente gestito per centralizzare e automatizzare la protezione dei dati su Servizi AWS, nel cloud e in locale. Utilizzando questo servizio, è possibile configurare le politiche di backup e monitorare l'attività delle risorse in un unico posto. AWS Consente di automatizzare e consolidare le attività di backup precedentemente eseguite servizio per servizio ed elimina la necessità di creare script personalizzati e processi manuali.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL completamente gestito che offre prestazioni veloci e prevedibili con una scalabilità perfetta.
## Epiche
### Attiva le AWS Backup funzionalità negli account di origine e di destinazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Attiva le funzionalità avanzate per DynamoDB e il backup tra account. | Sia nell'origine che nella destinazione Account AWS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingegnere addetto alla migrazione |
### Crea archivi di backup negli account di origine e di destinazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea casseforti di backup. | Sia nell'origine che nella destinazione Account AWS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)L' ARNs archivio di backup di origine e quello di destinazione saranno necessari quando si copia il backup della tabella DynamoDB tra gli account di origine e di destinazione. | AWS DevOps, ingegnere addetto alla migrazione |
### Esegui backup e ripristino utilizzando gli archivi di backup
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Nell'account di origine, crea un backup della tabella DynamoDB. | Per creare un backup per la tabella DynamoDB nell'account di origine, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Viene creato un nuovo processo di backup. Per monitorare lo stato del processo di backup, nella pagina AWS Backup **Processi**, selezionare la scheda **Processi di backup**. Tutti i processi di backup attivi, in corso e completati sono elencati in questa scheda. | AWS DevOps, DBA, ingegnere addetto alla migrazione |
| Copia il backup dall'account di origine all'account di destinazione. | Una volta completato il processo di backup, copia il backup della tabella DynamoDB dall'archivio di backup nell'account di origine all'archivio di backup nell'account di destinazione.Per copiare il backup vault, nell'account di origine, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingegnere addetto alla migrazione, DBA |
| Ripristina il backup nell'account di destinazione. | Nella destinazione Account AWS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, DBA, ingegnere addetto alla migrazione |
## Risorse correlate
+ [Utilizzo AWS Backup con DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/backuprestore_HowItWorksAWS.html)
+ [Creazione di copie di backup su Account AWS](https://docs.aws.amazon.com/aws-backup/latest/devguide/create-cross-account-backup.html)
+ [AWS Backup prezzi](https://aws.amazon.com/backup/pricing/)
# Copia le tabelle Amazon DynamoDB tra gli account utilizzando un'implementazione personalizzata
*Ramkumar Ramanujam, Amazon Web Services*
## Riepilogo
Quando si lavora con Amazon DynamoDB su Amazon Web Services (AWS), un caso d'uso comune consiste nel copiare o sincronizzare le tabelle DynamoDB in ambienti di sviluppo, test o staging con i dati delle tabelle presenti nell'ambiente di produzione. Come prassi standard, ogni ambiente utilizza un account AWS diverso.
DynamoDB ora supporta il backup su più account utilizzando AWS Backup. Per informazioni sui costi di storage associati all'utilizzo di AWS Backup, consulta [i prezzi di AWS Backup](https://aws.amazon.com/backup/pricing/). Quando usi AWS Backup per copiare più account, gli account di origine e di destinazione devono far parte di un'organizzazione AWS Organizations. Esistono altre soluzioni per il backup e il ripristino tra account che utilizzano servizi AWS come AWS Glue. L'utilizzo di queste soluzioni, tuttavia, aumenta l'ingombro delle applicazioni, poiché ci sono più servizi AWS da distribuire e mantenere.
Puoi anche usare Amazon DynamoDB Streams per acquisire le modifiche alle tabelle nell'account di origine. Quindi puoi avviare una funzione AWS Lambda e apportare le modifiche corrispondenti nella tabella di destinazione nell'account di destinazione. Ma questa soluzione si applica ai casi d'uso in cui le tabelle di origine e di destinazione devono essere sempre mantenute sincronizzate. Potrebbe non essere applicabile agli ambienti di sviluppo, test e gestione temporanea in cui i dati vengono aggiornati frequentemente.
Questo modello fornisce i passaggi per implementare una soluzione personalizzata per copiare una tabella Amazon DynamoDB da un account all'altro. Questo modello può essere implementato utilizzando linguaggi di programmazione comuni come C\$1, Java e Python. Ti consigliamo di utilizzare un linguaggio supportato da un [SDK AWS](https://aws.amazon.com/tools/).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Due account AWS attivi
+ Tabelle DynamoDB in entrambi gli account
+ Conoscenza dei ruoli e delle policy di AWS Identity and Access Management (IAM)
+ Conoscenza di come accedere alle tabelle di Amazon DynamoDB utilizzando qualsiasi linguaggio di programmazione comune, come C\$1, Java o Python
**Limitazioni**
Questo modello si applica alle tabelle DynamoDB di dimensioni pari o inferiori a 2 GB. Con una logica aggiuntiva per gestire le interruzioni della connessione o della sessione, le limitazioni, gli errori e i nuovi tentativi, può essere utilizzato per tabelle più grandi.
L'operazione di scansione DynamoDB, che legge gli elementi dalla tabella di origine, può recuperare solo fino a 1 MB di dati in una singola chiamata. Per le tabelle più grandi, superiori a 2 GB, questa limitazione può aumentare il tempo totale necessario per eseguire una copia completa della tabella.
## Architecture
Il diagramma seguente mostra l'implementazione personalizzata tra gli account AWS di origine e di destinazione. Le politiche e i token di sicurezza IAM vengono utilizzati con l'implementazione personalizzata. I dati vengono letti da Amazon DynamoDB nell'account di origine e scritti su DynamoDB nell'account di destinazione.
![\[Architettura dell'account di origine e di destinazione per la copia utilizzando l'implementazione personalizzata.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)
**Automazione e scalabilità**
Questo modello si applica alle tabelle DynamoDB di dimensioni inferiori, circa 2 GB.
Per applicare questo modello a tabelle più grandi, risolvi i seguenti problemi:
+ Durante l'operazione di copia della tabella, vengono mantenute due sessioni attive, utilizzando token di sicurezza diversi. Se l'operazione di copia della tabella richiede più tempo dei tempi di scadenza del token, è necessario implementare una logica per aggiornare i token di sicurezza.
+ Se non vengono fornite unità di capacità di lettura (RCUs) e unità di capacità di scrittura (WCUs) sufficienti, le operazioni di lettura o scrittura sulla tabella di origine o di destinazione potrebbero risultare limitate. Assicurati di catturare e gestire queste eccezioni.
+ Gestite eventuali altri errori o eccezioni e predisponete un meccanismo di ripetizione dei tentativi per riprovare o continuare dal punto in cui l'operazione di copia non è riuscita.
## Tools (Strumenti)
**Strumenti**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) — Amazon DynamoDB è un servizio di database NoSQL completamente gestito che offre prestazioni veloci e prevedibili con una scalabilità perfetta.
+ Gli strumenti aggiuntivi richiesti differiranno in base al linguaggio di programmazione scelto per l'implementazione. Ad esempio, se usi C\$1, avrai bisogno di Microsoft Visual Studio e dei seguenti NuGet pacchetti:
+ `AWSSDK`
+ `AWSSDK.DynamoDBv2`
**Codice**
Il seguente frammento di codice Python elimina e ricrea una tabella DynamoDB utilizzando la libreria Boto3.
Non utilizzare la `AWS_ACCESS_KEY_ID` mano `AWS_SECRET_ACCESS_KEY` di un utente IAM perché si tratta di credenziali a lungo termine, che dovrebbero essere evitate per l'accesso programmatico ai servizi AWS. Per ulteriori informazioni sulle credenziali temporanee, consulta la sezione *Best* practice.
Le `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e `TEMPORARY_SESSION_TOKEN` utilizzate nel seguente frammento di codice sono credenziali temporanee recuperate da AWS Security Token Service (AWS STS).
```
import boto3
import sys
import json
#args = input-parameters = GLOBAL_SEC_INDEXES_JSON_COLLECTION, ATTRIBUTES_JSON_COLLECTION, TARGET_DYNAMODB_NAME, TARGET_REGION, ...
#Input param: GLOBAL_SEC_INDEXES_JSON_COLLECTION
#[{"IndexName":"Test-index","KeySchema":[{"AttributeName":"AppId","KeyType":"HASH"},{"AttributeName":"AppType","KeyType":"RANGE"}],"Projection":{"ProjectionType":"INCLUDE","NonKeyAttributes":["PK","SK","OwnerName","AppVersion"]}}]
#Input param: ATTRIBUTES_JSON_COLLECTION
#[{"AttributeName":"PK","AttributeType":"S"},{"AttributeName":"SK","AttributeType":"S"},{"AttributeName":"AppId","AttributeType":"S"},{"AttributeName":"AppType","AttributeType":"N"}]
region = args['TARGET_REGION']
target_ddb_name = args['TARGET_DYNAMODB_NAME']
global_secondary_indexes = json.loads(args['GLOBAL_SEC_INDEXES_JSON_COLLECTION'])
attribute_definitions = json.loads(args['ATTRIBUTES_JSON_COLLECTION'])
# Drop and create target DynamoDB table
dynamodb_client = boto3.Session(
aws_access_key_id=args['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=args['AWS_SECRET_ACCESS_KEY'],
aws_session_token=args['TEMPORARY_SESSION_TOKEN'],
).client('dynamodb')
# Delete table
print('Deleting table: ' + target_ddb_name + ' ...')
try:
dynamodb_client.delete_table(TableName=target_ddb_name)
#Wait for table deletion to complete
waiter = dynamodb_client.get_waiter('table_not_exists')
waiter.wait(TableName=target_ddb_name)
print('Table deleted.')
except dynamodb_client.exceptions.ResourceNotFoundException:
print('Table already deleted / does not exist.')
pass
print('Creating table: ' + target_ddb_name + ' ...')
table = dynamodb_client.create_table(
TableName=target_ddb_name,
KeySchema=[
{
'AttributeName': 'PK',
'KeyType': 'HASH' # Partition key
},
{
'AttributeName': 'SK',
'KeyType': 'RANGE' # Sort key
}
],
AttributeDefinitions=attribute_definitions,
GlobalSecondaryIndexes=global_secondary_indexes,
BillingMode='PAY_PER_REQUEST'
)
waiter = dynamodb_client.get_waiter('table_exists')
waiter.wait(TableName=target_ddb_name)
print('Table created.')
```
## Best practice
**Credenziali temporanee**
Come best practice di sicurezza, mentre accedi ai servizi AWS in modo programmatico, evita di utilizzare la `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY` di un utente IAM perché si tratta di credenziali a lungo termine. Cerca sempre di utilizzare credenziali temporanee per accedere ai servizi AWS in modo programmatico.
Ad esempio, uno sviluppatore inserisce nell'applicazione il codice fisso `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY` di un utente IAM durante lo sviluppo, ma non riesce a rimuovere i valori codificati prima di apportare le modifiche al code repository. Queste credenziali esposte possono essere utilizzate da utenti indesiderati o malintenzionati, il che può avere gravi implicazioni (specialmente se le credenziali esposte hanno privilegi di amministratore). Queste credenziali esposte devono essere disattivate o eliminate immediatamente utilizzando la console IAM o AWS Command Line Interface (AWS CLI).
Per ottenere credenziali temporanee per l'accesso programmatico ai servizi AWS, usa AWS STS. Le credenziali temporanee sono valide solo per il tempo specificato (da 15 minuti a 36 ore). La durata massima consentita per le credenziali temporanee varia in base a fattori quali le impostazioni dei ruoli e il concatenamento dei ruoli. Per ulteriori informazioni su AWS STS, consulta la [documentazione](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).
## Poemi epici
### Configurare le tabelle DynamoDB
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea tabelle DynamoDB. | Crea tabelle DynamoDB, con indici, negli account AWS di origine e di destinazione.Imposta il provisioning della capacità come modalità on-demand, che consente a DynamoDB di scalare le read/write capacità in modo dinamico in base al carico di lavoro. In alternativa, è possibile utilizzare la capacità assegnata con 4000 e 4000. RCUs WCUs | Sviluppatore di app, DBA, ingegnere addetto alla migrazione |
| Compila la tabella dei sorgenti. | Compila la tabella DynamoDB nell'account di origine con i dati di test. Avere almeno 50 MB o più di dati di test consente di visualizzare il picco e la media del RCUs consumo durante la copia della tabella. È quindi possibile modificare il provisioning della capacità in base alle esigenze. | Sviluppatore di app, DBA, ingegnere addetto alla migrazione |
### Imposta le credenziali per accedere alle tabelle DynamoDB
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea ruoli IAM per accedere alle tabelle DynamoDB di origine e di destinazione. | Crea un ruolo IAM nell'account di origine con le autorizzazioni per accedere (leggere) alla tabella DynamoDB nell'account di origine.Aggiungi l'account di origine come entità attendibile per questo ruolo.Crea un ruolo IAM nell'account di destinazione con le autorizzazioni per accedere (creare, leggere, aggiornare, eliminare) alla tabella DynamoDB nell'account di destinazione. Aggiungi l'account di destinazione come entità affidabile per questo ruolo. | Sviluppatore di app, AWS DevOps |
### Copia i dati della tabella da un account a un altro
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Ottieni credenziali temporanee per i ruoli IAM. | Ottieni credenziali temporanee per il ruolo IAM creato nell'account di origine.Ottieni credenziali temporanee per il ruolo IAM creato nell'account di destinazione.Un modo per ottenere le credenziali temporanee per il ruolo IAM consiste nell'utilizzare AWS STS dalla CLI di AWS.aws sts assume-role --role-arn arn:aws:iam::Utilizza il profilo AWS appropriato (corrispondente all'account di origine o di destinazione).Per ulteriori informazioni sui diversi modi per ottenere credenziali temporanee, consulta quanto segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | Sviluppatore di app, tecnico addetto alla migrazione | | Inizializza i client DynamoDB per l'accesso a DynamoDB di origine e destinazione. | Inizializza i client DynamoDB, forniti dall'SDK AWS, per le tabelle DynamoDB di origine e di destinazione.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Per ulteriori informazioni su come effettuare richieste utilizzando credenziali temporanee IAM, consulta la [documentazione AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | Sviluppatore di app | | Elimina e ricrea la tabella di destinazione. | Elimina e ricrea la tabella DynamoDB di destinazione (insieme agli indici) nell'account di destinazione, utilizzando il client DynamoDB dell'account di destinazione.L'eliminazione di tutti i record da una tabella DynamoDB è un'operazione costosa perché richiede il provisioning. WCUs L'eliminazione e la ricreazione della tabella evitano questi costi aggiuntivi.È possibile aggiungere indici a una tabella dopo averla creata, ma ciò richiede 2-5 minuti in più. La creazione di indici durante la creazione della tabella, passando la raccolta indexes alla chiamata, è più efficiente. `createTable` | Sviluppatore di app | | Eseguite la copia della tabella. | Ripetere i passaggi seguenti fino alla copia di tutti i dati:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)*Per ulteriori informazioni, consulta l'implementazione di riferimento in C\$1 (per eliminare, creare e popolare tabelle) nella sezione Allegati.* È inoltre allegato un file JSON ( JavaScript Object Notation) di configurazione della tabella di esempio. | Sviluppatore di app | ## Risorse correlate + [Documentazione di Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Creazione di un utente IAM nel tuo account AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) + [AWS SDKs](https://aws.amazon.com/tools/) + [Utilizzo di credenziali temporanee con risorse AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) ## Informazioni aggiuntive Questo modello è stato implementato utilizzando C\$1 per copiare una tabella DynamoDB con 200.000 elementi (dimensione media degli elementi di 5 KB e dimensione della tabella di 250 MB). La tabella DynamoDB di destinazione è stata configurata con una capacità assegnata di 4000 e 4000. RCUs WCUs L'operazione completa di copia della tabella (dall'account di origine all'account di destinazione), inclusa l'eliminazione e la ricreazione della tabella, ha richiesto 5 minuti. Capacità totale delle unità consumate: 30.000 RCUs e circa 400.000. WCUs Per ulteriori informazioni sulle modalità di capacità di DynamoDB, [consulta la modalità di capacità di lettura/scrittura nella documentazione AWS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html). ## Allegati [Per accedere a contenuti aggiuntivi associati a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip) # Crea report dettagliati su costi e utilizzo per Amazon RDS e Amazon Aurora *Lakshmanan Lakshmanan e Sudarshan Narasimhan, Amazon Web Services* ## Riepilogo [Questo modello mostra come tenere traccia dei costi di utilizzo per i cluster Amazon Relational Database Service (Amazon RDS) o Amazon Aurora configurando tag di allocazione dei costi definiti dall'utente.](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) Puoi utilizzare questi tag per creare report dettagliati su costi e utilizzo in AWS Cost Explorer per cluster su più dimensioni. Ad esempio, puoi tenere traccia dei costi di utilizzo a livello di team, progetto o centro di costo e quindi analizzare i dati in Amazon Athena. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Una o più [istanze Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) o [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) **Limitazioni** Per le restrizioni relative ai tag, consulta la [AWS Billing User Guide](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html). ## Architecture **Stack tecnologico Target** + Amazon RDS o Amazon Aurora + AWSReport di costi e utilizzo + AWS Cost Explorer + Amazon Athena **Flusso di lavoro e architettura** Il flusso di lavoro di etichettatura e analisi consiste nei seguenti passaggi: 1. Un ingegnere dei dati, un amministratore di database o un amministratore AWS crea tag di allocazione dei costi definiti dall'utente per i cluster Amazon RDS o Aurora. 1. Un amministratore AWS attiva i tag. 1. I tag inviano i metadati ad AWS Cost Explorer. 1. Un ingegnere dei dati, un amministratore di database o un amministratore AWS crea un [rapporto mensile sull'allocazione dei costi](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-viewing). 1. Un ingegnere dei dati, un amministratore di database o un amministratore AWS analizza il report mensile di allocazione dei costi utilizzando Amazon Athena. Il diagramma seguente mostra come applicare i tag per tenere traccia dei costi di utilizzo per le istanze Amazon RDS o Aurora. ![\[Applicazione di tag per tenere traccia dei costi di utilizzo per istanze di database e cluster\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/63292b18-01d6-4523-b8ac-2c3b12b11b84.png) Il seguente diagramma di architettura mostra come il report di allocazione dei costi è integrato con Amazon Athena per l'analisi. ![\[Interrogazione dei report di allocazione dei costi in Athena\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/9c028405-1e93-4f6a-a0e5-36154e2b8eab.png) Il report mensile di allocazione dei costi viene archiviato in un bucket Amazon S3 specificato dall'utente. Quando configuri Athena con il CloudFormation modello AWS, come descritto nella sezione *Epics*, il modello fornisce diverse risorse aggiuntive, tra cui un crawler AWS Glue, un database AWS Glue, un evento Amazon Simple Notification System (Amazon SNS), funzioni AWS Lambda e ruoli AWS Identity and Access Management (IAM) per le funzioni Lambda. Man mano che nuovi file di dati sui costi arrivano nel bucket S3, vengono utilizzate notifiche di eventi per inoltrare questi file a una funzione Lambda per l'elaborazione. La funzione Lambda avvia un crawler job di AWS Glue per creare o aggiornare la tabella nel catalogo dati di AWS Glue. Questa tabella viene quindi utilizzata per interrogare i dati in Athena. ## Tools (Strumenti) + [Amazon Athena](https://aws.amazon.com/athena/) è un servizio di query interattivo che semplifica l'analisi dei dati in Amazon S3 utilizzando SQL standard. + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) è un motore di database relazionale completamente gestito creato per il cloud e compatibile con MySQL e PostgreSQL. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale nel cloud AWS. + [AWS CloudFormation](https://aws.amazon.com/cloudformation/) è un servizio Infrastructure as Code (IaC) che consente di modellare, fornire e gestire facilmente risorse AWS e di terze parti. + [AWS Cost Explorer](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-what-is.html) ti aiuta a visualizzare e analizzare i costi e l'utilizzo di AWS. ## Epiche ### Crea e attiva tag per il tuo cluster Amazon RDS o Aurora | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea tag di allocazione dei costi definiti dall'utente per il tuo cluster Amazon RDS o Aurora. | Per aggiungere tag a un cluster Amazon RDS o Aurora nuovo o esistente, segui le istruzioni [in Aggiungere, elencare e rimuovere tag nella](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html#Tagging.HowTo) Guida per l'utente di *Amazon Aurora*.*Per informazioni su come configurare un cluster Amazon Aurora, consulta le istruzioni per MySQL [e](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.Aurora.html) [PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) nella Guida per l'utente di Amazon Aurora.* | Amministratore AWS, ingegnere dei dati, DBA | | Attiva i tag di allocazione dei costi definiti dall'utente. | Segui le istruzioni in [Attivazione dei tag di allocazione dei costi definiti dall'utente](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activating-tags.html) nella *AWS Billing* User Guide. | Amministratore AWS | ### Crea report su costi e utilizzo | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea e configura report sui costi e sull'utilizzo per i tuoi cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html)I dati saranno disponibili in 24 ore. | Proprietario dell'app, amministratore AWS, DBA, General AWS, ingegnere dei dati | ### Analizza i dati dei report su costi e utilizzo | Operazione | Description | Competenze richieste | | --- | --- | --- | | Analizza i dati del rapporto sui costi e sull'utilizzo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html):role/ --role-session-name --profile
select status from cost_and_usage_data_statusPer ulteriori informazioni, consulta [Esecuzione di query Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) nella *AWS Cost and Usage Reports* User Guide.Quando esegui la query SQL, assicurati che il database corretto sia selezionato dall'elenco a discesa. | Proprietario dell'app, amministratore AWS, DBA, General AWS, ingegnere dei dati | ## Risorse correlate **Riferimenti** + [Configurazione di Athena utilizzando CloudFormation modelli AWS (consigliata](https://docs.aws.amazon.com/cur/latest/userguide/use-athena-cf.html)) + [Configurazione manuale di Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-manual.html) + [Esecuzione di query Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) + [Caricamento dei dati dei report su altre risorse](https://docs.aws.amazon.com/cur/latest/userguide/cur-query-other.html) **Tutorial e video** + [Analizza i report su costi e utilizzo con Amazon Athena (video](https://youtu.be/KEeJEZTYE8E)) YouTube # Distribuisci istanze di cluster di failover di SQL Server su Amazon e EC2 Amazon FSx utilizzando Terraform *Mark Hudson e Matt Burgess, Amazon Web Services* ## Riepilogo Questo modello utilizza Terraform per distribuire istanze di cluster di failover di SQL Server (FCIs) su nodi Windows Server Failover Cluster (WSFC) su Amazon Elastic Compute Cloud (Amazon). EC2 Inoltre, il modello utilizza lo storage FSx condiviso di Amazon per dati e file di registro. Quando si esegue la migrazione dei database SQL Server AWS, la prima scelta è Amazon RDS for SQL Server. Tuttavia, a volte Amazon RDS for SQL Server non è adatto e SQL Server deve essere distribuito su EC2 Amazon in un'architettura ad alta disponibilità. In questa soluzione, SQL Server viene installato su FCIs nodi WSFC. Il modulo Terraform incluso in questo modello fornisce fino a due istanze di Amazon EC2 SQL Server. Un file system Amazon FSx for Windows File Server funge da testimone del quorum e archivia dati e file di registro condivisi. Indipendentemente dal numero di istanze configurate, i nodi di istanze di SQL Server creeranno e si uniranno sempre a un cluster FCI per garantire la parità ambientale. (In genere, un'istanza è configurata per lo sviluppo e due istanze per gli ambienti di produzione). Per le configurazioni che utilizzano due nodi per l'elevata disponibilità, viene fornito un Network Load Balancer interno. Il Network Load Balancer utilizza una sonda di salute configurata sul cluster FCI per identificare quale nodo è il principale. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo. Account AWS + Amazon Virtual Private Cloud (Amazon VPC) con due sottoreti in zone di disponibilità separate. + Set di opzioni [DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) Amazon VPC. Configura il nome di dominio in modo che si risolva nel nome di dominio Active Directory e i server dei nomi di dominio e NetBIOS in modo che puntino ai controller di dominio Active Directory. Per ulteriori informazioni, consulta *Configurazione VPC* in Informazioni [aggiuntive](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD). + Amazon Machine Image (AMI) personalizzata. Per maggiori dettagli, consulta *Configurazione AMI* in [Informazioni aggiuntive](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + Bucket Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) contenente l'immagine ISO di SQL Server. Questo prerequisito è richiesto solo se si utilizza [EC2 Image](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) Builder con il file `component.yaml` fornito per creare l'AMI personalizzata. + AWS Key Management Service (AWS KMS) chiave di crittografia. + Per impostazione predefinita, SQL Server viene installato utilizzando un codice prodotto della Developer Edition. I sistemi di produzione dovrebbero utilizzare un codice prodotto valido passato al modulo dalla variabile pertinente. **Limitazioni** + Questa soluzione richiede AWS Managed Microsoft AD. Tuttavia, se preferisci, puoi invece utilizzare un'implementazione di Active Directory autogestita. A tale scopo, modifica il modulo Amazon FSx Terraform incluso per rimuovere l'`active_directory_id`attributo. Quindi, aggiungi i quattro attributi necessari per l'autogestione di Active Directory, come mostrato nella documentazione di [Terraform](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/fsx_windows_file_system). + SQL Server è configurato per utilizzare l'autenticazione in modalità mista. Se preferisci, puoi utilizzare l'autenticazione solo per Windows. A tale scopo, nello script di dati utente fornito, rimuovete i `/SAPWD` parametri `/SECURITYMODE` and forniti al `setup.exe` comando. È possibile rimuovere il `sql_accounts.tf` file e modificare il `instances.tf` file per rimuovere la `sql_sa_password` voce. + Quando si elimina un cluster distribuito, è necessario rimuovere i corrispondenti oggetti del computer virtuale e i singoli oggetti del computer in Active Directory. Per rimuovere gli oggetti, utilizzare gli strumenti di amministrazione di Active Directory. + Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Endpoints and quotas del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. **Versioni del prodotto** Questa soluzione è stata testata con le seguenti versioni: + Windows Server 2019 + SQL Server 2019 + [Terraform v0.13.0](https://developer.hashicorp.com/terraform/language/v1.1.x/upgrade-guides/0-13) ## Architecture **Stack tecnologico di origine** + SQL Server **Stack tecnologico di destinazione** + SQL Server FCI su nodi WSFC con Amazon EC2 + File server Amazon FSx per Windows + Bucket Amazon S3 + Gestione dei segreti AWS + AWS Managed Microsoft AD + AWS KMS + AWS Identity and Access Management (IAM) **Architettura Target** Il diagramma seguente mostra l'architettura di questa soluzione. ![\[Architettura per distribuire istanze di cluster di failover di SQL Server tra i nodi del cluster di failover di Windows Server su Amazon. EC2\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/45f3ab19-d240-4353-ab6e-f6e565f537a4/images/0bff16f2-94e7-4e86-91ea-7ab5f3725620.png) Il diagramma mostra: + Un ruolo IAM che fornisce alle EC2 istanze l'accesso a AWS KMS Secrets Manager + Due nodi SQL Server distribuiti su EC2 istanze Amazon in sottoreti private su due zone di disponibilità + Un Network Load Balancer per facilitare le connessioni all'istanza attiva di SQL Server (non distribuito durante la configurazione di un cluster a nodo singolo) + File system Amazon FSx per Windows File Server distribuito in entrambe le sottoreti private per lo storage condiviso dai nodi di SQL Server + Secrets Manager per l'archiviazione delle credenziali e della configurazione di Active Directory e SQL Server + Bucket Amazon S3 per l'archiviazione dell'immagine di installazione di SQL Server + AWS Managed Microsoft AD per l'autenticazione di Windows + AWS KMS per creare la chiave di crittografia **Automazione e scalabilità** [È possibile automatizzare l'implementazione dell'architettura di destinazione utilizzando i moduli Terraform presenti nel GitHub repository.](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) È necessario modificare il `terraform.tfvars` file per includere valori variabili specifici del proprio ambiente. Il bucket Amazon S3, AWS Managed Microsoft AD i componenti, la chiave di AWS KMS crittografia e alcuni segreti sono prerequisiti per questa distribuzione e non sono inclusi nel codice Terraform. ## Tools (Strumenti) **Servizi AWS** + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)consente ai carichi di lavoro e alle risorse compatibili con le directory di AWS utilizzare Microsoft Active Directory in. Cloud AWS In questo modello, AWS Managed Microsoft AD viene utilizzato per l'autenticazione di Windows Server e SQL Server e per il DNS. + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornisce capacità di elaborazione scalabile in. Cloud AWS Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente. In questo modello, le istanze del cluster di failover di SQL Server vengono installate sulle istanze Amazon EC2 . + [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) consente di automatizzare la creazione, la gestione e l'implementazione di immagini server personalizzate. + [Amazon FSx for Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) fornisce storage condiviso completamente gestito su Windows Server. In questo modello, FSx per Windows File Server fornisce lo storage condiviso per i dati e i file di registro di SQL Server e il quorum witness. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) consente di gestire in modo sicuro l'accesso alle AWS risorse controllando chi è autenticato e autorizzato a utilizzarle. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati. In questo modello, viene utilizzato per crittografare i segreti di Secrets Manager, lo storage SQL Server sui volumi Amazon Elastic Block Store (Amazon EBS) e il file system FSx per Windows File Server. + Con [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) puoi sostituire le credenziali nel codice,incluse le password, con una chiamata API a Secrets Manager in modo da recuperare il segreto a livello di codice. In questo modello, le credenziali di Active Directory per l'installazione e l'esecuzione di SQL Server, le credenziali `sa` utente e le informazioni di connessione al database vengono archiviate in Secrets Manager. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati. Questo modello utilizza un bucket Amazon S3 per archiviare l'immagine di installazione di SQL Server. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ti aiuta a lanciare AWS risorse in una rete virtuale che hai definito. Questa rete virtuale è simile a una comune rete da gestire all'interno del proprio data center, ma con i vantaggi dell'infrastruttura scalabile di AWS. ******Altri strumenti** + [Microsoft SQL Server FCIs](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/always-on-failover-cluster-instances-sql-server?view=sql-server-ver15) vengono installati nei nodi del cluster di Windows Server. Inoltre, possono essere installati su più sottoreti. In questo modello, le istanze FCI di SQL Server vengono installate tra i nodi WSFC. + [Terraform](https://www.terraform.io/) è uno strumento Infrastructure as Code (IaC) che consente di utilizzare il codice per fornire e gestire l'infrastruttura e le risorse cloud. In questo modello, Terraform viene utilizzato per creare le risorse e configurare le istanze FCI di SQL Server. + [Windows Server Failover Clustering](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/windows-server-failover-clustering-wsfc-with-sql-server?view=sql-server-ver15) offre funzionalità di infrastruttura che supportano l'elevata disponibilità di applicazioni server ospitate come SQL Server. In questo modello, i nodi FCI utilizzano la funzionalità WSFC per fornire un'elevata disponibilità locale attraverso la ridondanza a livello di istanza. **Archivio di codici** Il codice per questo pattern è disponibile nel repository GitHub [cluster-amazon-elastic-compute- cloud-amazon-fsx-microsoft -sql-server](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server). Nel repository sono disponibili le seguenti risorse: + Un `README.md` file che fornisce una panoramica della soluzione e informazioni aggiuntive sull'installazione e l'utilizzo + Un set base di file di configurazione Terraform e un modulo FSx specifico di Amazon per fornire i componenti per questo modello + Uno script di configurazione dell'istanza che viene eseguito come script di dati EC2 utente Amazon + Un file `component.yam` l che Image Builder può utilizzare per creare un'AMI personalizzata ## Best practice **Sicurezza e applicazione di patch** + Le installazioni e le configurazioni dei prerequisiti AMI sono i requisiti minimi per distribuire i cluster FCI di SQL Server. Potrebbero essere necessari software e configurazioni aggiuntivi per conformarsi agli standard e ai requisiti di sicurezza dell'organizzazione. + Dopo la distribuzione, applica patch a Windows su base continuativa. Puoi applicare direttamente le patch alle istanze in esecuzione o creare una nuova AMI con le ultime patch di Windows e sostituire le istanze (una alla volta) utilizzando la nuova AMI. AWS rilascia AMIs ogni mese nuovi Windows contenenti le patch, i driver e gli agenti di lancio più recenti del sistema operativo. Ti consigliamo di verificare la disponibilità dell'AMI più recente quando avvii nuove istanze o quando crei immagini personalizzate. + Le EC2 istanze Amazon sono configurate per consentire tutto il traffico in uscita. Se distribuito in un ambiente di produzione, è necessario stabilire regole in uscita nel gruppo di sicurezza per limitare questo traffico alle destinazioni richieste. + Il file system FSx per Windows File Server può registrare automaticamente i registri di controllo per la condivisione di file e l'accesso a file e cartelle e inviarli alla destinazione desiderata, se questo è un requisito dell'ambiente. + Ruota i segreti di Secrets Manager automaticamente a intervalli regolari. Per la coppia di chiavi di EC2 istanze Amazon, prendi in considerazione una soluzione di rotazione automatizzata come descritto in [Come usare AWS Secrets Manager per archiviare e ruotare in modo sicuro le coppie di chiavi SSH](https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-securely-store-rotate-ssh-key-pairs/). Per le credenziali di Active Directory e le `sa` credenziali segrete di SQL Server, configura la rotazione automatica in base alle tue politiche di gestione delle password. **Gestione di Active Directory** + Come parte del cluster FCI, Windows genera un Computer Name Object (CNO) in Active Directory. Il CNO risponde alle richieste DNS e inoltra il traffico al nodo SQL attivo. *Non* è consigliabile utilizzare questo DNS fornito da Active Directory. Il TTL è troppo alto per consentire un tempo di failover ragionevole e spesso impiega fino a 5 minuti per riflettere il nuovo indirizzo IP primario. Al contrario, per le installazioni ad alta disponibilità, il Network Load Balancer interno è configurato per il failover entro 30 secondi. + Per creare il cluster è necessario un amministratore di dominio Active Directory. Questo requisito è dovuto alle autorizzazioni elevate richieste per creare gli oggetti del cluster e modificare le autorizzazioni in Active Directory. Tuttavia, i servizi SQL Server non devono essere eseguiti come amministratore di dominio. Pertanto, si consiglia di creare un secondo utente Active Directory per questo scopo. Tuttavia, è possibile eliminare questo utente se i servizi verranno eseguiti come utente amministratore di dominio. In tal caso, l'utente amministratore di dominio deve essere aggiunto al gruppo di amministratori di Active Directory creato come parte di questo modello. ## Epiche ### Configura le credenziali del cluster | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare gruppi Active Directory. | In AWS Managed Microsoft AD, crea i seguenti gruppi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Per maggiori dettagli, consulta [Creazione di un AWS Managed Microsoft AD gruppo](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_create_group.html) nella AWS documentazione. | Amministratore AD | | Crea utenti Active Directory. | In AWS Managed Microsoft AD, crea i seguenti utenti[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Per maggiori dettagli, consulta [Creazione di un AWS Managed Microsoft AD utente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html) nella AWS documentazione. | Amministratore AD | | Aggiungi le credenziali di Active Directory ai segreti. | Usa Secrets Manager per creare quattro segreti per archiviare le seguenti informazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Per maggiori dettagli, consulta [Creare un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) nella AWS documentazione. | Amministratore AWS | ### Prepara l'ambiente | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea l'AMI di Windows. | Crea un'AMI Windows personalizzata che includa il software e le configurazioni prerequisiti. Per ulteriori dettagli, vedere Informazioni [aggiuntive](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). | Amministratore AWS, AWS DevOps | | Installa Terraform. | Per installare Terraform, segui le istruzioni sul sito Web [Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli). | AWS DevOps | | Clonare il repository. | Clona il [repository](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) di questo pattern. Per maggiori dettagli, consulta [Clonazione di un repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) sul sito web. GitHub | AWS DevOps | ### Installa il cluster | Operazione | Description | Competenze richieste | | --- | --- | --- | | Modifica le variabili Terraform. | Aggiorna il `terraform.tfvars` file fornito per impostare tutte le variabili sui valori appropriati per il tuo ambiente.Ad esempio, aggiorna le `domain_group_rdp_users` variabili `domain_group_administrators` and per utilizzare il nome di dominio Active Directory e il nome dei gruppi Active Directory creati in precedenza. | AWS DevOps | | Inizializza Terraform. | Per vedere la distribuzione proposta, vai alla radice del repository. Usa l'interfaccia a riga di comando (CLI) Terraform per `terraform init` eseguire e poi eseguire. `terraform plan` | AWS DevOps | | Distribuisci risorse. | Per distribuire il cluster SQL e le risorse associate, utilizza la CLI Terraform per l'esecuzione. `terraform apply` | AWS DevOps, amministratore AWS | | Convalida la distribuzione. | Per convalidare la distribuzione, attenersi alla seguente procedura:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | Amministratore di sistema DBA, AWS | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Il provisioning di Terraform è stato completato ma Windows Failover Cluster Manager non mostra che è stato creato un cluster o che il cluster è in uno stato non utilizzabile. | L'intera installazione delle risorse e la configurazione dei cluster possono richiedere 45-60 minuti. Una volta completato Terraform, lo script dei dati utente deve essere eseguito fino al completamento, il che richiede più riavvii. Per monitorare l'avanzamento, è possibile utilizzare la `Checkpoints` directory nell'`C:\`unità e accedere all'installazione di SQL Server. `C:\Program Data\Microsoft SQL Server\150\Log` Al termine, il messaggio **Installazione completata** è disponibile nel `C:\ProgramData\Amazon\EC2-Windows\Launch\Log\UserdataExecution.log` file. | | Dopo aver effettuato il provisioning di un cluster funzionante, l'utilizzo di Terraform per eliminare e ricreare il cluster non ha esito positivo. Terraform viene completato, ma il cluster non è configurato correttamente. | Parte del processo di provisioning prevede la registrazione di macchine e oggetti virtuali su Active Directory e Active Directory DNS. Se esistono nomi di computer per i nodi del EC2 cluster Amazon e il nodo del cluster, FCI non può inizializzarsi correttamente e il provisioning fallirà.Per risolvere questo problema, procedi nel seguente modo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | ## Risorse correlate **AWS documentazione** + [Crea immagini personalizzate con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-images.html) + [Crea una chiave KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) + [Creazione di un bucket generico](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [Creazione di una politica chiave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) + [Creando il tuo AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) ## Informazioni aggiuntive **Informazioni sul modulo Terraform** Questo modulo utilizza una combinazione di configurazione AMI e configurazione dei dati utente per ottenere un buon mix di tempi di provisioning e stabilità. Durante il provisioning, Windows richiede più riavvii e attese. È stato implementato un metodo di controllo per proteggere dai loop infiniti durante il riavvio dei dati utente persistenti. I dati utente sono configurati per essere persistenti. Pertanto, gli script di configurazione dei dati utente devono e devono continuare a essere sviluppati per essere idempotenti. Idempotency semplifica il processo di aggiornamento, consentendo la sostituzione delle istanze durante un ciclo di aggiornamento senza la configurazione manuale per ricongiungersi o ricreare i cluster FCI. **Stringhe di connessione e clustering di failover di SQL Server** Il modulo pubblicherà un segreto contenente l'indirizzo dell'endpoint da utilizzare nelle stringhe di connessione per questo database. Il nome segreto segue il formato. `{environment_name}/sqlserver/{cluster_name}/endpoint` Per le installazioni in cui viene utilizzato un solo nodo, puoi aspettarti che questo sia l'indirizzo IP dell'interfaccia SQL Server dell' EC2 istanza Amazon. Per le installazioni ad alta disponibilità (due istanze), puoi aspettarti che questo sia il nome DNS del Network Load Balancer interno. Il clustering virtuale di failover IPs non è supportato in questo modulo. Un IP virtuale deve rimanere nella stessa sottorete per funzionare. Nel AWS, una singola sottorete non può estendersi su più zone di disponibilità. Pertanto, l'uso del virtuale IPs eliminerebbe la possibilità per questo modulo di essere considerato altamente disponibile. A ogni EC2 istanza Amazon vengono assegnati tre indirizzi IP privati. Il loro utilizzo è il seguente: + **IP primario per il traffico di rete**: l'IP di origine per il traffico in uscita. + **Comunicazioni FCI**: utilizzate per mantenere lo stato e la sincronizzazione del cluster di failover. + **SQL Server (porta TCP 1433)**: ascolta e ascolta anche il traffico heartbeat per determinare quale istanza è principale. **Configurazione VPC** I [prerequisiti](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-prereqs) elencano un set di opzioni DHCP configurato per utilizzare Active Directory per la risoluzione DNS. Tuttavia, questo prerequisito non è un requisito rigido. Il requisito fondamentale è che le EC2 istanze devono essere in grado di risolvere il nome di dominio Active Directory. È possibile soddisfare questo requisito in altri modi, ad esempio utilizzando Amazon Route 53 Resolver gli endpoint. Per ulteriori informazioni, consulta [Integrazione della risoluzione DNS del servizio di directory con Amazon Route 53 Resolvers](https://aws.amazon.com/blogs/networking-and-content-delivery/integrating-your-directory-services-dns-resolution-with-amazon-route-53-resolvers/) (post di blog).AWS **Configurazione AMI** L'AMI utilizzata in questo modello deve contenere il software e le configurazioni prerequisiti seguenti: 1. Scarica ed espandi i file di installazione di SQL Server 2019 in. `C:\SQL_Install_media` 1. Installa le seguenti funzionalità di Windows: + `Install-WindowsFeature Failover-Clustering` + `Install-WindowsFeature RSAT-AD-PowerShell` + `Install-WindowsFeature RSAT-AD-Tools` + `Install-WindowsFeature RSAT-Clustering-Mgmt` + `Install-WindowsFeature RSAT-Clustering-PowerShell` + `Install-WindowsFeature RSAT-Clustering-CmdInterface` 1. Disattiva il firewall di Windows come segue: + `Get-NetFirewallProfile | Set-NetFirewallProfile -Enabled False` 1. Abilita il metodo di autenticazione CredSSP (`
DECLARE| DBA | | Esegui il PL/SQL blocco. | Esegui il PL/SQL blocco sorgente in Oracle. Se ci sono degli spazi tra i valori di indice di un array associativo, in tali spazi non viene memorizzato alcun dato. Ciò consente al ciclo Oracle di scorrere solo attraverso le posizioni dell'indice. | DBA | | Esamina l'output. | Cinque elementi sono stati inseriti nell'array (`cc`) a intervalli non consecutivi. Il conteggio degli array è mostrato nel seguente output:
TYPE country_codes IS TABLE OF VARCHAR2(100) INDEX BY pls_integer;
cc country_codes;
cc_idx NUMBER := NULL;
BEGIN
cc(7) := 'India';
cc(3) := 'UK';
cc(5) := 'USA';
cc(0) := 'China';
cc(-2) := 'Invalid';
dbms_output.put_line('cc_length:' || cc.COUNT);
IF (cc.COUNT > 0) THEN
cc_idx := cc.FIRST;
FOR i IN 1..cc.COUNT LOOP
dbms_output.put_line('cc_idx:' || cc_idx || ' country:' || cc(cc_idx));
cc_idx := cc.next(cc_idx);
END LOOP;
END IF;
END;
cc_length:5| DBA | ### Comportamento dell'array associativo PostgreSQL (target) | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un PL/pgSQL blocco di destinazione in PostgreSQL. | Crea un PL/pgSQL blocco di destinazione in PostgreSQL che utilizza il seguente array associativo:
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
DO $$| DBA | | Esegui il PL/pgSQL blocco. | Esegui il PL/pgSQL blocco di destinazione in PostgreSQL. Se ci sono degli spazi tra i valori dell'indice di un array associativo, nessun dato viene memorizzato in tali spazi. Ciò consente al ciclo Oracle di scorrere solo attraverso le posizioni dell'indice. | DBA | | Esamina l'output. | La lunghezza dell'array è maggiore di 5 perché `NULL` è memorizzata negli spazi tra le posizioni dell'indice. Come mostrato nell'output seguente, il ciclo completa 10 iterazioni per recuperare 5 valori nell'array.
DECLARE
cc character varying(100)[];
cc_idx integer := NULL;
BEGIN
cc[7] := 'India';
cc[3] := 'UK';
cc[5] := 'USA';
cc[0] := 'China';
cc[-2] := 'Invalid';
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN ARRAY_LOWER(cc, 1)..ARRAY_UPPER(cc, 1)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i, cc[i];
END LOOP;
END IF;
END;
$$;
cc_length:10| DBA | ### Emula il comportamento degli array associativi Oracle | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un PL/pgSQL blocco di destinazione con un array e un tipo definito dall'utente. | Per ottimizzare le prestazioni e soddisfare le funzionalità di Oracle, possiamo creare un tipo definito dall'utente che memorizza sia le posizioni dell'indice che i dati corrispondenti. Questo approccio riduce le iterazioni non necessarie mantenendo associazioni dirette tra indici e valori.
cc_idx:-2 country:Invalid
cc_idx:-1 country:
cc_idx:0 country:China
cc_idx:1 country:
cc_idx:2 country:
cc_idx:3 country:UK
cc_idx:4 country:
cc_idx:5 country:USA
cc_idx:6 country:
cc_idx:7 country:India
DO $$| DBA | | Esegui il PL/pgSQL blocco. | Esegui il PL/pgSQL blocco bersaglio. Se ci sono degli spazi tra i valori dell'indice di un array associativo, in tali spazi non viene memorizzato alcun dato. Ciò consente al ciclo Oracle di scorrere solo attraverso le posizioni dell'indice. | DBA | | Esamina l'output. | Come illustrato nell'output seguente, il tipo definito dall'utente memorizza solo gli elementi di dati popolati, il che significa che la lunghezza dell'array corrisponde al numero di valori. Di conseguenza, `LOOP` le iterazioni sono ottimizzate per elaborare solo i dati esistenti, eliminando la necessità di tenere traccia delle posizioni vuote.
DECLARE
cc country_codes[];
cc_append country_codes := NULL;
i record;
BEGIN
cc_append.idx = 7;
cc_append.val = 'India';
cc := array_append(cc, cc_append);
cc_append.idx = 3;
cc_append.val = 'UK';
cc := array_append(cc, cc_append);
cc_append.idx = 5;
cc_append.val = 'USA';
cc := array_append(cc, cc_append);
cc_append.idx = 0;
cc_append.val = 'China';
cc := array_append(cc, cc_append);
cc_append.idx = - 2;
cc_append.val = 'Invalid';
cc := array_append(cc, cc_append);
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN (
SELECT
*
FROM
unnest(cc)
ORDER BY
idx)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i.idx, i.val;
END LOOP;
END IF;
END;
$$;
cc_length:5| DBA | ## Risorse correlate **AWS documentazione** + [AWS database, blog](https://aws.amazon.com/blogs/database/) + [Guida alla migrazione da Oracle ad Aurora da PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) **Altra documentazione** + [Array associativi Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/23/lnpls/associative-arrays.html#GUID-8060F01F-B53B-48D4-9239-7EA8461C2170) + [Funzioni e operatori dell'array PostgreSQL](https://www.postgresql.org/docs/current/functions-array.html) + [Tipi PostgreSQL definiti dall'utente](https://www.postgresql.org/docs/current/sql-createtype.html) # Abilita connessioni crittografate per le istanze DB PostgreSQL in Amazon RDS *Rohit Kapoor, Amazon Web Services* ## Riepilogo Amazon Relational Database Service (Amazon RDS) supporta la crittografia SSL per le istanze DB PostgreSQL. Utilizzando SSL, puoi crittografare una connessione PostgreSQL tra le tue applicazioni e le istanze DB di Amazon RDS for PostgreSQL. Per impostazione predefinita, Amazon RDS SSL/TLS for PostgreSQL utilizza e prevede che tutti i client si connettano utilizzando la crittografia. SSL/TLS Amazon RDS per PostgreSQL supporta le versioni TLS 1.1 e 1.2. Questo modello descrive come abilitare le connessioni crittografate per un'istanza DB Amazon RDS for PostgreSQL. Puoi utilizzare lo stesso processo per abilitare le connessioni crittografate per Amazon Aurora PostgreSQL Compatible Edition. ## Prerequisiti e limitazioni + Un account AWS attivo + Un'[istanza DB Amazon RDS per PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_RDS_Configuring.html) + [Un](https://www.postgresql.org/docs/current/ssl-tcp.html) pacchetto SSL ## Architecture ![\[Abilitazione di connessioni crittografate per istanze DB PostgreSQL in Amazon RDS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/4f87c6a3-b4ff-4248-96d3-a4a498659735/images/ccc5c880-1191-4c12-a255-6908b96b96a5.png) ## Tools (Strumenti) + [pgAdmin](https://www.pgadmin.org/) è una piattaforma di amministrazione e sviluppo open source per PostgreSQL. Puoi usare pgAdmin su Linux, Unix, macOS e Windows per gestire gli oggetti del database in PostgreSQL 10 e versioni successive. + Gli editor di [PostgreSQL](https://wiki.postgresql.org/wiki/PostgreSQL_Clients) forniscono un'interfaccia più intuitiva per aiutarti a creare, sviluppare ed eseguire query e modificare il codice in base alle tue esigenze. ## Best practice + Monitora le connessioni non sicure al database. + Verifica i diritti di accesso al database. + Assicurati che i backup e le istantanee siano crittografati quando sono inattivi. + Monitora l'accesso al database. + Evita i gruppi di accesso senza restrizioni. + Migliora le tue notifiche con [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html). + Monitora regolarmente l'aderenza alle politiche. ## Epiche ### Scarica un certificato affidabile e importalo nel tuo negozio di fiducia | Operazione | Description | Competenze richieste | | --- | --- | --- | | Carica un certificato affidabile sul tuo computer. | Per aggiungere certificati all'archivio Trusted Root Certification Authorities del computer, procedi nel seguente modo. (Queste istruzioni utilizzano Windows Server come esempio.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingegnere, ingegnere addetto alla migrazione, DBA | ### Forza le connessioni SSL | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare un gruppo di parametri e impostare il parametro rds.force\$1ssl. | Se l'istanza DB PostgreSQL ha un gruppo di parametri personalizzato, modifica il gruppo di parametri e passa a 1. `rds.force_ssl`Se l'istanza DB utilizza il gruppo di parametri predefinito che non è `rds.force_ssl` abilitato, crea un nuovo gruppo di parametri. Puoi modificare il nuovo gruppo di parametri utilizzando l'API Amazon RDS o manualmente come indicato nelle seguenti istruzioni.Per creare un nuovo gruppo di parametri:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Per associare il gruppo di parametri alla tua istanza DB PostgreSQL:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Per ulteriori informazioni, consulta la [documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithDBInstanceParamGroups.html). | DevOps ingegnere, ingegnere addetto alla migrazione, DBA | | Forza le connessioni SSL. | Connettiti all'istanza DB Amazon RDS for PostgreSQL. I tentativi di connessione che non utilizzano SSL vengono rifiutati con un messaggio di errore. Per ulteriori informazioni, consulta la [documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Requiring). | DevOps ingegnere, ingegnere addetto alla migrazione, DBA | ### Installa l'estensione SSL | Operazione | Description | Competenze richieste | | --- | --- | --- | | Installa l'estensione SSL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Per ulteriori informazioni, consulta la [documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html). | DevOps ingegnere, ingegnere addetto alla migrazione, DBA | ### Configura il tuo client PostgreSQL per SSL | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura un client per SSL. | Utilizzando SSL, è possibile avviare il server PostgreSQL con il supporto per connessioni crittografate che utilizzano i protocolli TLS. Il server ascolta le connessioni standard e SSL sulla stessa porta TCP e negozia con qualsiasi client connesso se utilizzare SSL. Per impostazione predefinita, questa è un'opzione client.Se stai usando il client psql:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Per altri client PostgreSQL:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Consulta le seguenti pagine per questi client:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingegnere, ingegnere addetto alla migrazione, DBA | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Impossibile scaricare il certificato SSL. | Verifica la connessione al sito Web e riprova a scaricare il certificato sul computer locale. | ## Risorse correlate + [Documentazione Amazon RDS per PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) + [Utilizzo di SSL con un'istanza DB PostgreSQL (documentazione Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html)) + [ TCP/IP Connessioni sicure con SSL](https://www.postgresql.org/docs/9.1/ssl-tcp.html) (documentazione PostgreSQL) + [Utilizzo di SSL](https://jdbc.postgresql.org/documentation/ssl/) (documentazione JDBC) # Crittografa un'istanza database Amazon RDS for PostgreSQL esistente *Piyush Goyal, Shobana Raghu e Yaser Raja, Amazon Web Services* ## Riepilogo Questo modello spiega come crittografare un'istanza database Amazon Relational Database Service (Amazon RDS) per PostgreSQL esistente nel cloud AWS con tempi di inattività minimi. Questo processo funziona anche per le istanze DB di Amazon RDS for MySQL. Puoi abilitare la crittografia per un'istanza DB Amazon RDS al momento della creazione, ma non dopo la creazione. Tuttavia, puoi aggiungere la crittografia a un'istanza DB non crittografata creando uno snapshot dell'istanza DB e quindi creando una copia crittografata di tale istantanea. È quindi possibile ripristinare un'istanza DB dallo snapshot crittografato per ottenere una copia crittografata dell'istanza DB originale. Se il progetto prevede tempi di inattività (almeno per le transazioni di scrittura) durante questa attività, questo è tutto ciò che devi fare. Quando la nuova copia crittografata dell'istanza DB diventa disponibile, puoi indirizzare le applicazioni verso il nuovo database. Tuttavia, se il progetto non prevede tempi di inattività significativi per questa attività, è necessario un approccio alternativo che consenta di ridurre al minimo i tempi di inattività. Questo modello utilizza AWS Database Migration Service (AWS DMS) per migrare e replicare continuamente i dati in modo che il passaggio al nuovo database crittografato possa essere eseguito con tempi di inattività minimi. Le istanze DB crittografate di Amazon RDS utilizzano l'algoritmo di crittografia AES-256 standard del settore per crittografare i dati sul server che ospita le istanze database di Amazon RDS. Dopo la crittografia dei dati, Amazon RDS gestisce l'autenticazione dell'accesso e la decrittografia dei dati in modo trasparente, con un impatto minimo sulle prestazioni. Non è quindi necessario modificare le applicazioni client di database per utilizzare la crittografia. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un'istanza database Amazon RDS for PostgreSQL non crittografata + Esperienza nell'utilizzo (creazione, modifica o interruzione) di attività AWS DMS (consulta Lavorare [con le attività di AWS DMS nella documentazione di AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html)) + Familiarità con AWS Key Management Service (AWS KMS) per la crittografia dei database (consulta la documentazione di AWS [KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)) **Limitazioni** + Puoi abilitare la crittografia per un'istanza DB Amazon RDS solo al momento della creazione, non dopo la creazione dell'istanza DB. + I dati nelle [tabelle non registrate](https://www.postgresql.org/docs/current/sql-createtable.html) non verranno ripristinati utilizzando istantanee. Per ulteriori informazioni, consulta [Best practice for working with PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html#CHAP_BestPractices.PostgreSQL). + Non è possibile creare una replica di lettura crittografata di un'istanza database non crittografata o una replica di lettura non crittografata di un'istanza database crittografata. + Non puoi ripristinare un backup o uno snapshot non crittografato in un'istanza database crittografata. + AWS DMS non trasferisce automaticamente le sequenze, pertanto sono necessari passaggi aggiuntivi per gestirlo. Per ulteriori informazioni, consulta [Limitazioni delle istanze DB crittografate di Amazon RDS nella documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html#Overview.Encryption.Limitations) di Amazon RDS. ## Architecture **Architettura di origine** + Istanza DB RDS non crittografata **Architettura Target** + Istanza DB RDS crittografata + L'istanza DB RDS di destinazione viene creata ripristinando la copia istantanea DB dell'istanza DB RDS di origine. + Una chiave AWS KMS viene utilizzata per la crittografia durante il ripristino dello snapshot. + Un'attività di replica AWS DMS viene utilizzata per migrare i dati. ![\[Process utilizza AWS DMS per crittografare un'istanza database Amazon RDS for PostgreSQL esistente in un nuovo DB.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/44dd8420-d89d-466e-b7fb-1bdafab8f7f9.png) ## Tools (Strumenti) **Strumenti utilizzati per abilitare la crittografia:** + Chiave AWS KMS per la crittografia: quando crei un'istanza DB crittografata, puoi scegliere una chiave gestita dal cliente o la chiave gestita AWS per Amazon RDS per crittografare la tua istanza DB. Se non specifichi l'identificatore di chiave per una chiave gestita dal cliente, Amazon RDS utilizza la chiave gestita AWS per la tua nuova istanza DB. Amazon RDS crea una chiave gestita AWS per Amazon RDS per il tuo account AWS. Il tuo account AWS ha una chiave gestita AWS diversa per Amazon RDS per ogni regione AWS. Per ulteriori informazioni sull'uso delle chiavi KMS per la crittografia Amazon RDS, consulta [Encrypting Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html) RDS Resources. **Strumenti utilizzati per** la replica continua: + AWS DMS: puoi utilizzare AWS Database Migration Service (AWS DMS) per replicare le modifiche dal DB di origine al DB di destinazione. È importante mantenere sincronizzati il DB di origine e quello di destinazione per ridurre al minimo i tempi di inattività. Per informazioni sulla configurazione di AWS DMS e sulla creazione di attività, consulta la documentazione di [AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html). ## Epiche ### Crea un'istantanea dell'istanza DB di origine e crittografala | Operazione | Description | Competenze richieste | | --- | --- | --- | | Controlla i dettagli dell'istanza database PostgreSQL di origine. | Sulla console Amazon RDS, scegli l'istanza database PostgreSQL di origine. Nella scheda **Configurazione**, assicurati che la crittografia non sia abilitata per l'istanza. Per un'illustrazione dello schermo, consulta la sezione [Informazioni aggiuntive](#encrypt-an-existing-amazon-rds-for-postgresql-db-instance-additional). | DBA | | Crea l'istantanea del DB. | Crea uno snapshot DB dell'istanza che desideri crittografare. Il tempo necessario per creare uno snapshot dipende dalla dimensione del database. Per istruzioni, consulta [Creazione di uno snapshot DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) nella documentazione di Amazon RDS. | DBA | | Crittografa l'istantanea. | Nel pannello di navigazione della console Amazon RDS, scegli **Snapshot** e seleziona lo snapshot DB che hai creato. In **Actions (Operazioni)**, selezionare **Copy Snapshot (Copia snapshot)**. Fornisci la regione AWS di destinazione e il nome della copia dello snapshot del DB nei campi corrispondenti. Seleziona la casella di controllo **Abilita crittografia**. Per **Master Key (Chiave master)**, specifica l'identificatore di chiave KMS da utilizzare per crittografare la copia di snapshot DB. Seleziona **Copy Snapshot (Copia snapshot)**. Per ulteriori informazioni, consulta [Copiare uno snapshot nella documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) di Amazon RDS. | DBA | ### Preparare l'istanza DB di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Ripristina l'istantanea del DB. | Sulla console Amazon RDS, scegli **Snapshots**. Scegli lo snapshot crittografato che hai creato. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**. Per **DB Instance Identifier**, fornisci un nome univoco per la nuova istanza DB. Esamina i dettagli dell'istanza, quindi scegli **Ripristina istanza DB**. Una nuova istanza DB crittografata verrà creata dalla tua istantanea. Per ulteriori informazioni, consulta [Ripristino da uno snapshot DB nella documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) di Amazon RDS. | DBA | | Migra i dati utilizzando AWS DMS. | Sulla console AWS DMS, crea un'attività AWS DMS. Per il **tipo di migrazione**, scegli **Migra i dati esistenti e replica** le modifiche in corso. **In **Impostazioni attività**, per la **modalità di preparazione della tabella di Target**, scegli Tronca.** Per ulteriori informazioni, consulta [Creazione di un'attività](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) nella documentazione di AWS DMS. | DBA | | Abilita la convalida dei dati. | In **Impostazioni attività**, scegli **Abilita convalida.** Ciò consente di confrontare i dati di origine con i dati di destinazione per verificare che i dati siano stati migrati correttamente. | DBA | | Disabilita i vincoli sull'istanza DB di destinazione. | [Disabilita eventuali trigger e vincoli di chiave esterna](https://www.postgresql.org/docs/current/sql-altertable.html) sull'istanza DB di destinazione, quindi avvia l'attività AWS DMS. [Per ulteriori informazioni sulla disabilitazione dei trigger e dei vincoli di chiave esterna, consulta la documentazione di AWS DMS.](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.PostgreSQL.html) | DBA | | Verifica i dati. | Al termine del caricamento completo, verifica i dati sull'istanza DB di destinazione per vedere se corrispondono ai dati di origine. Per ulteriori informazioni, consulta la [convalida dei dati di AWS DMS nella documentazione](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Validating.html) di AWS DMS. | DBA | ### Passa all'istanza DB di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi le operazioni di scrittura sull'istanza DB di origine. | Interrompi le operazioni di scrittura sull'istanza DB di origine in modo che possa iniziare il downtime dell'applicazione. Verifica che AWS DMS abbia completato la replica dei dati nella pipeline. Abilita i trigger e le chiavi esterne sull'istanza DB di destinazione. | DBA | | Aggiorna le sequenze del database | Se il database di origine contiene numeri di sequenza, verificate e aggiornate le sequenze nel database di destinazione. | DBA | | Configura l'endpoint dell'applicazione. | Configura le connessioni delle applicazioni per utilizzare i nuovi endpoint di istanze database Amazon RDS. L'istanza DB è ora crittografata. | DBA, proprietario dell'applicazione | ## Risorse correlate + [Creazione di un task AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) + [Monitoraggio delle attività di replica tramite Amazon CloudWatch](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html#CHAP_Monitoring.CloudWatch) + [Monitoraggio delle attività di AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html) + [Aggiornamento della chiave di crittografia Amazon RDS](https://aws.amazon.com/premiumsupport/knowledge-center/update-encryption-key-rds/) ## Informazioni aggiuntive Verifica della crittografia per l'istanza database PostgreSQL di origine: ![\[La pagina di riepilogo dell'istanza database PostgreSQL di origine mostra la crittografia non abilitata per l'archiviazione.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/d53d1dab-b5c2-452d-b823-ba3d6508ad15.png) Note aggiuntive per questo modello: + Abilita la replica su PostgreSQL impostando il parametro su 1. `rds.logical_replication` **Nota importante:** gli slot di replica conservano i file WAL (Write Ahead Log) fino a quando i file non vengono consumati esternamente, ad esempio da `pg_recvlogical` processi di estrazione, trasformazione e caricamento (ETL) o da AWS DMS. Quando imposti il valore del `rds.logical_replication` parametro su 1, AWS DMS imposta i `max_connections` parametri `wal_level``max_wal_senders`,`max_replication_slots`, e. Se sono presenti slot di replica logici ma non esiste alcun utente per i file WAL conservati dallo slot di replica, è possibile che si verifichi un aumento dell'utilizzo del disco del registro delle transazioni e una diminuzione costante dello spazio di archiviazione libero. Per ulteriori informazioni e passaggi per risolvere questo problema, consulta l'articolo [Come posso identificare la causa dell'errore «Nessuno spazio rimasto sul dispositivo» o "DiskFull" su Amazon RDS for](https://aws.amazon.com/premiumsupport/knowledge-center/diskfull-error-rds-postgresql/) PostgreSQL? nel Knowledge Center di AWS Support. + Qualsiasi modifica allo schema apportata all'istanza DB di origine dopo aver creato lo snapshot DB non sarà presente nell'istanza DB di destinazione. + Dopo aver creato un'istanza DB crittografata, non è possibile modificare la chiave KMS utilizzata da quell'istanza DB. Assicurati di determinare i requisiti della chiave KMS prima di creare l'istanza DB crittografata. + È necessario disabilitare i trigger e le chiavi esterne sull'istanza DB di destinazione prima di eseguire l'attività AWS DMS. Puoi riattivarli quando l'attività è completa. # Applica il tagging automatico dei database Amazon RDS al momento del lancio *Susanne Kangnoh e Archit Mathur, Amazon Web Services* ## Riepilogo Amazon Relational Database Service (Amazon RDS) è un servizio Web che semplifica la configurazione, il funzionamento e la scalabilità di un database relazionale nel cloud Amazon Web Services (AWS). Offre una capacità ridimensionabile a un costo conveniente per un database relazionale standard del settore e gestisce task comuni di amministrazione del database. Puoi utilizzare i tag per classificare le tue risorse AWS in diversi modi. L'etichettatura dei database relazionali è utile quando hai molte risorse nel tuo account e desideri identificare rapidamente una risorsa specifica in base ai tag. Puoi utilizzare i tag Amazon RDS per aggiungere metadati personalizzati alle tue istanze DB RDS. Un tag è costituito da una chiave e un valore definiti dall'utente. Ti consigliamo di creare un set coerente di tag per soddisfare i requisiti della tua organizzazione. Questo modello fornisce un CloudFormation modello AWS per aiutarti a monitorare e contrassegnare le istanze DB RDS. Il modello crea un evento Amazon CloudWatch Events che controlla l'DBInstanceevento AWS CloudTrail **Create**. (CloudTrail acquisisce le chiamate API per Amazon RDS come eventi.) Quando rileva questo evento, chiama una funzione AWS Lambda che applica automaticamente le chiavi e i valori dei tag definiti dall'utente. Il modello invia anche una notifica che indica che l'istanza è stata etichettata, utilizzando Amazon Simple Notification Service (Amazon SNS). ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo. + Un bucket Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) per caricare il codice Lambda. + Un indirizzo e-mail a cui desideri ricevere notifiche di tagging. **Limitazioni** + La soluzione supporta CloudTrail **Create DBInstance** events. Non crea notifiche per altri eventi. ## Architecture **Architettura del workflow** ![\[Workflow diagram showing Servizi AWS interaction for RDS instance creation and notification.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/images/ec0bcf92-f986-4af3-bfe7-d2c5e04051c5.png) **Automazione e scalabilità** + Puoi utilizzare il CloudFormation modello AWS più volte per diverse regioni e account AWS. Devi eseguire il modello solo una volta in ogni regione o account. ## Tools (Strumenti) **Servizi AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html): AWS CloudTrail è un servizio AWS che ti aiuta con la governance, la conformità e il controllo operativo e del rischio del tuo account AWS. Le azioni intraprese da un utente, un ruolo o un servizio AWS vengono registrate come eventi in CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html): Amazon CloudWatch Events offre un flusso quasi in tempo reale di eventi di sistema che descrivono i cambiamenti nelle risorse AWS. CloudWatch Events viene a conoscenza dei cambiamenti operativi man mano che si verificano e intraprende le azioni correttive necessarie, inviando messaggi per rispondere all'ambiente, attivando funzioni, apportando modifiche e acquisendo informazioni sullo stato. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda è un servizio di elaborazione che supporta l'esecuzione di codice senza la necessità di fornire o gestire server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. Verrà addebitato soltanto il tempo di calcolo consumato e non verrà addebitato alcun costo quando il codice non è in esecuzione. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) — Amazon Simple Storage Service (Amazon S3) è un servizio di storage di oggetti altamente scalabile che può essere utilizzato per un'ampia gamma di soluzioni di storage, tra cui siti Web, applicazioni mobili, backup e data lake. + [Amazon SNS — Amazon Simple](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) Notification Service (Amazon SNS) è un servizio Web che consente ad applicazioni, utenti finali e dispositivi di inviare e ricevere istantaneamente notifiche dal cloud. **Codice** Questo modello include un allegato con due file: + `index.zip`è un file compresso che include il codice Lambda per questo modello. + `rds.yaml`è un CloudFormation modello che distribuisce il codice Lambda. Consulta la sezione *Epics* per informazioni su come usare questi file. ## Epiche ### Implementa il codice Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Carica il codice in un bucket S3. | Crea un nuovo bucket S3 o usa un bucket S3 esistente per caricare il file allegato `index.zip` (codice Lambda). Questo bucket deve trovarsi nella stessa regione AWS delle risorse (istanze DB RDS) che desideri monitorare. | Architetto del cloud | | Implementa il CloudFormation modello. | Apri la console Cloudformation nella stessa regione AWS del bucket S3 e distribuisci il `rds.yaml` file fornito nell'allegato. Nella prossima epopea, fornisci i valori per i parametri del modello. | Architetto del cloud | ### Completa i parametri nel CloudFormation modello | Operazione | Description | Competenze richieste | | --- | --- | --- | | Fornisci il nome del bucket S3. | Inserisci il nome del bucket S3 che hai creato o selezionato nella prima epic. Questo bucket S3 contiene il file.zip per il codice Lambda e deve trovarsi nella stessa regione AWS del CloudFormation modello e delle istanze DB RDS che desideri monitorare. | Architetto del cloud | | Fornisci la chiave S3. | Fornisci la posizione del file.zip del codice Lambda nel tuo bucket S3, senza barre iniziali (ad esempio o). `index.zip` `controls/index.zip` | Architetto del cloud | | Fornisci un indirizzo email. | Fornisci un indirizzo email attivo a cui desideri ricevere le notifiche di violazione. | Architetto del cloud | | Specificare un livello di registrazione. | Specificare il livello di registrazione e la verbosità. `Info`indica messaggi informativi dettagliati sullo stato di avanzamento dell'applicazione e deve essere utilizzato solo per il debug. `Error`indica eventi di errore che potrebbero comunque consentire all'applicazione di continuare a funzionare. `Warning`indica situazioni potenzialmente dannose. | Architetto del cloud | | Inserisci le chiavi e i valori dei tag per le tue istanze DB RDS. | Inserisci le chiavi e i valori dei tag richiesti che desideri applicare automaticamente all'istanza RDS. Per ulteriori informazioni, consulta [Tagging delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) nella documentazione AWS. | Architetto del cloud | ### Confermare la sottoscrizione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Conferma l'iscrizione via e-mail. | Quando il CloudFormation modello viene distribuito correttamente, invia un messaggio e-mail di sottoscrizione all'indirizzo e-mail fornito. Per ricevere notifiche quando le istanze vengono contrassegnate, è necessario confermare questa sottoscrizione e-mail. | Architetto del cloud | ## Risorse correlate + [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) (documentazione Amazon S3) + [Etichettatura delle risorse Amazon RDS (documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) Amazon Aurora) + [Caricamento di oggetti](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) (documentazione Amazon S3) + [Creazione di una regola CloudWatch Events che si attiva su una chiamata API AWS utilizzando AWS CloudTrail](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html) ( CloudWatch documentazione Amazon) ## Allegati [Per accedere a contenuti aggiuntivi associati a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/attachments/attachment.zip) # Stima del costo di una tabella DynamoDB per la capacità su richiesta *Moinul Al-Mamun, Amazon Web Services* ## Riepilogo [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) è un database transazionale NoSQL che fornisce una latenza di un millisecondo anche su scala di petabyte. Questa offerta serverless di Amazon Web Services (AWS) sta diventando popolare grazie alle sue prestazioni e scalabilità costanti. Non è necessario effettuare il provisioning dell'infrastruttura sottostante. La singola tabella può crescere fino a petabyte. Con la modalità di capacità su richiesta, paghi in base alla richiesta per le letture e le scritture dei dati eseguite dall'applicazione sulle tabelle. I costi di AWS si basano sulle unità di richiesta di lettura (RRUs) e unità di richiesta di scrittura (WRUs) accumulate in un mese. DynamoDB monitora continuamente le dimensioni della tabella durante tutto il mese per determinare i costi di archiviazione. Supporta il backup continuo con point-in-time-recovery (PITR). DynamoDB monitora continuamente le dimensioni delle tabelle abilitate a PITR per tutto il mese per determinare i costi di backup. Per stimare il costo di DynamoDB per un progetto, è importante calcolare la quantità di RRU, WRU e storage che verrà consumata nelle diverse fasi del ciclo di vita del prodotto. Per una stima approssimativa dei costi, puoi utilizzare [AWS Pricing Calculator](https://calculator.aws/#/createCalculator/DynamoDB), ma devi fornire un numero approssimativo di RRUs requisiti di storage per la tua tabella. WRUs Questi possono essere difficili da stimare all'inizio del progetto. AWS Pricing Calculator non considera il tasso di crescita dei dati o la dimensione degli articoli e non considera separatamente il numero di letture e scritture per la tabella di base e gli indici secondari globali (). GSIs Per utilizzare AWS Pricing Calculator, devi stimare tutti questi aspetti e ipotizzare cifre approssimative per WRU, RRU e dimensioni dello storage per ottenere una stima dei costi. Questo modello fornisce un meccanismo e un modello Microsoft Excel riutilizzabile per stimare i fattori di costo di base di DynamoDB, come i costi di scrittura, lettura, archiviazione, backup e ripristino, per la modalità di capacità on demand. È più granulare di AWS Pricing Calculator e considera la tabella di base e GSIs i requisiti in modo indipendente. Considera inoltre il tasso di crescita mensile dei dati relativi agli articoli e prevede i costi per tre anni. ## Prerequisiti e limitazioni **Prerequisiti** + Conoscenza di base di DynamoDB e della progettazione di modelli di dati DynamoDB + [Conoscenze di base sui prezzi di DynamoDB, WRU, RRU, storage, backup e ripristino (per ulteriori informazioni, consulta Prezzi per la capacità on demand)](https://aws.amazon.com/dynamodb/pricing/on-demand/) + Conoscenza dei dati, del modello di dati e delle dimensioni degli elementi in DynamoDB + Conoscenza di DynamoDB GSIs **Limitazioni** + Il modello fornisce un calcolo approssimativo, ma non è appropriato per tutte le configurazioni. Per ottenere una stima più accurata, è necessario misurare la dimensione del singolo articolo per ogni articolo nella tabella di base e. GSIs + Per una stima più accurata, è necessario considerare il numero previsto di scritture (inserimento, aggiornamento ed eliminazione) e letture per ogni articolo in un mese medio. + Questo modello supporta la stima dei soli costi di scrittura, lettura, archiviazione, backup e ripristino per i prossimi anni sulla base di ipotesi di crescita fissa dei dati. ## Tools (Strumenti) **Servizi AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. **Altri strumenti** + [AWS Pricing Calculator](https://calculator.aws/#/createCalculator/DynamoDB) è uno strumento di pianificazione basato sul Web che puoi utilizzare per creare stime per i tuoi casi d'uso AWS. ## Best practice Per mantenere bassi i costi, prendi in considerazione le seguenti best practice di progettazione di DynamoDB. + [Progettazione delle chiavi di partizione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-uniform-load.html): utilizza una chiave di partizione ad alta cardinalità per distribuire il carico in modo uniforme. + Modello di [progettazione dell'elenco di adiacenza: utilizza questo modello](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html) di progettazione per la gestione one-to-many e le relazioni. many-to-many + Indice [sparso: usa l'indice](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-general-sparse-indexes.html) sparso per il tuo. GSIs Quando crei un GSI, specifica una chiave di partizione e opzionalmente una chiave di ordinamento. Solo gli elementi della tabella di base che contengono una chiave di partizione GSI corrispondente vengono visualizzati nell'indice sparse. Questo aiuta a rimanere GSIs più piccoli. + [Sovraccarico dell'indice](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-gsi-overloading.html): utilizza lo stesso GSI per indicizzare vari tipi di articoli. + [Partizionamento in scrittura del GSI](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-gsi-sharding.html): partiziona con cura per distribuire i dati tra le partizioni per query efficienti e veloci. + [Oggetti di grandi dimensioni](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html): archivia solo i metadati all'interno della tabella, salva il blob in Amazon S3 e conserva il riferimento in DynamoDB. Suddividi gli elementi di grandi dimensioni in più elementi e indicizzali in modo efficiente utilizzando le chiavi di ordinamento. Per altre best practice di progettazione, consulta la [Guida per gli sviluppatori](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) di Amazon DynamoDB. ## Epiche ### Estrai le informazioni sugli elementi dal tuo modello di dati DynamoDB | Operazione | Description | Competenze richieste | | --- | --- | --- | | Ottieni le dimensioni dell'articolo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingegnere dei dati | | Stima il costo di scrittura. | Per stimare i costi di scrittura in modalità di capacità on demand, devi innanzitutto misurare quanti ne WRUs verranno consumati in un mese. A tal fine, è necessario considerare i seguenti fattori:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Per ulteriori informazioni, consulta la sezione *Informazioni aggiuntive*. | Ingegnere dei dati | | Stima il costo di lettura. | Per stimare i costi di lettura in modalità on demand, devi innanzitutto misurare quanti ne RRUs verranno consumati in un mese. A tal fine, è necessario considerare i seguenti fattori: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingegnere dei dati, sviluppatore di app | | Stima le dimensioni e i costi di archiviazione. | Innanzitutto, stima il fabbisogno medio mensile di archiviazione in base alle dimensioni dell'articolo nella tabella. Quindi calcola il costo di storage moltiplicando la dimensione dello storage per il prezzo di storage per GB per la tua regione AWS. Se hai già inserito dati per stimare il costo di scrittura, non è necessario inserirli nuovamente per calcolare le dimensioni dello storage. Altrimenti, per stimare le dimensioni dello spazio di archiviazione, è necessario considerare i seguenti fattori: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingegnere dei dati | ### Inserisci le informazioni sull'articolo e sull'oggetto nel modello Excel | Operazione | Description | Competenze richieste | | --- | --- | --- | | Scarica il modello Excel dalla sezione Allegati e adattalo alla tabella dei casi d'uso. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingegnere dei dati | | Inserisci le informazioni nel modello Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Nel modello sono presenti tre elementi o entità: informazioni, metadati e relazioni. Ce ne sono due GSIs. Per il tuo caso d'uso, se hai bisogno di più elementi, crea nuove righe. Se ne hai bisogno di più GSIs, copia un blocco GSI esistente e incollalo per creare tutti i blocchi GSI di cui hai bisogno. Quindi regola i calcoli delle colonne SUM e TOTAL. | Ingegnere dei dati | ## Risorse correlate **Riferimenti** + [Prezzi di Amazon DynamoDB per la capacità su richiesta](https://aws.amazon.com/dynamodb/pricing/on-demand/) + [Calcolatore dei prezzi AWS per DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) + [Best practice per la progettazione e l'architettura con DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) + [Nozioni di base su DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) **Guide e pattern** + [Modellazione dei dati con Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/) + [Stima dei costi di storage per una tabella Amazon DynamoDB](https://apg-library.amazonaws.com/content/9b74399d-9655-47ee-b9b3-de46b65bc4e3) ## Informazioni aggiuntive **Scrivi un esempio di calcolo dei costi** Il design del modello di dati DynamoDB mostra tre elementi per prodotto e una dimensione media degli elementi di 4 KB. Quando aggiungi un nuovo prodotto alla tabella base di DynamoDB, consuma il numero di elementi\$1 (dimensione dell'articolo/1 KB di unità di scrittura) = 3 \$1 (4/1) = 12 WRU. In questo esempio, per scrivere 1 KB, il prodotto consuma 1 WRU. **Leggi l'esempio di calcolo dei costi** Per ottenere la stima della RRU, considera la media di quante volte ogni articolo verrà letto in un mese. Ad esempio, l'elemento Informazioni verrà letto, in media, 10 volte in un mese, l'elemento di metadati verrà letto due volte e l'elemento relativo alla relazione verrà letto cinque volte. Nel modello di esempio, RRU totale per tutti i componenti = numero di nuovi componenti creati ogni mese \$1 RRU per componente al mese = 10 milioni \$1 17 RRU = 170 milioni di RRU al mese. Ogni mese verranno aggiunti nuovi elementi (componenti o prodotti) e il numero totale di prodotti aumenterà nel tempo. Pertanto, anche i requisiti RRU aumenteranno nel tempo. + Per il primo mese RRU, il consumo sarà di 170 milioni. + Per il secondo mese, il consumo di RRU sarà di 2\$1 170 milioni = 340 milioni. + Per il terzo mese il consumo di RRU sarà di 3\$1 170 milioni = 510 milioni. Il grafico seguente mostra il consumo mensile di RRU e le previsioni dei costi. ![\[Il consumo di RRU aumenta più rapidamente del costo.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/3505bfc8-694d-4acc-8585-cd71258fa315.png) Nota che i prezzi nel grafico sono solo a scopo illustrativo. Per creare previsioni accurate per il tuo caso d'uso, consulta la pagina dei prezzi di AWS e utilizza i prezzi nel foglio Excel. **Esempi di calcolo dei costi di storage, backup e ripristino** Lo storage, il backup e il ripristino di DynamoDB sono tutti collegati tra loro. Il backup è direttamente collegato allo storage e il ripristino è direttamente collegato alle dimensioni del backup. All'aumentare delle dimensioni della tabella, i costi di archiviazione, backup e ripristino corrispondenti aumenteranno proporzionalmente. *Dimensioni e costi dello storage* Il costo dello storage aumenterà nel tempo in base al tasso di crescita dei dati. Ad esempio, supponiamo che la dimensione media di un componente o prodotto nella tabella di base GSIs sia di 11 KB e che 10 milioni di nuovi prodotti vengano aggiunti ogni mese alla tabella del database. In tal caso, la dimensione della tabella DynamoDB aumenterà (11 KB \$1 10 milioni) /1024/1024 = 105 GB al mese. Nel primo mese, la dimensione di archiviazione della tabella sarà di 105 GB, nel secondo mese sarà di 105 \$1 105 = 210 e così via. GBs + Per il primo mese, il costo di storage sarà di 105 GB\$1 al prezzo di storage per GB per la tua regione AWS. + Per il secondo mese, il costo di storage sarà di 210 GB\$1 al prezzo di archiviazione per GB per ogni regione. + Per il terzo mese, il costo di archiviazione sarà di 315 GB\$1, il prezzo di archiviazione per GB per regione. Per le dimensioni e i costi dello storage per i prossimi tre anni, consulta la sezione *Dimensioni e previsioni dello storage*. *Costo di backup* I costi di backup aumenteranno nel tempo in base al tasso di crescita dei dati. Quando si attiva il backup continuo con point-in-time-recovery (PITR), i costi di backup continuo si basano sulla media di storage in GB al mese. In un mese solare, la dimensione media del backup sarebbe la stessa della dimensione di archiviazione della tabella, anche se le dimensioni effettive potrebbero essere leggermente diverse. Man mano che verranno aggiunti nuovi prodotti ogni mese, la dimensione totale dello storage e la dimensione del backup aumenteranno nel tempo. Ad esempio, per il primo mese, la dimensione media di backup di 105 GB potrebbe aumentare fino a 210 GB per il secondo mese. + Per il primo mese, il costo del backup sarà di 105 GB\$1 al mese (prezzo per GB di backup continuo) per GB nella tua regione AWS. + Per il secondo mese, il costo del backup sarà di 210 GB\$1 al mese (prezzo per GB) di backup continuo per ogni regione. + Per il terzo mese, il costo del backup sarà di 315 GB al mese\$1, il prezzo per GB del backup continuo a seconda della regione. + e così via I costi di Backup sono inclusi nel grafico della sezione *Dimensioni dello storage e previsione dei costi*. *Costo di ripristino* Quando si esegue un backup continuo con PITR abilitato, i costi delle operazioni di ripristino si basano sulle dimensioni del ripristino. Ogni volta che si esegue il ripristino, il pagamento viene calcolato in base ai gigabyte di dati ripristinati. Se le dimensioni della tabella sono grandi e il ripristino viene eseguito più volte in un mese, l'operazione risulterà costosa. Per stimare i costi di ripristino, questo esempio presuppone che si esegua un ripristino PITR una volta al mese alla fine del mese. L'esempio utilizza la dimensione media mensile del backup come dimensione dei dati di ripristino per quel mese. Per il primo mese, la dimensione media del backup è di 105 GB, mentre per il ripristino alla fine del mese, la dimensione dei dati di ripristino sarebbe di 105 GB. Per il secondo mese, sarebbero 210 GBs e così via. I costi di ripristino aumenteranno nel tempo in base al tasso di crescita dei dati. + Per il primo mese, il costo di ripristino sarà di 105 GB\$1 al prezzo di ripristino per GB per la tua regione AWS. + Per il secondo mese, il costo di ripristino sarà di 210 GB\$1 al prezzo di ripristino per GB per regione. + Per il terzo mese, il costo di ripristino sarà di 315 GB\$1 al prezzo di ripristino per GB nella regione. Per ulteriori informazioni, consulta la scheda Archiviazione, backup e ripristino nel modello Excel e il grafico nella sezione seguente. *Dimensioni dello storage e previsione dei costi* Nel modello, la dimensione effettiva dello spazio di archiviazione fatturabile viene calcolata sottraendo i 25 GB mensili del piano gratuito per la classe di tabelle Standard. Nel foglio, vedrai un grafico di previsione suddiviso in valori mensili. Il seguente grafico di esempio prevede le dimensioni mensili dello storage in GB, i costi di storage fatturabili, i costi di backup su richiesta e i costi di ripristino per i prossimi 36 mesi di calendario. Tutti i costi sono in USD. Dal grafico, risulta chiaro che i costi di storage, backup e ripristino aumentano proporzionalmente all'aumento delle dimensioni dello storage. ![\[Le dimensioni dello storage superano le tremila unità, mentre i costi sono inferiori a mille.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/fd9f06d0-bc9c-4b4e-8cbd-3e527fe09e88.png) Tieni presente che i prezzi utilizzati nel grafico sono solo a scopo illustrativo. Per creare prezzi accurati per il tuo caso d'uso, consulta la pagina dei prezzi di AWS e utilizza tali prezzi nel modello Excel. ## Allegati [Per accedere a contenuti aggiuntivi associati a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/1797b48f-a183-4f25-811f-44921c3a48ee/attachments/attachment.zip) # Stima dei costi di storage per una tabella Amazon DynamoDB *Moinul Al-Mamun, Amazon Web Services* ## Riepilogo Amazon DynamoDB è un database transazionale NoSQL che fornisce una latenza di un millisecondo anche su scala di petabyte. Questa popolare offerta AWS serverless di offre prestazioni e scalabilità costanti. Non è necessario effettuare il provisioning dello storage e la singola tabella può crescere fino a petabyte. DynamoDB monitora continuamente le dimensioni della tabella durante tutto il mese per determinare i costi di archiviazione. AWS quindi ti addebita la dimensione media dello spazio di archiviazione in gigabyte. Più la tabella cresce nel tempo, più aumenteranno i costi di archiviazione. Per calcolare i costi di archiviazione, puoi utilizzare [AWS Pricing Calculator](https://calculator.aws/#/createCalculator/DynamoDB), ma devi fornire la dimensione approssimativa della tabella, compresi gli indici secondari globali (GSIs), che è davvero difficile da stimare all'inizio del progetto. Inoltre, AWS Pricing Calculator non considera il tasso di crescita dei dati. Questo modello fornisce un meccanismo e un modello Microsoft Excel riutilizzabile per calcolare le dimensioni e i costi dello storage DynamoDB. Considera i requisiti di archiviazione per la tabella di base e quelli indipendenti. GSIs Calcola le dimensioni di archiviazione considerando le dimensioni dei singoli elementi e il tasso di crescita dei dati nel tempo. Per ottenere una stima, inserisci due informazioni nel modello: + La dimensione del singolo elemento in kilobyte per la tabella di base e GSIs + Quanti nuovi oggetti o prodotti potrebbero essere aggiunti alla tabella, in media, in un mese (ad esempio, 10 milioni) Il modello genera un grafico di archiviazione e previsione dei costi per i prossimi tre anni, come illustrato nell'esempio seguente. ![\[La linea più bassa per i costi aumenta lentamente e la linea più alta per lo storage aumenta più rapidamente.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9b74399d-9655-47ee-b9b3-de46b65bc4e3/images/c0436252-cc42-4ea3-ac50-c0455aece39d.png) ## Prerequisiti e limitazioni **Prerequisiti** + Conoscenza di base di DynamoDB, inclusi lo storage e i prezzi di DynamoDB + Conoscenza dei dati, del modello di dati e delle dimensioni degli elementi in DynamoDB + Conoscenza degli indici secondari globali DynamoDB () GSIs **Limitazioni** + Il modello fornisce un calcolo approssimativo, ma non è appropriato per tutte le configurazioni. Per ottenere una stima più accurata, è necessario misurare la dimensione del singolo articolo per ogni articolo nella tabella di base e. GSIs + Questo modello supporta solo la stima delle dimensioni e dei costi dello storage per i prossimi anni sulla base di ipotesi di crescita fissa dei dati. ## Tools (Strumenti) **Servizi AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. **Altri strumenti** + [AWS Pricing Calculator](https://docs.aws.amazon.com/pricing-calculator/latest/userguide/what-is-pricing-calculator.html) è uno strumento di pianificazione basato sul Web che puoi utilizzare per creare stime per i tuoi casi AWS d'uso. ## Epiche ### Estrai le informazioni sugli elementi dal tuo modello di dati DynamoDB | Operazione | Description | Competenze richieste | | --- | --- | --- | | Ottieni le dimensioni dell'articolo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingegnere dei dati | | Ottieni il numero di oggetti aggiunti in un mese. | Stima quanti componenti o oggetti verranno aggiunti alla tabella DynamoDB, in media, in un mese. | Ingegnere dei dati | ### Inserisci le informazioni sull'articolo e sull'oggetto nel modello Excel | Operazione | Description | Competenze richieste | | --- | --- | --- | | Scarica e modifica il foglio di calcolo Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingegnere dei dati | | Inserisci le informazioni nel modello Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingegnere dei dati | ## Risorse correlate + [Prezzi della capacità on demand per](https://aws.amazon.com/dynamodb/pricing/on-demand/) Amazon DynamoDB + [AWS Calcolatore dei prezzi per DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) ## Informazioni aggiuntive Tieni presente che il modello allegato prevede solo le dimensioni e i costi di archiviazione per la classe di tabella di archiviazione Standard. In base alla previsione dei costi di archiviazione e considerando le dimensioni dei singoli articoli e il tasso di crescita del prodotto o dell'oggetto, è possibile stimare quanto segue: + Costo di esportazione dei dati + Costi di backup e ripristino + Requisiti di archiviazione dei dati. **Costo dello storage dei dati di Amazon DynamoDB** DynamoDB monitora continuamente le dimensioni delle tabelle per determinare i costi di archiviazione. DynamoDB misura la dimensione dei dati fatturabili aggiungendo la dimensione in byte dei dati grezzi e un sovraccarico di archiviazione per elemento che dipende dalle funzionalità abilitate. Per ulteriori informazioni, consulta la [DynamoDB Developer Guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/CapacityUnitCalculations.html). Il prezzo per l'archiviazione dei dati dipende dalla classe di tabella. I primi 25 GB archiviati ogni mese sono gratuiti se utilizzi la classe di tabelle DynamoDB Standard. [Per ulteriori informazioni sui costi di storage per le diverse classi di tabelle Standard e Standard-Infrequent Access Regioni AWS, vedi Prezzi per la capacità on demand.](https://aws.amazon.com/dynamodb/pricing/on-demand/) ## Allegati [Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/9b74399d-9655-47ee-b9b3-de46b65bc4e3/attachments/attachment.zip) # Stima le dimensioni del motore Amazon RDS per un database Oracle utilizzando i report AWR *Abhishek Verma e Eduardo Valentim, Amazon Web Services* ## Riepilogo Quando esegui la migrazione di un database Oracle ad Amazon Relational Database Service (Amazon RDS) o Amazon Aurora, il calcolo della CPU, della memoria e del I/O disco per il database di destinazione è un requisito fondamentale. È possibile stimare la capacità richiesta del database di destinazione analizzando i report di Oracle Automatic Workload Repository (AWR). Questo modello spiega come utilizzare i report AWR per stimare questi valori. Il database Oracle di origine potrebbe essere locale o ospitato su un'istanza Amazon Elastic Compute Cloud (Amazon EC2) oppure potrebbe essere un'istanza DB Amazon RDS for Oracle. Il database di destinazione potrebbe essere qualsiasi database Amazon RDS o Aurora. **Nota** Le stime della capacità saranno più precise se il motore di database di destinazione è Oracle. Per altri database Amazon RDS, le dimensioni del motore possono variare a causa delle differenze nell'architettura del database. Ti consigliamo di eseguire il test delle prestazioni prima di migrare il database Oracle. ## Prerequisiti e limitazioni **Prerequisiti** + Una licenza Oracle Database Enterprise Edition e una licenza Oracle Diagnostics Pack per scaricare i report AWR. **Versioni del prodotto** + Tutte le edizioni di Oracle Database per le versioni 11g (versioni 11.2.0.3.v1 e successive) e fino a 12.2 e 18c,19c. + Questo modello non copre Oracle Engineered Systems o Oracle Cloud Infrastructure (OCI). ## Architecture **Stack tecnologico di origine** Una delle seguenti: + Un database Oracle locale + Un database Oracle su un'istanza EC2 + Un'istanza DB Amazon RDS per Oracle **Stack tecnologico Target** + Qualsiasi database Amazon RDS o Amazon Aurora **Architettura Target** Per informazioni sul processo di migrazione completo, consulta lo schema [Migrare un database Oracle su Aurora PostgreSQL utilizzando AWS DMS e AWS SCT](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.html). **Automazione e scalabilità** Se hai più database Oracle da migrare e desideri utilizzare parametri prestazionali aggiuntivi, puoi automatizzare il processo seguendo i passaggi descritti nel post del blog [Istanze Amazon RDS di dimensioni corrette su larga scala in base ai](https://aws.amazon.com/blogs/database/right-sizing-amazon-rds-instances-at-scale-based-on-oracle-performance-metrics/) parametri delle prestazioni Oracle. ## Tools (Strumenti) + [Oracle Automatic Workload Repository (AWR) è un repository](https://docs.oracle.com/en-us/iaas/performance-hub/doc/awr-report-ui.html) integrato nei database Oracle. Periodicamente raccoglie e archivia i dati sull'attività del sistema e sul carico di lavoro, che vengono poi analizzati da Automatic Database Diagnostic Monitor (ADDM). AWR acquisisce istantanee dei dati sulle prestazioni del sistema periodicamente (per impostazione predefinita, ogni 60 minuti) e archivia le informazioni (per impostazione predefinita, fino a 8 giorni). È possibile utilizzare le viste e i report AWR per analizzare questi dati. ## Best practice + Per calcolare il fabbisogno di risorse per il database di destinazione, puoi utilizzare un singolo report AWR, più report AWR o viste AWR dinamiche. Si consiglia di utilizzare più report AWR durante il periodo di picco di carico per stimare le risorse necessarie per gestire tali carichi di picco. Inoltre, le viste dinamiche forniscono più punti dati che consentono di calcolare i requisiti di risorse in modo più preciso. + È necessario stimare gli IOPS solo per il database che si intende migrare, non per altri database e processi che utilizzano il disco. + Per calcolare quanto I/O viene utilizzato dal database, non utilizzate le informazioni nella sezione Load Profile del rapporto AWR. Utilizza invece la sezione I/O Profilo, se disponibile, oppure vai alla sezione Instance Activity Stats e guarda i valori totali per le operazioni fisiche di lettura e scrittura. + Quando stimi l'utilizzo della CPU, ti consigliamo di utilizzare il metodo delle metriche del database anziché le statistiche del sistema operativo (OS), perché si basa sulla CPU utilizzata solo dai database. (Le statistiche del sistema operativo includono anche l'utilizzo della CPU da parte di altri processi). È inoltre necessario controllare i consigli relativi alla CPU nel rapporto ADDM per migliorare le prestazioni dopo la migrazione. + Quando stabilisci il tipo di istanza giusto, considera i limiti di I/O throughput (Amazon Elastic Block Store (Amazon EBS) e il throughput di rete per la dimensione specifica dell'istanza. + Esegui il test delle prestazioni prima della migrazione per convalidare le dimensioni del motore. ## Epiche ### Crea un rapporto AWR | Operazione | Description | Competenze richieste | | --- | --- | --- | | Abilita il rapporto AWR. | Per abilitare il rapporto, segui le istruzioni nella [documentazione Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/18/tgdba/gathering-database-statistics.html#GUID-26D359FA-F809-4444-907C-B5AFECD9AE29). | DBA | | Verifica il periodo di conservazione. | Per verificare il periodo di conservazione del rapporto AWR, utilizza la seguente query.
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
SQL> SELECT snap_interval,retention FROM dba_hist_wr_control;| DBA | | Genera l'istantanea. | Se l'intervallo delle istantanee AWR non è sufficientemente granulare per registrare il picco del carico di lavoro di picco, puoi generare il rapporto AWR manualmente. Per generare l'istantanea AWR manuale, utilizzate la seguente query.
SQL> EXEC dbms_workload_repository.create_snapshot;| DBA | | Controlla le istantanee recenti. | Per controllare le istantanee AWR recenti, usa la seguente query.
SQL> SELECT snap_id, to_char(begin_interval_time,'dd/MON/yy hh24:mi') Begin_Interval,| DBA | ### Stima dei requisiti del disco I/O | Operazione | Description | Competenze richieste | | --- | --- | --- | | Scegliere un metodo. | IOPS è la misura standard delle operazioni di input e output al secondo su un dispositivo di storage e include operazioni di lettura e scrittura. Se stai migrando un database locale in AWS, devi determinare il disco di picco I/O utilizzato dal database. Puoi utilizzare i seguenti metodi per stimare il disco I/O per il tuo database di destinazione:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)I passaggi seguenti descrivono questi quattro metodi. | DBA | | Opzione 1: utilizzare il profilo di carico. | La tabella seguente mostra un esempio della sezione Load Profile del rapporto AWR.Per informazioni più accurate, si consiglia di utilizzare l'opzione 2 (profili I/O) o l'opzione 3 (statistiche sull'attività delle istanze) anziché il profilo di carico.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)In base a queste informazioni, è possibile calcolare IOPs e produrre nel modo seguente:*IOPS = Richieste di lettura: \$1 I/O Richieste di scrittura = I/O 3.586,8 \$1 574,7 = 4134,5**Throughput = lettura fisica (blocchi) \$1 Scrittura fisica (blocchi) = 13.575,1 \$1 3.467,3 = 17.042,4*Poiché la dimensione del blocco in Oracle è di 8 KB, puoi calcolare la velocità effettiva totale come segue:*La velocità effettiva totale in MB è 17042,4 \$1 8 \$1 1024/1024/1024 = 133,2 MB*Non utilizzate il profilo di carico per stimare la dimensione dell'istanza. Non è così preciso come le statistiche o i I/O profili delle attività delle istanze. | DBA | | Opzione 2: utilizza le statistiche sull'attività delle istanze. | Se utilizzi una versione del database Oracle precedente alla 12c, puoi utilizzare la sezione Instance Activity Stats del rapporto AWR per stimare gli IOPS e il throughput. La tabella seguente mostra un esempio di questa sezione.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Sulla base di queste informazioni, è possibile calcolare gli IOPS totali e il throughput nel modo seguente:*IOPS totali = 3.610,28 \$1 757,11 = 4367**Mbps totali = 114.482.426,26 \$1 36.165.631,84 = 150648058,1/1024/1024 = 143 Mbps* | DBA | | Opzione 3: usa I/O i profili. | In Oracle Database 12c, il rapporto AWR include una sezione I/O Profili che presenta tutte le informazioni in un'unica tabella e fornisce dati più accurati sulle prestazioni del database. La tabella seguente mostra un esempio di questa sezione.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Questa tabella fornisce i seguenti valori per il throughput e gli IOPS totali:*Throughput = 143 MBPS (dalla quinta riga, denominata Totale, seconda colonna)**IOPS = 4.367,4 (dalla prima riga, denominata Total Requests, seconda colonna)* | DBA | | Opzione 4: utilizza le viste AWR. | È possibile visualizzare le stesse informazioni su IOPS e sulla velocità effettiva utilizzando le viste AWR. Per ottenere queste informazioni, utilizza la seguente query:
to_char(end_interval_time,'dd/MON/yy hh24:mi') End_Interval
FROM dba_hist_snapshot
ORDER BY 1;
break on report| DBA | | | Al secondo | Per transazione | Per dirigente | Per chiamata | | --- |--- |--- |--- |--- | | **Orario (i) DB:** | 26,6 | 0.2 | 0,00 | 0,02 | | **CPU (e) DB:** | 18,0 | 0.1 | 0,00 | 0.01 | | **CPU (e) in background:** | 0.2 | 0,0 | 0,00 | 0,00 | | **Dimensione di ripristino (byte):** | 2.458.539,9 | 17.097,5 | | | | **Lettura logica (blocchi):** | 3.371.931,5 | 23449,6 | | | | **Blocca le modifiche:** | 21.643,5 | 150,5 | | | | **Lettura fisica (blocchi):** | 13.575,1 | 94,4 | | | | **Scrittura fisica (blocchi):** | 3.467,3 | 24,1 | | | | **Leggi le richieste IO:** | 3.586,8 | 24,9 | | | | **Scrivi richieste IO:** | 574,7 | 4.0 | | | | **Leggi IO (MB):** | 106,1 | 0.7 | | | | **Scrivi IO (MB):** | 27,1 | 0.2 | | | | **Righe di scansione IM:** | 0,0 | 0,0 | | | | **Sessione logica Read IM:** | | | | | | **Chiamate utente:** | 1.245,7 | 8.7 | | | | **Analisi (SQL):** | 4.626,2 | 32,2 | | | | **Analisi rigide (SQL):** | 8.9 | 0.1 | | | | **Area di lavoro SQL (MB):** | 824,9 | 5.7 | | | | **Accessi:** | 1,7 | 0,0 | | | | **Esegue (SQL):** | 136.656,5 | 950,4 | | | | **Rollback:** | 22.9 | 0.2 | | | | **Transazioni:** | 143,8 | | | | | Statistic | Totale | al secondo | per Trans | | --- |--- |--- |--- | | **richieste I/O totali di lettura fisica** | 2.547.333.217 | 3.610,28 | 25,11 | | **byte totali di lettura fisica** | 80.776.296.124.928 | 114.482.426,26 | 796.149,98 | | **richieste I/O totali di scrittura fisica** | 534.198.208 | 757,11 | 5,27 | | **byte totali di scrittura fisici** | 25.517.678.849.024 | 36,165,631,84 | 251,508,18 | | | Lettura\$1scrittura al secondo | Lettura al secondo | Scrivi al secondo | | --- |--- |--- |--- | | **Richieste totali:** | 4.367,4 | 3.610,3 | 757,1 | | **Richieste al database:** | 4.161.5 | 3.586,8 | 574,7 | | **Richieste ottimizzate:** | 0,0 | 0,0 | 0,0 | | **Richieste di ripristino:** | 179,3 | 2.8 | 176,6 | | **Totale (MB):** | 143,7 | 109,2 | 34,5 | | **Banca dati (MB):** | 133,1 | 106,1 | 27,1 | | **Totale ottimizzato (MB):** | 0,0 | 0,0 | 0,0 | | **Ripeti (MB):** | 7.6 | 2.7 | 4.9 | | **Database (blocchi):** | 17.042,4 | 13.575,1 | 3.467,3 | | **Tramite Buffer Cache (blocchi):** | 5.898,5 | 5.360,9 | 537,6 | | **Diretto (blocchi):** | 11.143,9 | 8.214,2 | 2.929,7 | ### Stima dei requisiti della CPU | Operazione | Description | Competenze richieste | | --- | --- | --- | | Scegliere un metodo. | È possibile stimare la CPU richiesta per il database di destinazione in tre modi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Se stai esaminando i core utilizzati, ti consigliamo di utilizzare il metodo delle metriche del database anziché le statistiche del sistema operativo, poiché si basa sulla CPU utilizzata solo dai database di cui intendi migrare. (Le statistiche del sistema operativo includono anche l'utilizzo della CPU da parte di altri processi). È inoltre necessario controllare i consigli relativi alla CPU nel rapporto ADDM per migliorare le prestazioni dopo la migrazione.È inoltre possibile stimare i requisiti in base alla generazione della CPU. Se utilizzi diverse generazioni di CPU, puoi stimare la CPU richiesta per il database di destinazione seguendo le istruzioni contenute nel white paper [Demystifying the Number of v for Optimal](https://d1.awsstatic.com/whitepapers/Demystifying_vCPUs.df200b766578b75009ad8d15c72e493d6408c68a.pdf) Workload Performance. CPUs | DBA | | Opzione 1: stima i requisiti in base ai core disponibili. | Nei report AWR:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)È possibile stimare i core disponibili in due modi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)**Per stimare i core disponibili utilizzando i comandi del sistema operativo**Utilizzate il comando seguente per contare i core del processore.
compute sum of Value on report
select METRIC_NAME,avg(AVERAGE) as "Value"
from dba_hist_sysmetric_summary
where METRIC_NAME in ('Physical Read Total IO Requests Per Sec','Physical Write Total IO Requests Per Sec')
group by metric_name;
$ cat /proc/cpuinfo |grep "cpu cores"|uniqUtilizzate il seguente comando per contare i socket nel processore.
cpu cores : 4
cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l
grep "physical id" /proc/cpuinfo | sort -uNon è consigliabile utilizzare comandi del sistema operativo come **nmon** e **sar** per estrarre l'utilizzo della CPU. Questo perché tali calcoli includono l'utilizzo della CPU da parte di altri processi e potrebbero non riflettere l'effettiva CPU utilizzata dal database.**Per stimare i core disponibili utilizzando il rapporto AWR**È inoltre possibile ricavare l'utilizzo della CPU dalla prima sezione del rapporto AWR. Ecco un estratto del rapporto.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)In questo esempio, il CPUs conteggio è 80, il che indica che sono logici (virtuali). CPUs È inoltre possibile notare che questa configurazione ha due socket, un processore fisico per socket (per un totale di due processori fisici) e 40 core per ogni processore o socket fisico. | DBA | | Opzione 2: stima dell'utilizzo della CPU utilizzando le statistiche del sistema operativo. | È possibile controllare le statistiche sull'utilizzo della CPU del sistema operativo direttamente nel sistema operativo (utilizzando **sar** o un'altra utilità del sistema operativo host) o esaminando i valori IDLE/ (IDLE\$1BUSY) dalla sezione Operating System Statistics del rapporto AWR. **Puoi vedere i secondi di CPU consumati direttamente da v\$1osstat.** I report AWR e Statspack mostrano questi dati anche nella sezione Statistiche del sistema operativo.Se nella stessa casella sono presenti più database, tutti hanno gli stessi valori **v\$1osstat** per BUSY\$1TIME.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Se nel sistema non sono presenti altri utenti principali di CPU, utilizza la formula seguente per calcolare la percentuale di utilizzo della CPU:*Utilizzo = Tempo di occupazione/Tempo totale**Orario di lavoro = requisiti = V\$1OSStat.busy\$1time**C = Tempo totale (occupato\$1inattivo)**C = capacità = V\$1OSTAT.busy\$1time \$1 V\$1OSTAT.idle\$1time**Utilizzo = BUSY\$1TIME/(BUSY\$1TIME \$1 IDLE\$1TIME)**= -1.305.569.937/(1.305.569.937 \$1 4.312.718.839)**= 23% utilizzato* | DBA | | Opzione 3: stima dell'utilizzo della CPU utilizzando le metriche del database. | Se nel sistema sono in esecuzione più database, puoi utilizzare le metriche del database visualizzate all'inizio del rapporto.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Per ottenere i parametri di utilizzo della CPU, usa questa formula:*Utilizzo della CPU del database (% della potenza della CPU disponibile) = tempo CPU/NUM\$1CPUS /tempo trascorso*dove l'utilizzo della CPU è descritto in base al *tempo impiegato dalla CPU* e rappresenta il tempo impiegato sulla CPU, non il tempo di attesa della CPU. Questo calcolo si traduce in:*= 312.625,40/11.759,64/80 = viene utilizzato il 33% della CPU**Numero di core (33%) \$1 80 = 26,4 core**Core totali = 26,4 \$1 (120%) = 31,68 core*Puoi utilizzare il maggiore di questi due valori per calcolare l'utilizzo della CPU dell'istanza Amazon RDS o Aurora DB.Su IBM AIX, l'utilizzo calcolato non corrisponde ai valori del sistema operativo o del database. Questi valori corrispondono su altri sistemi operativi. | DBA | | Nome DB | ID DB | Istanza | Inserisci un numero | Ora di avvio | Versione | RAC | | --- |--- |--- |--- |--- |--- |--- | | XXXX |
physical id : 0
physical id : 1
call mysql.rds_set_configuration('binlog retention hours', XX)Conferma l'impostazione eseguendo il comando seguente.call mysql.rds_show_configuration;I database compatibili con MySQL gestiti da AWS eliminano i log binari il prima possibile. Pertanto, il periodo di conservazione deve essere sufficientemente lungo da garantire che i log non vengano eliminati prima dell'esecuzione del task AWS DMS. Un valore di 24 ore è in genere sufficiente, ma il valore deve basarsi sul tempo necessario per configurare l'attività AWS DMS nella regione DR. | DBA | ### Aggiorna l'attività AWS DMS esistente nella regione principale | Operazione | Description | Competenze richieste | | --- | --- | --- | | Registra l'ARN dell'attività AWS DMS. | Utilizza Amazon Resource Name (ARN) per ottenere il nome dell'attività AWS DMS per un uso successivo. Per recuperare l'ARN del task AWS DMS, visualizza l'attività nella console o esegui il comando seguente.
aws dms describe-replication-tasksUn ARN ha il seguente aspetto.
arn:aws:dms:us-east-1:I caratteri dopo l'ultimo punto corrispondono al nome dell'attività utilizzato in un passaggio successivo. | Amministratore AWS | | Modifica l'attività AWS DMS esistente per registrare il checkpoint. | AWS DMS crea checkpoint che contengono informazioni in modo che il motore di replica conosca il punto di ripristino per il flusso di modifiche. Per registrare le informazioni sui checkpoint, esegui i seguenti passaggi nella console:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Amministratore AWS | | Convalida le informazioni sui checkpoint. | Utilizzando un client MySQL connesso all'endpoint writer per il cluster, interroga la nuova tabella di metadati nel cluster di database reporter per verificare che esista e contenga le informazioni sullo stato di replica. Eseguire il seguente comando seguente.:task:AN6HFFMPM246XOZVEUHCNSOVF7MQCLTOZUIRAMY
select * from awsdms_control.awsdms_txn_state;Il nome dell'attività dell'ARN deve essere trovato in questa tabella nella `Task_Name` colonna. | DBA | ### Espandi entrambi i cluster Amazon Aurora in una regione DR | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un'infrastruttura di base nella regione DR. | Crea i componenti di base necessari per la creazione e l'accesso ai cluster Amazon Aurora:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Assicuratevi che la configurazione di entrambi i gruppi di parametri corrisponda alla configurazione nella regione principale. | Amministratore AWS | | Aggiungi la regione DR a entrambi i cluster Amazon Aurora. | Aggiungi una regione secondaria (la regione DR) ai cluster Amazon Aurora principali e reporter. Per ulteriori informazioni, consulta [Aggiungere una regione AWS a un database globale Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-attaching). | Amministratore AWS | ### Esegui il failover | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi l'attività AWS DMS. | L'attività AWS DMS nella regione primaria non funzionerà correttamente dopo il failover e deve essere interrotta per evitare errori. | Amministratore AWS | | Esegui un failover gestito. | Eseguire un failover gestito del cluster di database principale nella regione DR. Per istruzioni, consulta [Esecuzione di failover pianificati gestiti per i database globali di Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Una volta completato il failover sul cluster di database principale, esegui la stessa attività sul cluster di database reporter. | Amministratore AWS, DBA | | Carica i dati nel database principale. | Inserisci i dati di test nel nodo writer del database principale nel cluster di database DR. Questi dati verranno utilizzati per verificare che la replica funzioni correttamente. | DBA | | Crea l'istanza di replica AWS DMS. | Per creare l'istanza di replica AWS DMS nella regione DR, consulta [Creazione di un'istanza di replica](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Creating.html). | Amministratore AWS, DBA | | Crea gli endpoint di origine e destinazione di AWS DMS. | Per creare gli endpoint di origine e destinazione di AWS DMS nella regione DR, consulta [Creazione di endpoint di origine e destinazione](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.Creating.html). L'origine deve puntare all'istanza writer del cluster di database principale. La destinazione deve puntare all'istanza writer del cluster di database reporter. | Amministratore AWS, DBA | | Ottieni il checkpoint di replica. | Per ottenere il checkpoint di replica, utilizzate un client MySQL per interrogare la tabella dei metadati eseguendo quanto segue sul nodo writer nel cluster di database reporter nella regione DR.
select * from awsdms_control.awsdms_txn_state;Nella tabella, trova il valore task\$1name che corrisponde all'ARN del task AWS DMS esistente nella regione primaria che hai ottenuto nella seconda epic. | DBA | | Crea un task AWS DMS. | Utilizzando la console, crea un'attività AWS DMS nella regione DR. Nell'attività, specifica un metodo di migrazione di **Replicate data changes only**. Per ulteriori informazioni, vedere [Creazione di un'attività.](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Imposta l'impostazione dell'attività di **migrazione AWS DMS task Start** **su Automatically on create**. | Amministratore AWS, DBA | | Registra l'ARN dell'attività AWS DMS. | Usa l'ARN per ottenere il nome del task AWS DMS per un uso successivo. Per recuperare l'ARN del task AWS DMS, esegui il comando seguente.
aws dms describe-replication-tasks| Amministratore AWS, DBA | | Convalida i dati replicati. | Interroga il cluster di database reporter nella regione DR per confermare che i dati di test caricati nel cluster di database principale siano stati replicati. | DBA | ### Esegui il failback | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi l'attività AWS DMS. | L'attività AWS DMS nella regione DR non funzionerà correttamente dopo il failback e deve essere interrotta per evitare errori. | Amministratore AWS | | Esegui un failback gestito. | Esegui il failback del cluster di database principale nella regione principale. Per istruzioni, consulta [Esecuzione di failover pianificati gestiti per i database globali di Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Una volta completato il failback sul cluster di database principale, esegui la stessa attività sul cluster di database reporter. | Amministratore AWS, DBA | | Ottieni il checkpoint di replica. | Per ottenere il checkpoint di replica, utilizzate un client MySQL per interrogare la tabella dei metadati eseguendo quanto segue sul nodo writer nel cluster di database reporter nella regione DR.
select * from awsdms_control.awsdms_txn_state;Nella tabella, trova il `task_name` valore che corrisponde all'ARN del task AWS DMS esistente nella regione DR che hai ottenuto nella quarta epopea. | DBA | | Aggiorna gli endpoint di origine e destinazione di AWS DMS. | Dopo il failback dei cluster di database, controlla i cluster nella regione primaria per determinare quali nodi sono le istanze di scrittura. Verifica quindi che gli endpoint di origine e destinazione di AWS DMS esistenti nella regione primaria puntino alle istanze writer. In caso contrario, aggiorna gli endpoint con i nomi DNS (Domain Name System) dell'istanza di scrittura. | Amministratore AWS | | Crea un task AWS DMS. | Utilizzando la console, crea un'attività AWS DMS nella regione principale. Nell'attività, specifica un metodo di migrazione di **Replicate data changes only**. Per ulteriori informazioni, vedere [Creazione di un'attività.](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Amministratore AWS, DBA | | Registra l'attività AWS DMS Amazon Resource Name (ARN). | Usa l'ARN per ottenere il nome del task AWS DMS per un uso successivo. Per recuperare l'ARN del task AWS DMS, esegui il seguente comando:
aws dms describe-replication-tasksIl nome dell'attività sarà necessario quando si esegue un altro failover gestito o durante uno scenario di DR. | Amministratore AWS, DBA | | Eliminare le attività di AWS DMS. | Elimina l'attività AWS DMS originale (attualmente interrotta) nella regione principale e l'attività AWS DMS esistente (attualmente interrotta) nella regione secondaria. | Amministratore AWS | ## Risorse correlate + [Configurazione del cluster Amazon Aurora DB](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraSettingUp.html) + [Using Amazon Aurora global databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Lavorare con Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraMySQL.html) + [Utilizzo di un'istanza di replica AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) + [Utilizzo degli endpoint AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.html) + [Lavorare con le attività di AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) + [Che cos'è AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ## Informazioni aggiuntive I database globali di Amazon Aurora vengono utilizzati in questo esempio per il DR perché forniscono un obiettivo del tempo di ripristino (RTO) efficace di 1 secondo e un obiettivo del punto di ripristino (RPO) inferiore a 1 minuto, entrambi inferiori rispetto alle soluzioni replicate tradizionali e ideali per scenari di DR. I database globali di Amazon Aurora offrono molti altri vantaggi, tra cui: + Letture globali con latenza locale: i consumatori globali possono accedere alle informazioni in una regione locale, con latenza locale. + Cluster Amazon Aurora DB secondari scalabili: i cluster secondari possono essere scalati indipendentemente, aggiungendo fino a 16 repliche di sola lettura. + Replica rapida dai cluster Amazon Aurora DB primari a quelli secondari: la replica ha un impatto minimo sulle prestazioni del cluster primario. Si verifica a livello di storage, con latenze di replica tipiche tra regioni inferiori a 1 secondo. Questo modello utilizza anche AWS DMS per la replica. I database Amazon Aurora offrono la possibilità di creare repliche di lettura, che possono semplificare il processo di replica e la configurazione del DR. Tuttavia, AWS DMS viene spesso utilizzato per la replica quando sono necessarie trasformazioni dei dati o quando il database di destinazione richiede indici aggiuntivi che il database di origine non dispone. # Esegui la migrazione di funzioni e procedure Oracle con più di 100 argomenti a PostgreSQL *Srinivas Potlachervoo, Amazon Web Services* ## Riepilogo Questo modello mostra come migrare le funzioni e le procedure di Oracle Database con più di 100 argomenti a PostgreSQL. Ad esempio, puoi utilizzare questo modello per migrare le funzioni e le procedure Oracle verso uno dei seguenti servizi di database AWS compatibili con PostgreSQL: + Amazon Relational Database Service (Amazon RDS) per PostgreSQL + Amazon Aurora PostgreSQL-Compatible Edition PostgreSQL non supporta funzioni o procedure con più di 100 argomenti. Come soluzione alternativa, puoi definire un nuovo tipo di dati con campi di tipo che corrispondono agli argomenti della funzione di origine. È quindi possibile creare ed eseguire una PL/pgSQL funzione che utilizza il tipo di dati personalizzato come argomento. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un'[istanza di database Amazon RDS Oracle (DB)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) + [Un'istanza DB [Amazon RDS per PostgreSQL o un'istanza](https://aws.amazon.com/getting-started/hands-on/create-connect-postgresql-db/) DB Aurora compatibile con PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) **Versioni del prodotto** + Istanza Amazon RDS Oracle DB versioni 10.2 e successive + Istanza DB Amazon RDS PostgreSQL 9.4 e successive o istanze DB compatibili con Aurora PostgreSQL versioni 9.4 e successive + Oracle SQL Developer versione 18 e successive + pGAdmin versione 4 e successive ## Architecture **Stack tecnologico di origine** + Istanza Amazon RDS Oracle DB versioni 10.2 e successive **Stack tecnologico Target** + Istanza DB Amazon RDS PostgreSQL 9.4 e successive o istanze DB compatibili con Aurora PostgreSQL versioni 9.4 e successive ## Tools (Strumenti) **Servizi AWS** + [Amazon Relational Database Service (Amazon RDS) per PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) ti aiuta a configurare, gestire e scalare un database relazionale PostgreSQL nel cloud AWS. + [Amazon Aurora PostgreSQL Compatible Edition è un motore](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) di database relazionale completamente gestito e conforme ad ACID che ti aiuta a configurare, gestire e scalare le distribuzioni PostgreSQL. **Altri servizi** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) è un ambiente di sviluppo integrato che semplifica lo sviluppo e la gestione dei database Oracle nelle implementazioni tradizionali e basate sul cloud. + [pgAdmin](https://www.pgadmin.org/) è uno strumento di gestione open source per PostgreSQL. Fornisce un'interfaccia grafica che consente di creare, gestire e utilizzare oggetti di database. ## Best practice Assicuratevi che il tipo di dati che create corrisponda ai campi di tipo inclusi nella funzione o procedura Oracle di origine. ## Epiche ### Esegui una funzione o una procedura Oracle con più di 100 argomenti | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea o identifica una Oracle/PLSQL funzione o una procedura esistente con più di 100 argomenti. | Create una Oracle/PLSQL funzione o una procedura con più di 100 argomenti.oppureIdentifica una Oracle/PLSQL funzione o una procedura esistente con più di 100 argomenti.Per ulteriori informazioni, vedere le sezioni [14.7 CREATE FUNCTION Statement](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-FUNCTION-statement.html#GUID-B71BC5BD-B87C-4054-AAA5-213E856651F2) e [14.11 CREATE PROCEDURE Statement nella documentazione](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-PROCEDURE-statement.html#GUID-5F84DB47-B5BE-4292-848F-756BF365EC54) del database Oracle. | Conoscenza di Oracle/PLSQL | | Compilare la funzione o la procedura. Oracle/PLSQL | Compilare la Oracle/PLSQL funzione o la procedura.Per ulteriori informazioni, vedere [Compilazione di una funzione](https://docs.oracle.com/cd/E37097_01/doc.42/e35128/GUID-6B7B6F82-616D-4915-82BE-D4AE7F59CF37.htm#AEUTL165) nella documentazione di Oracle Database. | Conoscenza di Oracle/PLSQL | | Esegui la funzione. Oracle/PLSQL | Esegui la Oracle/PLSQL funzione o la procedura. Quindi, salvate l'output. | Conoscenza di Oracle/PLSQL | ### Definire un nuovo tipo di dati che corrisponda agli argomenti della funzione o della procedura di origine | Operazione | Description | Competenze richieste | | --- | --- | --- | | Definisci un nuovo tipo di dati in PostgreSQL. | Definisci un nuovo tipo di dati in PostgreSQL che includa tutti gli stessi campi che compaiono negli argomenti della funzione o della procedura Oracle di origine.Per ulteriori informazioni, vedere [CREATE TYPE nella documentazione di](https://www.postgresql.org/docs/current/sql-createtype.html) PostgreSQL. | Conoscenza di PostgreSQL PL/pgSQL | ### Crea una funzione PostgreSQL che includa il nuovo argomento TYPE | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una funzione PostgreSQL che includa il nuovo tipo di dati. | Crea una funzione PostgreSQL che includa il nuovo argomento. `TYPE`Per esaminare una funzione di esempio, consulta la sezione **Informazioni aggiuntive** di questo modello. | Conoscenza di PostgreSQL PL/pgSQL | | Compila la funzione PostgreSQL. | Compila la funzione in PostgreSQL. Se i nuovi campi del tipo di dati corrispondono agli argomenti della funzione o della procedura di origine, la funzione viene compilata correttamente. | Conoscenza di PostgreSQL PL/pgSQL | | Esegui la funzione PostgreSQL. | Esegui la funzione PostgreSQL. | Conoscenza di PostgreSQL PL/pgSQL | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | La funzione restituisce il seguente errore:**ERRORE: errore di sintassi vicino a ""**
hdbnsutil -sr_enable --name=siteA| Amministrazione SAP Basis | | Registrare il database SAP HANA di destinazione come sistema secondario. | **Per registrare il database SAP HANA di destinazione come sistema secondario di origine per SAP HSR, scegli la replica asincrona.**
(sid)adm $> HDB stopIn alternativa, puoi scegliere l'opzione di registrazione. `–online` In tal caso, non è necessario arrestare e avviare il database SAP HANA. | Amministrazione SAP Basis | | Convalida la sincronizzazione. | Sul DB SAP HANA di origine, verifica che tutti i log siano applicati al sistema di destinazione (poiché si tratta di una replica asincrona).Per verificare la replica, esegui i seguenti comandi sull'origine.
(sid)adm $> hdbnsutil -sr_register –name=siteB –remotehost=hdbhost /
--remoteInstance=00 –replicationMode=async –operationMode=logreplay
(sid)adm $> HDB start
(sid)adm $> cdpy| Amministrazione SAP Basis | | Chiudi l'applicazione SAP di origine e SAP HANA DB. | Durante il cutover della migrazione, esegui uno spegnimento del sistema di origine (l'applicazione SAP e il database SAP HANA). | Amministrazione di SAP Basis | | Effettua un'acquisizione sull'obiettivo. | Per eseguire un'acquisizione sulla destinazione su AWS, esegui il comando`hdbnsutil -sr_takeover`. | Amministrazione SAP Basis | | Sul DB SAP HANA di destinazione, disattiva la replica. | Per cancellare i metadati di replica, interrompi la replica sul sistema di destinazione eseguendo il comando. `hdbnsutil -sr_disable` Ciò è conforme alla nota SAP 2693441: impossibile rinominare un sistema SAP HANA a causa di un errore. | Amministrazione SAP Basis | | Esegui il backup del database SAP HANA di destinazione. | Una volta completata con successo l'acquisizione, consigliamo di eseguire un backup completo di SAP HANA DB. | Amministrazione SAP Basis | ### Ripristina il nome host originale nel sistema di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Ripristina il nome host SAP HANA DB di destinazione all'originale. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.html)Puoi convalidare altre opzioni secondo necessità. Tuttavia, assicuratevi di non confondere la ridenominazione dell'host con una modifica del SID (Nota SAP 2598814 — hdblcm: la ridenominazione SID fallisce). | Amministrazione SAP Basis | | Regola hdbuserstore. | Adatta i `hdbuserstore` dettagli puntando ai dettagli della fonte. `schema/user` Per i passaggi dettagliati, consulta la documentazione [SAP.](https://help.sap.com/viewer/b3ee5778bc2e4a089d3299b82ec762a7/2.0.02/en-US/ddbdd66b632d4fe7b3c2e0e6e341e222.html?q=hdbuserstore) Per convalidare questo passaggio, esegui il comando. `R3trans -d` Il risultato dovrebbe riflettere una connessione riuscita al database SAP HANA. | Amministrazione SAP Basis | | Avvia le connessioni client. | Nell'ambiente di destinazione, avvia i server delle applicazioni SAP e altre connessioni client. | Amministrazione SAP Basis | ## Risorse correlate **Riferimenti SAP** I riferimenti alla documentazione SAP vengono aggiornati frequentemente da SAP. Per rimanere aggiornato, consulta la nota SAP 2407186 — Guide pratiche e white paper per SAP HANA High Availability. *Note SAP aggiuntive* + 2550327 — Come rinominare un sistema SAP HANA + 1999880 — Domande frequenti: replica del sistema SAP HANA + 2078425 — Nota sulla risoluzione dei problemi per lo strumento di gestione del ciclo di vita della piattaforma SAP HANA hdblcm + 2592227 — Modifica del suffisso FQDN nei sistemi HANA + 2048681 — Esecuzione di attività di amministrazione della gestione del ciclo di vita della piattaforma SAP HANA su sistemi con più host senza SSH o credenziali root *Documenti SAP* + [Connessione di rete per la replica del sistema](https://help.sap.com/docs/SAP_HANA_PLATFORM/4e9b18c116aa42fc84c7dbfd02111aba/47190b425eb1433697b026ecd46ff5f9.html) + [Risoluzione dei nomi host per la replica del sistema](https://help.sap.com/viewer/eb3777d5495d46c5b2fa773206bbfb46/1.0.12/en-US/c0cba1cb2ba34ec89f45b48b2157ec7b.html) **AWS riferimenti** + [Migrazione di SAP HANA da altre piattaforme a AWS](https://docs.aws.amazon.com/sap/latest/sap-hana/migrating-hana-hana-to-aws.html) ## Informazioni aggiuntive Le modifiche eseguite da nell'`hdblcm`ambito dell'attività di ridenominazione del nome host vengono consolidate nel seguente registro dettagliato. ![\[Codice che mostra i processi interrotti su temp-host, a partire da hdbhost e il sistema SAP HANA DB è stato rinominato.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/004781c1-96df-43dd-a52e-ed1db5bdf9ef/images/9e0c11ca-6555-484f-9639-107f60f725f5.png) # Esegui la migrazione del gruppo di disponibilità Microsoft SQL Server Always On utilizzando AWS Application Migration Service *Sreenivas Nettem, Bharath Kumar Pammi Ramesh, Anantharaman Seshadri e Gireesh Sreekantan, Amazon Web Services* ## Riepilogo AWS Application Migration Service (AWS MGN) è lo strumento preferito per il rehosting degli ambienti esistenti in, che consente ai clienti di abbandonare i data center locali. Cloud AWS Questo modello descrive il processo di utilizzo di AWS MGN per migrare i cluster Windows con i gruppi di disponibilità Always On di Microsoft SQL Server. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo. Account AWS + Un ruolo AWS Identity and Access Management (IAM) per l'orchestrazione di AWS MGN. + Accesso ai server di database di origine (gruppo di disponibilità SQL Server Always On). + Active Directory in una AWS landing zone per conservare i nomi DNS. + Una sottorete temporanea con comunicazione di rete chiusa con Active Directory. + Le sottoreti di destinazione sono in grado di comunicare con Active Directory. + Due indirizzi IP riservati per il cluster Windows in una sottorete di destinazione (uno in ogni zona di disponibilità). + Due indirizzi IP riservati per il listener SQL Always On in una sottorete di destinazione (uno in ogni zona di disponibilità). **Versioni del prodotto** + Windows Server 2012 o versioni successive + SQL Server 2012 o versione successiva ## Architecture **Stack tecnologico di origine** Cluster Microsoft Windows (macchina fisica o virtuale locale) Gruppo di disponibilità Microsoft SQL Server Always On **Stack tecnologico Target** Istanza Amazon EC2 Windows **Architettura Target** ![\[Architettura AWS per la migrazione della disponibilità di SQL Server Always On utilizzando AWS MGN.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/aa94040b-5ecf-42f9-90e3-929d0fa5e715/images/0b85c613-51df-475b-9598-3da3f9cd47c6.png) ## Tools (Strumenti) *Servizi AWS* + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornisce capacità di elaborazione scalabile in. Cloud AWS Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente. + [AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html)ti aiuta a riospitare (lift and shift) le applicazioni Cloud AWS senza modifiche e con tempi di inattività minimi. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle. *Altri strumenti* + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) è uno strumento per la gestione di SQL Server, che include l'accesso, la configurazione e l'amministrazione dei componenti di SQL Server. ## Best practice [Per AWS MGN, consulta Best practice for. AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/best_practices_mgn.html) ## Epiche ### Prepara l'account di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Inizializza AWS MGN. | Inizializza AWS MGN nella destinazione. Regione AWS Questo crea i ruoli e le politiche IAM richiesti. Per ulteriori informazioni, consulta [Inizializzazione del servizio di migrazione delle applicazioni con la console](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialize-console.html). | Amministratore cloud | | Crea modelli di replica e avvia. | Configura i modelli di replica e avvio da utilizzare con AWS MGN. Per ulteriori informazioni, vedete [Configurazione dei modelli nella documentazione](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialization-templates.html). AWS | Amministratore cloud | | Consenti le porte di comunicazione. | Per abilitare le comunicazioni di rete per AWS MGN, consenti il traffico sulle porte TCP 443 e 1500. Per ulteriori informazioni, consulta [i requisiti di rete per il servizio di migrazione delle applicazioni nella documentazione](https://docs.aws.amazon.com/mgn/latest/ug/Network-Requirements.html). AWS | Amministratore cloud, amministratore di rete | ### Preparare il server di origine | Operazione | Description | Competenze richieste | | --- | --- | --- | | Verifica i prerequisiti AWS MGN. | Verificate che i server di origine soddisfino i prerequisiti per l'installazione dell'agente AWS MGN. Per ulteriori informazioni, consultate [Requisiti di installazione](https://docs.aws.amazon.com/mgn/latest/ug/installation-requirements.html) nella AWS documentazione. | Tecnico di migrazione | | Installa l'agente AWS MGN. | Installa l'agente AWS MGN sui server di origine. Durante l'installazione, scegliete Regione AWS dove migrare i server. Dopo l'installazione, l'agente comunica con il servizio e avvia la replica. Per ulteriori informazioni, vedere [Installazione dell'agente di AWS replica sui server Windows](https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html). | Ingegnere della migrazione | | Controlla lo stato del server di origine. | Nella console AWS MGN, controllate lo stato dei server di origine. All'inizio della replica, sui server viene visualizzato il messaggio **Pronto per il test**.In caso di errori, vedere [Risoluzione degli errori di comunicazione nella documentazione](https://docs.aws.amazon.com/mgn/latest/ug/Troubleshooting-Communication-Errors.html) di AWS MGN. | Amministratore del cloud, tecnico addetto alla migrazione | | Ottimizza le impostazioni di replica. | I cluster SQL Always On utilizzano una replica I/O sincrona elevata dal server primario al server secondario. Per ottimizzare la replica ed evitare ritardi, utilizza un server di [replica dedicato per ogni server](https://docs.aws.amazon.com/mgn/latest/ug/replication-settings-template.html) SQL Always On.**Se il database è superiore a 5 TB, valuta la possibilità di scegliere un'istanza del server di replica di dimensioni maggiori, ad esempio **m5.large**, anziché la t3.small predefinita.** | Amministratore del cloud, ingegnere addetto alla migrazione | | Aggiorna il modello di lancio. | Aggiorna le [impostazioni di avvio](https://docs.aws.amazon.com/mgn/latest/ug/launch-settings.html) e scegli le sottoreti per i server SQL Always On. I server del cluster SQL Always On sono distribuiti su diversi server AWS Zone di disponibilità per garantire un'elevata disponibilità. | Ingegnere addetto alla migrazione, responsabile della migrazione | | Aggiorna le impostazioni di avvio. | In base ai requisiti di dimensioni e prestazioni, aggiorna il tipo di istanza e input/output le operazioni al secondo (IOPS) nelle impostazioni di avvio.(Facoltativo) Scegli un'interfaccia elastic network esistente nelle impostazioni di avvio. | Ingegnere addetto alla migrazione, responsabile della migrazione | ### Cutover di prova | Operazione | Description | Competenze richieste | | --- | --- | --- | | Verifica i server di origine. | Nella console AWS MGN, verificate che lo stato del server di origine sia **Pronto per il test**. | Amministratore del cloud, ingegnere addetto alla migrazione | | Avvia le istanze di test. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Amministratore cloud, ingegnere addetto alla migrazione | | Test di connettività e integrità del database. | Verifica la connettività e l'integrità del database delle istanze di test. Quindi contrassegna i server di origine come **Ready for cutover nella console** AWS MGN. | Amministratore cloud, ingegnere addetto alla migrazione | ### Attività preliminari alla migrazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Verifica l'integrità del database. | Questo aiuta a garantire che non vi siano problemi di integrità del database all'origine prima della migrazione. Esegui `DBCC CHECKDB` e specifica`WITH_PHYSICAL_ONLY`. L'esecuzione di questo controllo senza autorizzazione `WITH_PHYSICAL_ONLY` può causare problemi di prestazioni all'origine. Per mantenere l'integrità del database, esegui un controllo completo settimanale del database.Questi comandi controllano l'integrità logica e fisica del database rilevando potenziali problemi di danneggiamento. Il controllo verifica la struttura del database, ad esempio pagine, righe, indici e tabelle di sistema. | Ingegnere dei dati, DBA | | Verifica le connessioni ai server collegati. | Verifica le connessioni tra tutti i server esistenti e documenta il loro stato. Questo aiuta a garantire che i server collegati funzionino come previsto dopo la migrazione. | Ingegnere dei dati, DBA | | Verifica i backup. | Conferma l'integrità dei backup di origine. | Ingegnere dei dati, DBA | ### AWS Cutover MGN | Operazione | Description | Competenze richieste | | --- | --- | --- | | Arresta SQL Server e i servizi del cluster. | Arresta i servizi cluster SQL Server e Microsoft su tutti i nodi del cluster SQL. | DBA, ingegnere addetto alla migrazione | | Verifica i server. | **Nella console AWS MGN, verificate che lo stato dei server di origine sia **Pronto per il cutover** e che lo stato della replica dei dati sia Integrato.** | Ingegnere della migrazione | | Avvia il cutover. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html)Per ulteriori informazioni, vedete [Avvio di un'istanza cutover](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html) nella documentazione di MGN. AWS | Ingegnere della migrazione | | Prova i server lanciati. | Accedi alle EC2 istanze Amazon avviate e convalida lo stato del cluster. Verifica che i server si trovino nelle sottoreti corrette, che le dimensioni dell'istanza e le impostazioni IOPS siano corrette e che il server di controllo sia accessibile. | DBA, ingegnere addetto alla migrazione | ### Attività successive all'installazione del database | Operazione | Description | Competenze richieste | | --- | --- | --- | | Aggiorna l'indirizzo IP del cluster. | Aggiorna l'indirizzo IP del cluster per il cluster Windows utilizzando i due indirizzi IP riservati nelle sottoreti di destinazione. Per ulteriori informazioni, vedere [Modifica dell'indirizzo IP di un'istanza del cluster di failover](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/change-the-ip-address-of-a-failover-cluster-instance?view=sql-server-2016). | DBA, ingegnere addetto alla migrazione | | Aggiorna il listener IPs del gruppo di disponibilità Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, ingegnere addetto alla migrazione | | Verifica la connessione. | Utilizzando SSMS, connettiti al listener del gruppo di disponibilità Always On e conferma che la connessione abbia esito positivo. | DBA, ingegnere addetto alla migrazione | | Verifica lo stato del gruppo di disponibilità Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, ingegnere addetto alla migrazione | | Controlla il registro degli errori. | Aprire il log degli errori e verificare gli eventuali errori segnalati per l'istanza di SQL Server. Assicurarsi che il ripristino sia completo per tutti i database. | DBA, ingegnere addetto alla migrazione | | Prova i server collegati. | Verifica la connettività di tutti i server collegati. In caso di problemi di connettività, assicurati che il server e la porta di destinazione siano accessibili. | DBA, ingegnere addetto alla migrazione | ### Finalizza il cutover | Operazione | Description | Competenze richieste | | --- | --- | --- | | Finalizza il cutover. | Dopo aver convalidato i cluster SQL Always On di destinazione, [finalizza il cutover tramite la console](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html#revert-finalize-cutover-gs) MGN. AWS In questo modo si interrompe la replica dei dati dai server di origine e si eliminano i dati dal server di replica. Rimuove inoltre il server di replica e le risorse associate. | Amministratore del cloud, ingegnere addetto alla migrazione | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | AWS Risoluzione dei problemi MGN | Per problemi e risoluzioni comuni, consultate le sezioni [Risoluzione dei problemi](https://docs.aws.amazon.com/mgn/latest/ug/troubleshooting.html) e [Domande frequenti](https://docs.aws.amazon.com/mgn/latest/ug/FAQ.html) nella documentazione di AWS MGN. | ## Risorse correlate *AWS resources* + [Opzione 1 Rehost - () AWS Application Migration ServiceAWS](https://catalog.us-east-1.prod.workshops.aws/workshops/c6bdf8dc-d2b2-4dbd-b673-90836e954745/en-US/04-application-migration/01-mgn) + [Che cos'è? AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html) *Risorse SQL Server* + [Che cos'è SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) ## Informazioni aggiuntive Per i requisiti di sicurezza standard per la migrazione dei carichi di lavoro a Cloud AWS, consulta le [migliori pratiche per la sicurezza, l'identità e la conformità sul sito Web](https://aws.amazon.com/architecture/security-identity-compliance/). AWS # Esegui la migrazione di SQL Server su AWS utilizzando gruppi di disponibilità distribuiti *Praveen Marthala, Amazon Web Services* ## Riepilogo I gruppi di disponibilità Always On di Microsoft SQL Server forniscono una soluzione ad alta disponibilità (HA) e disaster recovery (DR) per SQL Server. Un gruppo di disponibilità è costituito da una replica primaria che accetta read/write traffico e fino a otto repliche secondarie che accettano traffico di lettura. Un gruppo di disponibilità è configurato su un Windows Server Failover Cluster (WSFC) con due o più nodi. I gruppi di disponibilità distribuita Microsoft SQL Server Always On forniscono una soluzione per configurare due gruppi di disponibilità separati tra due indipendenti WFSCs. I gruppi di disponibilità che fanno parte del gruppo di disponibilità distribuita non devono necessariamente trovarsi nello stesso data center. Un gruppo di disponibilità può essere locale e l'altro gruppo di disponibilità può trovarsi su istanze Amazon Web Services (AWS) Cloud su Amazon Elastic Compute Cloud (Amazon EC2) in un dominio diverso. Questo modello descrive i passaggi per l'utilizzo di un gruppo di disponibilità distribuito per migrare i database SQL Server locali che fanno parte di un gruppo di disponibilità esistente a SQL Server con gruppi di disponibilità configurati su Amazon. EC2 Seguendo questo schema, puoi migrare i database sul cloud AWS con tempi di inattività minimi durante il cutover. I database sono altamente disponibili su AWS subito dopo il cutover. Puoi anche utilizzare questo modello per modificare il sistema operativo sottostante da locale ad AWS mantenendo la stessa versione di SQL Server. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + AWS Direct Connect o AWS Site-to-Site VPN + La stessa versione di SQL Server installata in locale e sui due nodi di AWS **Versioni del prodotto** + SQL Server versione 2016 e successive + SQL Server Enterprise Edition ## Architecture **Stack tecnologico di origine** + Database Microsoft SQL Server con gruppi di disponibilità Always On locali **Stack tecnologico Target** + Database Microsoft SQL Server con gruppi di disponibilità Always On EC2 su Amazon sul cloud AWS **Architettura di migrazione** ![\[SQL Server con replica sincrona in gruppi di disponibilità in locale e su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/6e229e30-9b11-4ccb-bccd-cbe6601139c0/images/79ee7911-d68f-4db7-9b94-113dcf09c28b.png) *Terminologia* + WSFC 1: WSFC locale + WSFC 2 — WSFC sul cloud AWS + AG 1 — Primo gruppo di disponibilità, che si trova in WSFC 1 + AG 2 — Secondo gruppo di disponibilità, che si trova nel WSFC 2 + Replica primaria di SQL Server: nodo in AG 1 considerato il principale globale per tutte le scritture + SQL Server forwarder: nodo in AG 2 che riceve i dati in modo asincrono dalla replica primaria di SQL Server + Replica secondaria di SQL Server: nodi in AG 1 o AG 2 che ricevono dati in modo sincrono dalla replica primaria o dal server d'inoltro ## Tools (Strumenti) + [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html): AWS Direct Connect collega la rete interna a una posizione AWS Direct Connect tramite un cavo Ethernet standard in fibra ottica. Con questa connessione, puoi creare *interfacce virtuali* direttamente ai servizi AWS pubblici, aggirando i provider di servizi Internet nel tuo percorso di rete. + [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/concepts.html) — Amazon Elastic Compute Cloud (Amazon EC2) fornisce capacità di calcolo scalabile nel cloud AWS. Puoi usare Amazon EC2 per lanciare tutti o pochi server virtuali di cui hai bisogno, con scalabilità orizzontale o orizzontale. + [AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html): AWS Site-to-Site VPN supporta la creazione di una rete privata site-to-site virtuale (VPN). Puoi configurare la VPN per far passare il traffico tra le istanze che avvii su AWS e la tua rete remota. + [Microsoft SQL Server Management Studio](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms?view=sql-server-ver15) — Microsoft SQL Server Management Studio (SSMS) è un ambiente integrato per la gestione dell'infrastruttura SQL Server. Fornisce un'interfaccia utente e un gruppo di strumenti con editor di script avanzati che interagiscono con SQL Server. ## Epiche ### Configura un secondo gruppo di disponibilità su AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un WSFC su AWS. | Crea WSFC 2 su EC2 istanze Amazon con due nodi per HA. Utilizzerai questo cluster di failover per creare il secondo gruppo di disponibilità (AG 2) su AWS. | Amministratore di sistema, SysOps amministratore | | Creare il secondo gruppo di disponibilità su WSFC 2. | Utilizzando SSMS, crea AG 2 su due nodi in WSFC 2. Il primo nodo in WSFC 2 fungerà da server d'inoltro. Il secondo nodo di WSFC 2 fungerà da replica secondaria di AG 2.In questa fase, nessun database è disponibile in AG 2. Questo è il punto di partenza per configurare il gruppo di disponibilità distribuito. | DBA, Sviluppatore | | Crea database senza opzioni di ripristino su AG 2. | Esegui il backup dei database nel gruppo di disponibilità locale (AG 1). Ripristina i database sia sul server d'inoltro che sulla replica secondaria di AG 2 senza alcuna opzione di ripristino. Durante il ripristino dei database, specificate una posizione con spazio su disco sufficiente per i file di dati del database e i file di registro.In questa fase, i database sono in fase di ripristino. Non fanno parte di AG 2 o del gruppo di disponibilità distribuita e non si sincronizzano. | DBA, Sviluppatore | ### Configurare il gruppo di disponibilità distribuito | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea il gruppo di disponibilità distribuita su AG 1. | Per creare il gruppo di disponibilità distribuita su AG 1, utilizzare l'`DISTRIBUTED`opzione `CREATE AVAILABILITY GROUP` with.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Sviluppatore | | Crea il gruppo di disponibilità distribuita su AG 2. | Per creare il gruppo di disponibilità distribuita su AG 2, utilizzare `ALTER AVAILABILITY GROUP` con l'`DISTRIBUTED`opzione.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html)Il gruppo di disponibilità distribuito viene creato tra AG 1 e AG 2.I database di AG 2 non sono ancora configurati per partecipare al flusso di dati da AG 1 a AG 2. | DBA, Sviluppatore | | Aggiungi database al server d'inoltro e alla replica secondaria su AG 2. | Aggiungi i database al gruppo di disponibilità distribuito utilizzando l'`ALTER DATABASE``SET HADR``AVAILABILITY GROUP`opzione sia nel server d'inoltro che nella replica secondaria su AG 2. Ciò avvia il flusso di dati asincrono tra i database su AG 1 e AG 2. Il primario globale esegue le scritture, invia i dati in modo sincrono alla replica secondaria su AG 1 e invia i dati in modo asincrono al server d'inoltro su AG 2. Lo spedizioniere su AG 2 invia i dati in modo sincrono alla replica secondaria su AG 2. | DBA, Sviluppatore | ### Monitora il flusso di dati asincrono tra AG 1 e AG 2 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Utilizzo DMVs e registri di SQL Server. | Monitora lo stato del flusso di dati tra due gruppi di disponibilità utilizzando viste di gestione dinamiche (DMVs) e log di SQL Server. DMVs che sono interessanti per il monitoraggio includono `sys.dm_hadr_availability_replica_states` e`sys.dm_hadr_automatic_seeding`.Per lo stato della sincronizzazione del server d'inoltro, monitora *lo stato sincronizzato* nel registro di SQL Server sul server d'inoltro. | DBA, Sviluppatore | ### Esegui attività complementari per la migrazione finale | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi tutto il traffico verso la replica principale. | Blocca il traffico in entrata verso la replica principale in AG 1 in modo che non si verifichi alcuna attività di scrittura sui database e che i database siano pronti per la migrazione. | Proprietario dell'app, sviluppatore | | Modifica la modalità di disponibilità del gruppo di disponibilità distribuita su AG 1. | Nella replica principale, imposta la modalità di disponibilità del gruppo di disponibilità distribuita su sincrona. Dopo aver modificato la modalità di disponibilità in sincrona, i dati vengono inviati in modo sincrono dalla replica primaria in AG 1 al server d'inoltro in AG 2. | DBA, Sviluppatore | | Controlla LSNs in entrambi i gruppi di disponibilità. | Controlla gli ultimi numeri di sequenza di log (LSNs) sia in AG 1 che in AG 2. Poiché non viene eseguita alcuna scrittura nella replica primaria in AG 1, i dati sono sincronizzati e la durata LSNs per entrambi i gruppi di disponibilità deve corrispondere. | DBA, Sviluppatore | | Aggiorna AG 1 al ruolo secondario. | Quando aggiorni AG 1 al ruolo secondario, AG 1 perde il ruolo di replica principale e non accetta scritture e il flusso di dati tra due gruppi di disponibilità si interrompe. | DBA, Sviluppatore | ### Failover verso il secondo gruppo di disponibilità | Operazione | Description | Competenze richieste | | --- | --- | --- | | Failover manuale su AG 2. | Sul forwarder di AG 2, modificate il gruppo di disponibilità distribuita per consentire la perdita dei dati. Poiché avete già verificato e confermato che gli ultimi dati LSNs su AG 1 e AG 2 coincidono, la perdita di dati non è un problema.Quando si consente la perdita di dati sullo spedizioniere in AG 2, i ruoli di AG 1 e AG 2 cambiano:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Sviluppatore | | Modifica la modalità di disponibilità del gruppo di disponibilità distribuita su AG 2. | Sulla replica principale in AG 2, modifica la modalità di disponibilità in asincrona.Ciò modifica lo spostamento dei dati da AG 2 a AG 1, da sincrono a asincrono. Questo passaggio è necessario per evitare l'eventuale latenza di rete tra AG 2 e AG 1 e non influirà sulle prestazioni del database. | DBA, Sviluppatore | | Inizia a inviare traffico alla nuova replica primaria. | Aggiorna la stringa di connessione per utilizzare l'endpoint URL del listener su AG 2 per inviare traffico ai database.AG 2 ora accetta scritture e invia dati allo spedizioniere in AG 1, oltre all'invio di dati alla propria replica secondaria in AG 2. I dati vengono trasferiti in modo asincrono da AG 2 a AG 1. | Proprietario dell'app, sviluppatore | ### Esegui attività post-cutover | Operazione | Description | Competenze richieste | | --- | --- | --- | | Elimina il gruppo di disponibilità distribuita su AG 2. | Monitora la migrazione per il periodo di tempo pianificato. Quindi rilascia il gruppo di disponibilità distribuita su AG 2 per rimuovere la configurazione del gruppo di disponibilità distribuita tra AG 2 e AG 1. Ciò rimuove la configurazione del gruppo di disponibilità distribuito e il flusso di dati da AG 2 a AG 1 si interrompe. A questo punto, AG 2 è altamente disponibile su AWS, con una replica primaria che esegue scritture e una replica secondaria nello stesso gruppo di disponibilità. | DBA, Sviluppatore | | Disattiva i server locali. | Disattiva i server locali in WSFC 1 che fanno parte di AG 1. | Amministratore di sistema, amministratore SysOps | ## Risorse correlate + [Gruppi di disponibilità distribuiti](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-sql-server/distributed-groups.html) + [SQL Docs: gruppi di disponibilità distribuiti](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/distributed-availability-groups?view=sql-server-ver15) + [SQL Docs: Always On Availability Groups: una soluzione ad alta disponibilità e disaster recovery](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/always-on-availability-groups-sql-server?view=sql-server-ver15) # Migrare un database relazionale su MongoDB Atlas su AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Riepilogo Questo modello descrive i passaggi per la migrazione da un database relazionale come SQL Server, MySQL o PostgreSQL a MongoDB Atlas in. Cloud AWS Utilizza [MongoDB Relational Migrator per accelerare la migrazione dei dati dai database relazionali](https://www.mongodb.com/products/relational-migrator) a MongoDB Atlas. Il modello accompagna la guida [Migrating to MongoDB Atlas sul AWS sito web Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS Fornisce le fasi di implementazione per uno degli scenari di migrazione descritti in tale guida. Per ulteriori scenari di migrazione, consulta i seguenti modelli sul sito Web AWS Prescriptive Guidance: + [Migrare un ambiente MongoDB ospitato autonomamente su MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Trasmetti dati da IBM Db2, SAP, Sybase e altri database a MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Il modello è destinato ai [partner e agli utenti di AWS System Integrator (SI)](https://aws.amazon.com/managed-services/partners/). AWS ## Prerequisiti e limitazioni **Prerequisiti** + Un database relazionale di origine (Oracle Database, SQL Server, PostgreSQL, MySQL, SAP/Sybase ASE e altri) per la migrazione a MongoDB Atlas. + Familiarità con database relazionali, MongoDB Atlas e. Servizi AWS Questo modello spiega alcune delle fasi di migrazione ad alto livello. Ulteriori dettagli verranno aggiunti nelle versioni future. **Versioni del prodotto** + MongoDB versione 5.0 o successiva ## Architecture Il diagramma seguente mostra la migrazione da un database RDBMS (Relational Database Management System) a MongoDB Atlas on. AWS ![\[Architettura per la migrazione da RDBMS a MongoDB Atlas su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/4e3ea0f1-21e8-4641-a9ee-732355f20baf/images/8eacf3ec-f480-4912-9002-6a50800fe9bf.png) Per le architetture di riferimento di MongoDB Atlas che supportano diversi scenari di utilizzo, consulta [Migrating to MongoDB Atlas sul sito Web Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Guidance. AWS AWS ## Tools (Strumenti) + [MongoDB](https://www.mongodb.com/atlas) Atlas è un database come servizio DBaa (S) completamente gestito per l'implementazione e la gestione dei database MongoDB nel cloud. + [MongoDB Relational Migrator offre una transizione fluida dei dati dai database relazionali](https://www.mongodb.com/products/relational-migrator) tradizionali a MongoDB. Aiuta ad automatizzare il processo di conversione e trasforma il modello di dati strutturati dei database relazionali nel formato di documento flessibile fornito da MongoDB. Relational Migrator preserva l'integrità e le relazioni dei dati per semplificare la migrazione. Le organizzazioni possono sfruttare i vantaggi in termini di scalabilità, prestazioni e versatilità offerti da MongoDB, pur mantenendo la familiarità dei dati esistenti. ## Best practice [Per le migliori pratiche per l'utilizzo di MongoDB AWS su, consulta i post sul AWS blog di Partner Network.](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Epiche ### Scoperta e valutazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Determinare i parametri e le dimensioni del database relazionale. | Stima la dimensione del set di lavoro utilizzando i consigli e le informazioni di Relational Migrator `db.stats()` per lo spazio totale dell'indice. Si supponga che si acceda frequentemente a una percentuale dello spazio dati. Questa operazione dovrebbe richiedere circa una settimana. Per ulteriori informazioni ed esempi su questa e le altre storie di questa epopea, consulta la sezione [Risorse correlate](#migrate-relational-database-to-mongodb-atlas-resources). | Proprietario dell'app, DBA | | Stima dei requisiti di larghezza di banda della rete. | Per stimare i requisiti di larghezza di banda di rete, moltiplica la dimensione media dei documenti per il numero di documenti inviati al secondo. Considerate come base il traffico massimo che qualsiasi nodo del cluster sarà in grado di sopportare. Per calcolare le velocità di trasferimento dei dati a valle dal cluster alle applicazioni client, utilizza la somma del totale dei documenti restituiti in un periodo di tempo. Se le tue applicazioni leggono da nodi secondari, dividi questo numero di documenti totali per il numero di nodi che possono eseguire operazioni di lettura. Per trovare la dimensione media dei documenti per un database, utilizzate il `db.stats().avgObjSize` comando. Questa operazione richiede in genere un giorno. | DBA | | Seleziona il livello Atlas. | Segui le istruzioni nella documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) per selezionare il livello di cluster Atlas corretto. | DBA | | Piano di taglio. | Piano per il completamento dell'applicazione. | DBA, proprietario dell'app | ### Configura un nuovo ambiente MongoDB Atlas su AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un nuovo cluster MongoDB Atlas su. AWS | In MongoDB Atlas, **scegli** Crea un cluster. Nella finestra di dialogo **Crea nuovo cluster**, seleziona AWS come fornitore di servizi cloud. | DBA | | Configurazione Regioni AWS selettiva e globale del cluster. | Seleziona dall'elenco delle opzioni disponibili Regioni AWS per il tuo cluster Atlas. Se necessario, configura i cluster globali. | DBA | | Seleziona il livello del cluster. | Seleziona il livello di cluster preferito. La selezione del livello determina fattori come la memoria, lo storage e le specifiche IOPS. | DBA | | Configura impostazioni aggiuntive del cluster. | Configura impostazioni del cluster aggiuntive come la versione di MongoDB, il backup e le opzioni di crittografia. Per ulteriori informazioni su queste opzioni, consulta la sezione [Risorse correlate](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | ### Configura sicurezza e conformità | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura l'elenco di accesso. | Per connettersi al cluster Atlas, è necessario aggiungere una voce all'elenco di accesso del progetto. Atlas lo utilizza TLS/SSL per crittografare le connessioni al cloud privato virtuale (VPC) per il database. Per impostare la lista di accesso al progetto e per ulteriori informazioni sulle storie di questa epopea, consulta la sezione Risorse [correlate](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | | Autentica e autorizza gli utenti. | È necessario creare e autenticare gli utenti del database che accederanno ai cluster MongoDB Atlas. Per accedere ai cluster di un progetto, gli utenti devono appartenere a quel progetto e possono appartenere a più progetti. | DBA | | Crea ruoli personalizzati. | (Facoltativo) Atlas supporta la creazione di ruoli personalizzati nei casi in cui le autorizzazioni utente integrate nel database Atlas non coprono il set di autorizzazioni desiderato. | DBA | | Configura il peering VPC. | (Facoltativo) Atlas supporta il [peering VPC con altri dispositivi](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). VPCs AWS | Amministratore AWS | | Configura un AWS PrivateLink endpoint. | (Facoltativo) Puoi configurare endpoint privati utilizzando AWS . AWS PrivateLink Per ulteriori informazioni, consulta la documentazione di [Amazon VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) | Amministratore AWS | | Abilita l'autenticazione a due fattori. | (Facoltativo) Atlas supporta l'autenticazione a due fattori (2FA) per aiutare gli utenti a controllare l'accesso ai propri account Atlas. | Amministratore AWS | | Configura l'autenticazione e l'autorizzazione degli utenti con LDAP. | (Facoltativo) Atlas supporta l'esecuzione dell'autenticazione e dell'autorizzazione degli utenti con Lightweight Directory Access Protocol (LDAP). | DBA | | Configura l'accesso unificato AWS . | (Facoltativo) Alcune funzionalità di Atlas, tra cui Atlas Data Lake e la crittografia a riposo mediante la gestione delle chiavi dei clienti, utilizzano ruoli AWS Identity and Access Management (IAM) per l'autenticazione. | Amministratore AWS | | Configura la crittografia a riposo utilizzando AWS KMS. | (Facoltativo) Atlas supporta l'utilizzo di AWS Key Management Service (AWS KMS) per crittografare i motori di archiviazione e i backup dei provider di cloud. | Amministratore AWS | | Configura la crittografia a livello di campo lato client. | (Facoltativo) Atlas supporta la crittografia a livello di campo lato client, inclusa la crittografia automatica dei campi. | Amministratore AWS | ### Migrazione dei dati | Operazione | Description | Competenze richieste | | --- | --- | --- | | Aggiungi MongoDB Relational Migrator all'elenco di accesso. | Aggiungi Relational Migrator all'elenco di accesso per il tuo database di origine. Questo aiuta a preparare l'ambiente di origine per la connessione al cluster Atlas di destinazione. | DBA | | Valuta gli oggetti del database relazionale. | Avvia MongoDB Relational Migrator e connettiti al tuo database relazionale. Inizia la valutazione. | DBA | | Accetta i modelli di migrazione o scegli di modificarli in base alle tue esigenze aziendali. | Accetta i modelli di database consigliati da Relational Migrator in base alla valutazione iniziale e ai parametri prestazionali oppure scegli di modificarli in base ai requisiti aziendali. | DBA | | Avvia la replica di destinazione impostata in MongoDB Atlas. | Avvia la replica di destinazione impostata in MongoDB Atlas. **In Relational Migrator, scegli Sono pronto per la migrazione.** | DBA | ### Configurare l'integrazione operativa | Operazione | Description | Competenze richieste | | --- | --- | --- | | Connect al cluster MongoDB Atlas. | Assicurati che la connettività del cluster MongoDB Atlas funzioni come previsto. | Proprietario dell'app | | Interagisci con i dati del cluster. | Verifica i dati del cluster. | DBA | | Monitora i tuoi cluster. | Verifica che i cluster siano configurati correttamente. | DBA | | Eseguire il backup e il ripristino dei dati del cluster. | Pianifica i backup con una cadenza regolare per i dati del cluster. | DBA | ## Risorse correlate Tutti i seguenti collegamenti, se non diversamente specificato, portano alle pagine Web della documentazione di MongoDB. **Guida alla migrazione** + [Migrazione a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) on (Guida prescrittiva)AWS **Scoperta e valutazione** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Esempio di dimensionamento con set di dati di esempio Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Esempio di dimensionamento per applicazioni mobili](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Traffico di rete](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Scalabilità automatica del cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modello di dimensionamento Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurazione della sicurezza e della conformità** + [Configurazione delle voci dell'elenco di accesso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configura i ruoli personalizzati del database](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurare una connessione peering di rete](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Scopri di più sugli endpoint privati in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gestisci le tue opzioni di autenticazione a più fattori](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configura l'autenticazione e l'autorizzazione degli utenti con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Crittografia a riposo con Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Metodi per assumere un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentazione IAM) + [Crittografia a livello di campo lato client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Crittografia automatica](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Controlli di sicurezza MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Centro fiducia MongoDB](https://www.mongodb.com/cloud/trust) + [Configura le funzionalità di sicurezza per i cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configurazione di un nuovo ambiente MongoDB Atlas su **AWS**** + [Provider di cloud e regioni](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gestisci i cluster globali](https://docs.atlas.mongodb.com/global-clusters/) + [Seleziona il livello del cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configura impostazioni aggiuntive](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Inizia con Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migrazione dei dati** + [Migrazione o importazione dei dati](https://www.mongodb.com/docs/atlas/import/) **Cluster di monitoraggio** + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrazione delle operazioni** + [Connect a un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagisci con i tuoi dati](https://docs.atlas.mongodb.com/data-explorer/) + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Backup, ripristino e archiviazione dei dati](https://docs.atlas.mongodb.com/backup-restore-cluster/) # Migrare un ambiente MongoDB ospitato autonomamente su MongoDB Atlas su AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Riepilogo Questo modello descrive i passaggi per la migrazione da un ambiente MongoDB autogestito (incluso MongoDB Community Server, Enterprise Server, Enterprise Advanced, MLab o qualsiasi cluster MongoDB gestito) a MongoDB Atlas nel. Cloud AWS Utilizza il [servizio Atlas Live Migration](https://www.mongodb.com/cloud/atlas/migrate) per accelerare la migrazione dei dati da MongoDB a MongoDB Atlas. Il modello accompagna la guida [Migrating to MongoDB Atlas sul AWS sito web Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS Fornisce le fasi di implementazione per uno degli scenari di migrazione descritti in tale guida. Per ulteriori scenari di migrazione, consulta i seguenti modelli sul sito Web AWS Prescriptive Guidance: + [Migrare un database relazionale su MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) + [Trasmetti dati da IBM Db2, SAP, Sybase e altri database a MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Il modello è destinato ai partner e agli utenti di [AWS Systems Integrator](https://aws.amazon.com/managed-services/partners/) (SI). AWS ## Prerequisiti e limitazioni **Prerequisiti** + Un MongoDB Enterprise Advanced, Community Server di origine o altro ambiente MongoDB autogestito per la migrazione a MongoDB Atlas. + Familiarità con MongoDB, MongoDB Atlas e. Servizi AWS Questo modello spiega alcune delle fasi di migrazione ad alto livello. Ulteriori dettagli verranno aggiunti nelle versioni future. **Versioni del prodotto** + MongoDB versione 6.0.13 o successiva ## Architecture Il diagramma seguente mostra l'Atlas Live Migration Service utilizzato per migrare i dati da un database MongoDB Enterprise Advanced e da un database della comunità MongoDB a MongoDB Atlas on. AWS Utilizza questo servizio quando devi migrare database complessi e di grandi dimensioni su MongoDB Atlas con tempi di inattività minimi e sincronizzazione continua dei dati. Questo modello utilizza Atlas Live Migration Service. ![\[Migrazione dei dati con MongoDB Atlas Live Migration Service.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/372134c4-ba47-4e48-bd0d-8b43017773b8.png) Il diagramma seguente mostra il servizio mirror MongoDB `mongomirror` () che è possibile utilizzare anche per migrare i dati da un database MongoDB Enterprise Advanced e da un database della comunità MongoDB a MongoDB Atlas tramite una connessione protetta. AWS [AWS PrivateLink](https://aws.amazon.com/privatelink/) Utilizzalo `mongomirror` per la replica continua dei dati tra MongoDB locali e MongoDB Atlas. Questo strumento è ideale per il disaster recovery o le migrazioni a fasi, ma non rientra nell'ambito di questo modello. ![\[Migrazione dei dati con lo strumento mongomirror.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/53488a9b-2210-4b3d-b517-b618c1e0182c.png) Per ulteriori architetture di riferimento di MongoDB Atlas che supportano diversi scenari di utilizzo, consulta [Migrazione a MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas sul sito Web Prescriptive Guidance. AWS AWS ## Tools (Strumenti) + [MongoDB](https://www.mongodb.com/atlas) Atlas è un database as a service (DBaaS) completamente gestito per l'implementazione e la gestione di database MongoDB nel cloud. + [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) è un'utilità MongoDB gratuita che aiuta a migrare i database su Atlas. Questo servizio mantiene il database di origine sincronizzato con il database di destinazione fino al cutover. Quando si è pronti per il cutover, si interrompono le istanze dell'applicazione, le si indirizza al cluster Atlas di destinazione e le si riavvia. Per accedere a questo servizio, scegli **le opzioni del database** dal tuo cluster MongoDB Atlas. + [mongomirror](https://www.mongodb.com/docs/atlas/import/mongomirror/) è uno strumento per la migrazione manuale dei dati da un set di repliche MongoDB esistente a un set di repliche MongoDB Atlas. `mongomirror`non richiede la chiusura del set di repliche o delle applicazioni esistenti, non importa i dati degli utenti o dei ruoli né copia il database di configurazione. È possibile effettuare il download `mongomirror` dalla documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/import/mongomirror/#download-mongomirror). ## Best practice [Per le migliori pratiche per l'utilizzo di MongoDB AWS su, consulta i post sul AWS blog di Partner Network.](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Epiche ### Scoperta e valutazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Determina la dimensione del cluster. | Stimate la dimensione del set di lavoro utilizzando le informazioni fornite `db.stats()` per lo spazio totale dell'indice. Si supponga che si acceda frequentemente a una percentuale dello spazio dati. In alternativa, è possibile stimare i requisiti di memoria in base alle proprie ipotesi. Questa operazione dovrebbe richiedere circa una settimana. Per ulteriori informazioni ed esempi su questa e le altre storie di questa epopea, consulta la sezione [Risorse correlate](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA, proprietario dell'app | | Stima dei requisiti di larghezza di banda della rete. | Per stimare i requisiti di larghezza di banda di rete, moltiplica la dimensione media dei documenti per il numero di documenti inviati al secondo. Considerate come base il traffico massimo che qualsiasi nodo del cluster sarà in grado di sopportare. Per calcolare le velocità di trasferimento dei dati a valle dal cluster alle applicazioni client, utilizza la somma del totale dei documenti restituiti in un periodo di tempo. Se le tue applicazioni leggono da nodi secondari, dividi questo numero di documenti totali per il numero di nodi che possono eseguire operazioni di lettura. Per trovare la dimensione media dei documenti per un database, utilizzate il `db.stats().avgObjSize` comando. Questa operazione richiede in genere un giorno. | DBA | | Seleziona il livello Atlas. | Segui le istruzioni nella documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) per selezionare il livello di cluster Atlas corretto. | DBA | | Piano per il cutover. | Piano per il completamento dell'applicazione. | DBA, proprietario dell'app | ### Configura un nuovo ambiente MongoDB Atlas su AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un nuovo cluster MongoDB Atlas su. AWS | Accedi ad Atlas e apri la pagina **Panoramica** del tuo progetto. Scegli il pulsante **Crea** per creare un cluster. Per ulteriori informazioni, consulta la [ documentazione di MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). | DBA | | Configurazione Regioni AWS selettiva e globale del cluster. | Seleziona dall'elenco delle opzioni disponibili Regioni AWS per il tuo cluster Atlas. Se necessario, configura i cluster globali. Per ulteriori informazioni, consulta la [ documentazione di MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/#select-your-preferred-region.). | DBA | | Seleziona il livello del cluster. | Seleziona il tuo livello di cluster preferito. La selezione del livello determina fattori quali memoria, storage e specifiche IOPS. | DBA | | Configura impostazioni aggiuntive del cluster. | Configura impostazioni del cluster aggiuntive come la versione di MongoDB, il backup e le opzioni di crittografia. Per ulteriori informazioni su queste opzioni, consulta la sezione [Risorse correlate](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA | ### Configura sicurezza e conformità | Operazione | Description | Competenze richieste | | --- | --- | --- | | Autentica e autorizza gli utenti. | È necessario creare e autenticare gli utenti del database che accederanno ai cluster MongoDB Atlas. Per accedere ai cluster di un progetto, gli utenti devono appartenere a quel progetto e possono appartenere a più progetti. Atlas supporta anche l'autenticazione basata su AWS Identity and Access Management (IAM). Per ulteriori informazioni, consulta la [ documentazione di MongoDB](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam). | DBA | | Crea ruoli personalizzati. | (Facoltativo) Atlas supporta la creazione di ruoli personalizzati nei casi in cui le autorizzazioni utente integrate nel database Atlas non coprono il set di autorizzazioni desiderato. | DBA | | Configura il peering VPC. | (Facoltativo) Atlas supporta il [peering su cloud privato virtuale (VPC) con altri](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). VPCs AWS | Amministratore AWS | | Configura un AWS PrivateLink endpoint. | (Facoltativo) Puoi configurare endpoint privati utilizzando AWS . AWS PrivateLink Per ulteriori informazioni, consulta la documentazione di [Amazon VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) | Amministratore AWS | | Abilita l'autenticazione a due fattori. | (Facoltativo) Atlas supporta l'autenticazione a due fattori (2FA) per aiutare gli utenti a controllare l'accesso ai propri account Atlas. | Amministratore AWS | | Configura l'autenticazione e l'autorizzazione degli utenti con LDAP. | (Facoltativo) Atlas supporta l'esecuzione dell'autenticazione e dell'autorizzazione degli utenti con Lightweight Directory Access Protocol (LDAP). | Amministratore AWS | | Configura l' AWS accesso unificato. | (Facoltativo) Alcune funzionalità di Atlas, tra cui Atlas Data Lake e la crittografia a riposo mediante la gestione delle chiavi dei clienti, utilizzano i ruoli IAM per l'autenticazione. | Amministratore AWS | | Configura la crittografia a riposo utilizzando AWS KMS. | (Facoltativo) Atlas supporta l'utilizzo di AWS Key Management Service (AWS KMS) per crittografare i motori di archiviazione e i backup dei provider di cloud. | Amministratore AWS | | Configura la crittografia a livello di campo lato client. | (Facoltativo) Atlas supporta la crittografia a livello di campo lato client, inclusa la crittografia automatica dei campi. | Amministratore AWS | ### Migrazione dei dati | Operazione | Description | Competenze richieste | | --- | --- | --- | | Seleziona la replica di destinazione impostata in MongoDB Atlas. | Passa al cluster Atlas di destinazione e scegli il pulsante con i puntini di sospensione (...). Nell'elenco dei cluster, questo pulsante appare sotto il nome del cluster. Nei dettagli del cluster, il pulsante appare sulla destra, accanto ai pulsanti **Connect** e **Configuration**. Per ulteriori informazioni, consulta la [ documentazione di MongoDB](https://www.mongodb.com/docs/atlas/import/c2c-pull-live-migration/#procedure). | DBA | | Aggiungi Atlas Live Migration Service all'elenco di accesso. | Aggiungi Atlas Live Migration Service all'elenco di accesso nel cluster AWS di origine. Questo aiuta a preparare l'ambiente di origine per la connessione al cluster Atlas di destinazione. | DBA | | Esegui la migrazione con Atlas Live Migration Service. | Scegli **Avvia migrazione**. Quando il pulsante **Prepare to Cutover** diventa verde, esegui il cutover. Rivedi le metriche delle prestazioni del cluster Atlas. Prendi in considerazione l'aggiornamento della connessione al database in tutti i livelli dell'applicazione in modo che punti al nuovo database. | DBA | ### Configurare l'integrazione operativa | Operazione | Description | Competenze richieste | | --- | --- | --- | | Connect al cluster MongoDB Atlas. | Assicurati che la connettività del cluster MongoDB Atlas funzioni come previsto. | Proprietario dell'app | | Interagisci con i dati del cluster. | Esegui il test dei dati del cluster. | DBA | | Monitora i tuoi cluster. | Verifica che i cluster siano configurati correttamente. | DBA | | Eseguire il backup e il ripristino dei dati del cluster. | Pianifica i backup con una cadenza regolare per i dati del cluster. | DBA | ## Risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Errore: impossibile raggiungere la fonte specificata | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) | | Errore: impossibile risolvere il nome host | Non è stato trovato alcun indirizzo IP per il nome host specificato. Verifica che il nome host fornito sia corretto e accessibile pubblicamente. | | Qualsiasi altro errore | Se riscontri altri errori, consulta [Risoluzione dei problemi di Live Migration (Pull)](https://www.mongodb.com/docs/atlas/import/live-import-troubleshooting/) nella documentazione di MongoDB. | ## Risorse correlate Tutti i seguenti collegamenti, se non diversamente specificato, portano alle pagine Web della documentazione di MongoDB. **Guida alla migrazione** + [Migrazione a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) on (Guida prescrittiva)AWS **Migrazione legacy** + [Migrazione di versioni precedenti di MongoDB](https://www.mongodb.com/docs/atlas/legacy-migration/) **Scoperta e valutazione** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Esempio di dimensionamento con set di dati di esempio Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Esempio di dimensionamento per applicazioni mobili](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Traffico di rete](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Scalabilità automatica del cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modello di dimensionamento Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurazione della sicurezza e della conformità** + [Configurazione delle voci dell'elenco di accesso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configura i ruoli personalizzati del database](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurare una connessione peering di rete](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Scopri di più sugli endpoint privati in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gestisci le tue opzioni di autenticazione a più fattori](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configura l'autenticazione e l'autorizzazione degli utenti con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Crittografia a riposo con Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Metodi per assumere un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentazione IAM) + [Crittografia a livello di campo lato client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Crittografia automatica](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Controlli di sicurezza MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [MongoDB Trust Center](https://www.mongodb.com/cloud/trust) + [Configura le funzionalità di sicurezza per i cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configurazione di un nuovo ambiente MongoDB Atlas su **AWS**** + [Provider di cloud e regioni](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gestisci i cluster globali](https://docs.atlas.mongodb.com/global-clusters/) + [Seleziona il livello del cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configura impostazioni aggiuntive](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Inizia con Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migrazione dei dati** + [Migrazione o importazione dei dati](https://www.mongodb.com/docs/atlas/import/) **Cluster di monitoraggio** + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrazione delle operazioni** + [Connect a un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagisci con i tuoi dati](https://docs.atlas.mongodb.com/data-explorer/) + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Backup, ripristino e archiviazione dei dati](https://docs.atlas.mongodb.com/backup-restore-cluster/) **Addestramento** + [Migrazione in tempo reale con MongoDB Atlas](https://learn.mongodb.com/courses/live-migration-with-mongodb-atlas) ## Informazioni aggiuntive Per ulteriori informazioni, consulta i seguenti argomenti nella documentazione di MongoDB: + Per spostare i dati su un'istanza serverless, [usa Compass per esportare e importare dati o migrare i dati](https://www.mongodb.com/docs/compass/current/import-export/) con strumenti autogestiti. [Per ulteriori informazioni, consulta Limitazioni delle istanze Serverless.](https://www.mongodb.com/docs/atlas/reference/serverless-instance-limitations/) + Per caricare i dati in un nuovo cluster in Atlas, consulta [Caricare dati in Atlas](https://www.mongodb.com/docs/atlas/sample-data/#std-label-sample-data). + Per creare una copia del cluster a scopo di test, consulta [Metodi di backup per una distribuzione autogestita](https://www.mongodb.com/docs/manual/core/backups/). + Se l'applicazione che desideri migrare richiede un uptime quasi continuo, contatta il [supporto](https://www.mongodb.com/docs/atlas/support/#std-label-request-support) di MongoDB e condividi i tuoi requisiti di uptime e la configurazione del cluster. + [Per ulteriori informazioni, consulta Migrare o importare dati.](https://www.mongodb.com/docs/atlas/import/) # Esegui la migrazione di un database Oracle ad Amazon DynamoDB utilizzando AWS DMS *Rambabu Karnena, Amazon Web Services* ## Riepilogo Questo modello illustra i passaggi per la migrazione di un database Oracle ad [Amazon](https://aws.amazon.com/dynamodb/) DynamoDB utilizzando AWS Database Migration Service [(](https://aws.amazon.com/dms/)AWS DMS). Copre tre tipi di database di origine: + Database Oracle locali + Database Oracle su Amazon Elastic Compute Cloud ([Amazon EC2](https://aws.amazon.com/ec2/)) + Amazon Relational Database Service ([Amazon](https://aws.amazon.com/rds/) RDS) per istanze database Oracle In questa dimostrazione di concetto, questo modello si concentra sulla migrazione da un'istanza DB Amazon RDS for Oracle. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un'applicazione che si connette a un database Amazon RDS for Oracle + Una tabella creata nel database Amazon RDS for Oracle di origine con una chiave primaria e dati di esempio **Limitazioni** + Gli oggetti del database Oracle, come procedure, funzioni, pacchetti e trigger, non vengono presi in considerazione per la migrazione perché Amazon DynamoDB non supporta questi oggetti di database. **Versioni del prodotto** + Questo modello si applica a tutte le edizioni e versioni dei database Oracle supportate da AWS DMS. Per ulteriori informazioni, consulta Utilizzo di un [database Oracle come origine per AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) e utilizzo di [un database Amazon DynamoDB come destinazione](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) per AWS DMS. Ti consigliamo di utilizzare le versioni più recenti di AWS DMS per il supporto di versioni e funzionalità più completo. ## Architecture **Stack tecnologico di origine** + Amazon RDS per istanze DB Oracle, Oracle su EC2 Amazon o database Oracle locali **Stack tecnologico Target** + Amazon DynamoDB **Architettura di migrazione dei dati AWS** ![\[I dati vengono trasferiti da Oracle DB ad AWS DMS ad Amazon DynamoDB.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/463fc7d4-ec8d-473b-8c7f-1df31800ee03/images/180e7340-3887-455d-a591-b5850e22770a.png) ## Tools (Strumenti) + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ti aiuta a migrare gli archivi di dati nel cloud AWS o tra combinazioni di configurazioni cloud e locali. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale nel cloud AWS. Questo modello utilizza Amazon RDS for Oracle. ## Epiche ### Pianifica la migrazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un VPC. | Nel tuo account AWS, crea un cloud privato virtuale (VPC) e una sottorete privata. | Amministratore di sistema | | Crea gruppi di sicurezza ed elenchi di controllo degli accessi alla rete. | Per ulteriori informazioni, consulta la [documentazione di AWS](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html). | Amministratore di sistema | | Configura e avvia l'istanza DB di Amazon RDS for Oracle. | Per ulteriori informazioni, consulta la [documentazione di AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). | DBA, amministratore di sistema | ### Migrazione dei dati | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un ruolo IAM per accedere a DynamoDB. | Nella console AWS Identity and Access Management (IAM), crea il ruolo, allega la policy `AmazonDynamoDBFullAccess to it` e seleziona AWS DMS come servizio. | Amministratore di sistema | | Crea un'istanza di replica AWS DMS per la migrazione. | L'istanza di replica deve trovarsi nella stessa zona di disponibilità e nello stesso VPC del database di origine. | Amministratore di sistema | | Crea endpoint di origine e destinazione in AWS DMS. | Per creare l'endpoint del database di origine, hai due opzioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)Per creare l'endpoint del database di destinazione, scegli il ruolo Amazon Resource Name (ARN) dal task precedente per accedere a DynamoDB. | Amministratore di sistema | | Crea un task AWS DMS per caricare le tabelle del database Oracle di origine su DynamoDB. | Scegli i nomi degli endpoint di origine e destinazione e l'istanza di replica dai passaggi precedenti. Il tipo può essere a pieno carico. Scegli lo schema Oracle e specifica**%** per selezionare tutte le tabelle. | Amministratore di sistema | | Convalida le tabelle in DynamoDB. | Per visualizzare i risultati della migrazione, scegli **Tabelle** dal riquadro di navigazione a sinistra nella console DynamoDB. | DBA | ### Migrare l'applicazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Modifica il codice dell'applicazione. | Per connetterti e recuperare dati da DynamoDB, aggiorna il codice dell'applicazione. | Proprietario dell'app, DBA, amministratore di sistema | ### Tagliare | Operazione | Description | Competenze richieste | | --- | --- | --- | | Cambia i client dell'applicazione per utilizzare DynamoDB. | | DBA, proprietario dell'app, amministratore di sistema | ### Chiudi il progetto | Operazione | Description | Competenze richieste | | --- | --- | --- | | Chiudi le risorse AWS. | Ad esempio, chiudono l'istanza Amazon RDS for Oracle, DynamoDB e l'istanza di replica AWS DMS. | DBA, amministratore di sistema | | Raccogli le metriche. | Le metriche includono il tempo necessario per la migrazione, le percentuali del lavoro manuale e del lavoro svolto dallo strumento e i risparmi sui costi. | DBA, proprietario dell'app, amministratore di sistema | ## Risorse correlate + [AWS Database Migration Service e Amazon DynamoDB: cosa devi sapere](https://aws.amazon.com/blogs/database/aws-database-migration-service-and-amazon-dynamodb-what-you-need-to-know/) (post sul blog) + [Utilizzo di un database Oracle come sorgente per AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) + [Utilizzo di un database Amazon DynamoDB come destinazione per AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) + [Best practice per la migrazione da RDBMS ad Amazon DynamoDB (white paper)](https://docs.aws.amazon.com/whitepapers/latest/best-practices-for-migrating-from-rdbms-to-dynamodb/welcome.html) # Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for Oracle utilizzando AWS DMS SharePlex *Ramu Jagini, Amazon Web Services* ## Riepilogo Questo modello descrive come migrare un database Oracle 8i o 9i locale a un database Amazon Relational Database Service (Amazon RDS) per Oracle. Puoi utilizzare questo modello per completare la migrazione con tempi di inattività ridotti utilizzando Quest per la replica sincrona. SharePlex È necessario utilizzare un'istanza di database Oracle intermedia per la migrazione perché AWS Database Migration Service (AWS DMS) non supporta Oracle 8i o 9i come ambiente di origine. Puoi utilizzare la versione [SharePlex 7.6.3](https://www.quest.com/community/shareplex/f/forum/20700/where-can-download-7-6-3-or-support-9i-shareplex) per eseguire la replica da versioni precedenti del database Oracle a versioni successive del database Oracle. L'istanza intermedia del database Oracle è compatibile come destinazione per la versione SharePlex 7.6.3 e supportata come origine per AWS DMS o versioni più recenti di. SharePlex Questo supporto consente la replica successiva dei dati nell'ambiente di destinazione Amazon RDS for Oracle. Tieni presente che diversi tipi di dati e funzionalità obsoleti possono influire sulla migrazione da Oracle 8i o 9i alla versione più recente di Oracle Database. Per mitigare questo impatto, questo modello utilizza Oracle 11.2.0.4 come versione intermedia del database per aiutare a ottimizzare il codice dello schema prima della migrazione all'ambiente di destinazione Amazon RDS for Oracle. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un database Oracle 8i o 9i di origine in un ambiente locale + [Oracle Database 12c Release 2](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/index.html) (12CR2) per lo staging su Amazon Elastic Compute Cloud (Amazon) EC2 + Quest SharePlex 7.6.3 (livello commerciale) **Limitazioni** + [Limitazioni di RDS per Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Oracle.Concepts.limitations.html) **Versioni del prodotto** + Oracle 8i o 9i per il database di origine + Oracle 12 CR2 per il database dell'area di gestione temporanea (deve corrispondere alla versione di Amazon RDS for Oracle) + Oracle 12 CR2 o versione successiva per il database di destinazione (Amazon RDS for Oracle) ## Architecture **Stack tecnologico di origine** + Database Oracle 8i o 9i + SharePlex **Stack tecnologico Target** + Amazon RDS per Oracle **Architettura di migrazione** Il diagramma seguente mostra come migrare un database Oracle 8i o 9i da un ambiente locale a un'istanza DB Amazon RDS for Oracle nel cloud AWS. ![\[Flusso di lavoro per la migrazione di un database Oracle locale ad Amazon RDS su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/6e07d586-fd74-4f3d-8e81-79dd55c445c3/images/36e1a5ff-908b-4cb7-96f7-997eb105f1d6.png) Il diagramma mostra il flusso di lavoro seguente: 1. Abilita il database di origine Oracle con la modalità di registro degli archivi, la registrazione forzata e la registrazione supplementare. 1. [Ripristina il database di gestione temporanea Oracle dal database di origine Oracle utilizzando il ripristino di Recovery Manager (RMAN) e FLASHBACK\$1SCN. point-in-time](https://docs.oracle.com/database/121/SUTIL/GUID-D408B112-1A81-4F68-BEFF-7403A9588DDB.htm#SUTIL849) 1. SharePlex Configurare per leggere i redo log dal database di origine Oracle utilizzando (utilizzato in RMAN). `FLASHBACK_SCN` 1. Avvia SharePlex la replica per sincronizzare i dati dal database di origine Oracle al database di gestione temporanea Oracle. 1. Ripristina il database di destinazione Amazon RDS for Oracle utilizzando EXPDP e IMPDP con. `FLASHBACK_SCN` 1. Configura AWS DMS e le relative attività di origine come database di staging Oracle e Amazon RDS for Oracle come database di destinazione utilizzando `FLASHBACK_SCN` (utilizzato in EXPDP). 1. Avvia le attività di AWS DMS per sincronizzare i dati dal database di staging Oracle al database di destinazione Oracle. ## Tools (Strumenti) + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale nel cloud AWS. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ti aiuta a migrare gli archivi di dati nel cloud AWS o tra combinazioni di configurazioni cloud e locali. + [Quest SharePlex](https://support.quest.com/shareplex/11.0/technical-documents) è uno strumento di replica Oracle-to-Oracle dei dati per spostare i dati con tempi di inattività minimi e nessuna perdita di dati. + [Recovery Manager (RMAN)](https://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmquick.htm) è un client di database Oracle che esegue attività di backup e ripristino sui database. Semplifica enormemente il backup, il ripristino e il ripristino dei file di database. + [Data Pump Export](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_export.htm#SUTIL823) consente di caricare dati e metadati in un set di file del sistema operativo chiamato set di file di dump. [Il set di file di dump può essere importato solo dall'utilità [Data Pump Import o dal pacchetto](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_import.htm#SUTIL300) DBMS\$1DATAPUMP.](https://docs.oracle.com/database/121/ARPLS/d_datpmp.htm#ARPLS356) ## Epiche ### Configurazione SharePlex e database di gestione temporanea di Oracle su Amazon EC2 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un' EC2 istanza. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | Amministrazione Oracle | | Preparare il database dell'area di gestione temporanea. | Prepara il database di gestione temporanea di Oracle per il ripristino come aggiornamento su Oracle 12 CR2 eseguendo il backup RMAN dall'ambiente di origine del database Oracle 8i o 9i.Per ulteriori informazioni, vedere [Oracle 9i Recovery Manager User's Guide](https://docs.oracle.com/cd/B10500_01/server.920/a96566/toc.htm) e [Database Backup and Recovery User's Guide](https://docs.oracle.com/database/121/BRADV/rcmcomre.htm#BRADV8005) nella documentazione Oracle. | Amministrazione Oracle | | Configura SharePlex. | Configura l' SharePlex origine come database Oracle 8i o 9i locale e configura la destinazione come database di CR2 staging Oracle 12 ospitato su Amazon. EC2 | SharePlex, Amministrazione Oracle | ### Configura Amazon RDS for Oracle come ambiente di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un'istanza Oracle DB. | Crea un database Amazon RDS for Oracle, quindi collega Oracle CR2 12 al database.Per ulteriori informazioni, consulta [Creazione di un'istanza DB Oracle e connessione a un database su un'istanza DB Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) nella documentazione di Amazon RDS. | DBA | | Ripristina Amazon RDS for Oracle dal database di staging. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Per ulteriori informazioni, consulta [54 DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_DATAPUMP.html#GUID-AEA7ED80-DB4A-4A70-B199-592287206348) nella documentazione Oracle. | DBA | ### Configura AWS DMS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea endpoint per i database. | Crea un endpoint di origine per il database di staging Oracle e un endpoint di destinazione per il database Amazon RDS for Oracle.Per ulteriori informazioni, consulta [Come posso creare endpoint di origine o di destinazione utilizzando AWS DMS](https://aws.amazon.com/premiumsupport/knowledge-center/create-source-target-endpoints-aws-dms/)? nell'AWS Knowledge Center. | DBA | | Crea un'istanza di replica. | Utilizza AWS DMS per avviare un'istanza di replica per il database di staging Oracle sul database Amazon RDS for Oracle.Per ulteriori informazioni, consulta [Come posso creare un'istanza di replica AWS DMS](https://aws.amazon.com/premiumsupport/knowledge-center/create-aws-dms-replication-instance/)? nell'AWS Knowledge Center. | DBA | | Crea e avvia attività di replica. | Crea attività di replica AWS DMS per l'acquisizione dei dati di modifica (CDC) utilizzando `FLASHBACK_SCN` EXPDP (poiché il caricamento completo è già avvenuto tramite EXPDP).Per ulteriori informazioni, consulta [Creazione di un'attività](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) nella documentazione di AWS DMS. | DBA | ### Passare ad Amazon RDS for Oracle | Operazione | Description | Competenze richieste | | --- | --- | --- | | Interrompi il carico di lavoro dell'applicazione. | Arresta i server delle applicazioni e le relative applicazioni durante la finestra di cutover pianificata. | Sviluppatore di app, DBA | | Convalida la sincronizzazione del database di staging Oracle locale con l'istanza. EC2 | Verifica che tutti i messaggi siano stati pubblicati per le attività di replica dall'istanza di SharePlex replica al database di staging Oracle su Amazon EC2 eseguendo alcuni cambi di registro sul database di origine locale.Per ulteriori informazioni, consulta [6.4.2 Cambio di un file di registro](https://docs.oracle.com/database/121/ADMQS/GUID-E30B4C65-2AC7-4A44-A58C-D3C121EB152F.htm#ADMQS12075) nella documentazione Oracle. | DBA | | Convalida la sincronizzazione del database di gestione temporanea di Oracle con il database Amazon RDS for Oracle. | Verifica che tutte le attività di AWS DMS non presentino ritardi né errori, quindi verifica lo stato di convalida delle attività. | DBA | | Interrompi la replica di SharePlex Amazon RDS. | Se entrambe le repliche SharePlex e AWS DMS non mostrano errori, interrompi entrambe le repliche. | DBA | | Rimappa l'applicazione su Amazon RDS. | Condividi i dettagli dell'endpoint Amazon RDS for Oracle con il server delle applicazioni e le relative applicazioni, quindi avvia l'applicazione per riprendere le operazioni aziendali. | Sviluppatore di app, DBA | ### Testa l'ambiente di destinazione AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Testa l'ambiente del database di staging Oracle su AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | SharePlex, Amministrazione Oracle | | Testa l'ambiente Amazon RDS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Per ulteriori informazioni, consulta [Amazon RDS for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) Oracle nella documentazione di Amazon RDS. | Amministrazione Oracle | ## Risorse correlate + [Migra con fiducia](https://aws.amazon.com/cloud-migration/) + [Amazon EC2](https://aws.amazon.com/ec2/) + [Amazon RDS per Oracle](https://aws.amazon.com/rds/oracle/) + [AWS Database Migration Service](https://aws.amazon.com/dms/) + [Eseguire il debug delle migrazioni AWS DMS: cosa fare quando le cose vanno male (parte 1)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-1/) + [Eseguire il debug delle migrazioni AWS DMS: cosa fare quando le cose vanno male (parte 2)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-2/) + [Eseguire il debug delle migrazioni AWS DMS: cosa fare quando le cose vanno male? (Parte 3)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-3/) + [SharePlex per la replica del database](https://aws.amazon.com/marketplace/pp/B07943W4MJ) + [SharePlex: replica del database per qualsiasi ambiente](https://www.youtube.com/watch?v=ygS_ouUaNus) # Esegui la migrazione di un database MySQL locale su Amazon EC2 *Lorenzo Mota, Amazon Web Services* ## Riepilogo Questo modello fornisce indicazioni per la migrazione di un database MySQL locale a un database MySQL su un'istanza Amazon Elastic Compute Cloud (Amazon EC2). Il modello illustra l'uso di AWS Database Migration Service (AWS DMS) o di strumenti MySQL nativi **come** mysqldump per la migrazione. Si concentra sulla migrazione completa del database verso un'istanza DB MySQL. Il modello è destinato principalmente agli architetti di soluzioni DBAs e soluzioni. Può essere utilizzato in progetti piccoli o grandi, in una fase di test o di migrazione finale. Si consiglia di eseguire almeno un ciclo di test prima di utilizzare questo modello in un ambiente di produzione. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un database sorgente MySQL in un data center locale **Versioni del prodotto** + MySQL versione 5.5 e successive + [Un sistema operativo di destinazione supportato da Amazon EC2; consulta Amazon EC2 FAQs](https://aws.amazon.com/ec2/faqs/) ## Architecture **Stack tecnologico di origine** + Un database MySQL locale **Stack tecnologico Target** + Un'istanza di database MySQL su Amazon EC2 **Metodi di migrazione dei dati AWS** + AWS DMS + [Strumenti MySQL nativi [come mysqldump o strumenti di terze parti come](https://dev.mysql.com/doc/refman/en/mysqldump.html) Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Architettura Target** Il diagramma seguente illustra l'implementazione di destinazione di Amazon EC2 dopo il cutover. ![\[Un'istanza DB MySQL su Amazon EC2 con replica su un'istanza DB MySQL in standby.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/34cab6f9-9107-4c3b-98ec-a6d7fa9f298a.png) **Architettura di migrazione dei dati AWS** *Utilizzo di AWS DMS:* Il diagramma seguente illustra il flusso di lavoro di migrazione dei dati basato sull'invio AWS DMS di modifiche complete e incrementali al database MySQL di destinazione fino al cutover. La connessione di rete da locale a AWS dipende dai requisiti del client SQL e non rientra nell'ambito di questo modello. ![\[Utilizzo di AWS DMS per inviare dati a un database MySQL di destinazione su Amazon EC2.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/c906c45d-fac5-4bb9-b8c8-55e2f9f05fd8.png) *Utilizzando altri strumenti MySQL:* Il diagramma seguente illustra il flusso di lavoro di migrazione dei dati basato sull'utilizzo degli strumenti MySQL per generare file di dump di esportazione dal database locale. Questi file vengono spostati su Amazon Simple Storage Service (Amazon S3) e importati nel database MySQL di destinazione prima del cutover. La connessione di rete da locale a AWS dipende dai requisiti del client SQL e non rientra nell'ambito di questo modello. ![\[Utilizzo di strumenti MySQL nativi per inviare dati a un DB MySQL di destinazione su Amazon EC2.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/18e88877-7879-4a99-b985-25c56bf7c35f.png) Note: + A seconda delle considerazioni relative ai tempi di inattività e alle dimensioni del database per il cutover finale, puoi utilizzare AWS DMS un altro strumento di acquisizione dei dati di modifica (CDC) per ridurre al minimo i tempi di cutover. Quando si utilizza uno strumento CDC come, ad esempio AWS DMS, è possibile migrare al database di destinazione in pochi minuti. + Una strategia offline con **mysqldump** può essere sufficiente se le dimensioni del database e la latenza di rete consentono una breve finestra di migrazione. (Si consiglia di eseguire dei test per ottenere un tempo approssimativo.) + Di solito una strategia CDC AWS DMS richiede più monitoraggio e complessità rispetto a un'opzione offline. ## Tools (Strumenti) **AWS servizi** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) supporta diversi database di origine e destinazione. Per informazioni sui database di origine e destinazione MySQL supportati AWS DMS da, [vedere Utilizzo di un database compatibile con MySQL come origine [e Utilizzo](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) di un database compatibile con MySQL come](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.MySQL.html) destinazione AWS DMS per. AWS DMS Se il database di origine non è supportato da, è necessario scegliere un altro metodo per migrare AWS DMS i dati. **Altri strumenti** + [mysqldump è](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) un'utilità MySQL che crea un file di dump da un database MySQL per scopi di backup o migrazione. + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) è un'utilità open source per eseguire backup non bloccanti su database MySQL. ## Epiche ### Pianifica la migrazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Convalida le versioni del database. | Convalida le versioni dei database di origine e di destinazione. Per informazioni sulle versioni di MySQL supportate AWS DMS da, [consulta Sources AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Sources.html) for [e Targets AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Targets.html) nella documentazione. AWS DMS | DBA | | Identifica il sistema operativo di destinazione. | Determina la versione del sistema operativo di destinazione. Per un elenco dei sistemi operativi di destinazione supportati da Amazon EC2, consulta Amazon [EC2](https://aws.amazon.com/ec2/faqs/). FAQs | DBA, amministratore di sistema | | Identifica i requisiti hardware. | Determina i requisiti hardware per l'[istanza del server di destinazione](https://aws.amazon.com/rds/instance-types/) in base all'elenco di compatibilità MySQL e ai requisiti di capacità. | DBA, amministratore di sistema | | Identifica i requisiti di archiviazione. | Determina il tipo e la capacità di archiviazione per il database di destinazione. | DBA, amministratore di sistema | | Identifica i requisiti di rete. | Determina i requisiti di rete come latenza e larghezza di banda. | DBA, amministratore di sistema | | Scegli il tipo di istanza di destinazione. | Scegli il [tipo di istanza di destinazione](https://aws.amazon.com/rds/instance-types/) in base alla capacità, alle funzionalità di archiviazione e alle funzionalità di rete. | DBA, amministratore di sistema | | Identifica i requisiti di sicurezza. | Determina i requisiti di sicurezza di accesso alla rete o all'host per i database di origine e di destinazione. | DBA, amministratore di sistema | | Identifica gli utenti. | Determina l'elenco degli utenti del sistema operativo per l'installazione del software MySQL. Per ulteriori informazioni, consulta [ la documentazione MySQL](https://dev.mysql.com/doc/mysql-security-excerpt/en/access-control.html). | DBA, amministratore di sistema | | Determinare una strategia di backup. | | DBA | | Determina i requisiti di disponibilità. | | DBA | | Identifica la strategia di migrazione o commutazione delle applicazioni. | | DBA, amministratore di sistema | ### Configura l'infrastruttura | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un cloud privato virtuale (VPC) e sottoreti. | Configura tabelle di routing, gateway Internet, gateway NAT e sottoreti. Per ulteriori informazioni, consulta le [opzioni di configurazione VPC nella documentazione](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html) di Amazon VPC. | Amministratore di sistema | | Crea gruppi di sicurezza e liste di controllo degli accessi alla rete (ACLs). | Configura le porte (l'impostazione predefinita per MySQL è 3306) e gli intervalli CIDR o IPs specifici a seconda delle tue esigenze. | Amministratore di sistema | | Configura e avvia un'istanza EC2. | Per istruzioni, consulta [Avvio di un'istanza EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) nella documentazione di Amazon EC2. | Amministratore di sistema | ### Installa il software MySQL | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare utenti e gruppi. | Crea gli utenti e i gruppi del sistema operativo che devono accedere al server e al database. Per ulteriori informazioni, consulta [ Access Control and Account Management](https://dev.mysql.com/doc/refman/en/access-control.html) nella documentazione MySQL. | DBA, amministratore di sistema | | Scarica MySQL. | Scarica il software MySQL. Per istruzioni e file binari, consulta [Installazione di MySQL](https://dev.mysql.com/doc/refman/en/installing.html) nella documentazione di MySQL. | DBA, amministratore di sistema | | Installa MySQL sull'istanza EC2 e configura il server. | Connect alla tua istanza EC2 e installa il software MySQL. Per ulteriori informazioni, consulta [Connect to your EC2 istance (Connect to your EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect.html) nella documentazione di Amazon EC2. | DBA, amministratore di sistema | ### Migrazione dei dati: opzione 1 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Migra i dati con strumenti nativi MySQL o di terze parti. | Questa opzione utilizza strumenti MySQL nativi o strumenti di terze parti per migrare oggetti e dati del database. [Per istruzioni, consulta la documentazione per [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) o Percona (per la migrazione fisica). XtraBackup](https://docs.percona.com/percona-xtrabackup/2.4/index.html) Per ulteriori informazioni sull'utilizzo di questi strumenti, consulta il post di AWS blog [Opzioni di migrazione per MySQL ad Amazon RDS for MySQL o Amazon Aurora MySQL](https://aws.amazon.com/blogs/database/migration-options-for-mysql-to-amazon-rds-for-mysql-or-amazon-aurora-mysql/). | DBA | ### Migrazione dei dati — opzione 2 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Esegui la migrazione dei dati con AWS DMS. | Per ulteriori informazioni, consulta [Visualizzazione ad alto livello della AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.HighLevelView.html) AWS DMS documentazione. | DBA | ### Preparatevi per il cutover | Operazione | Description | Competenze richieste | | --- | --- | --- | | Raccogli il numero di oggetti. | Raccogli il numero di oggetti dal database di origine e dai nuovi database di destinazione. Correggi eventuali discrepanze nel database di destinazione. | DBA | | Controlla le dipendenze. | Verifica che le dipendenze (collegamenti) da e verso altri database siano ancora valide e funzionino correttamente. | DBA | | Prova. | Se si tratta di un ciclo di test, esegui test delle query, raccogli le metriche e risolvi eventuali problemi. | DBA | ### Tagliare | Operazione | Description | Competenze richieste | | --- | --- | --- | | Sposta i clienti. | Trasferisci i client applicativi alla nuova infrastruttura. | DBA, proprietario dell'app, amministratore di sistema | | Fornire supporto. | Fornire supporto durante i test funzionali delle applicazioni. | DBA | ### Chiudi il progetto | Operazione | Description | Competenze richieste | | --- | --- | --- | | Chiudi le risorse. | Chiudi l'istanza di AWS DMS replica e le altre AWS risorse temporanee. | DBA, amministratore di sistema | | Documenti di revisione e progetto. | Rivedi e convalida i documenti del progetto. | DBA, proprietario dell'app, amministratore di sistema | | Raccogli metriche. | Raccogli parametri come il tempo necessario per la migrazione, la percentuale di modifiche manuali rispetto alle modifiche assistite da strumenti e i risparmi sui costi. | DBA, proprietario dell'app, amministratore di sistema | | Chiudi il progetto. | Chiudi il progetto di migrazione e fornisci feedback. | DBA, proprietario dell'app, amministratore di sistema | | Disattivazione del database di origine. | Disattiva il database MySQL locale. | DBA, amministratore di sistema | ## Risorse correlate **Riferimenti** + [Documentazione Amazon EC2](https://docs.aws.amazon.com/ec2/) + [AWS DMS documentazione](https://docs.aws.amazon.com/dms/) + [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) + [AWS DMS Step-by-Step Procedure dettagliate](https://docs.aws.amazon.com/dms/latest/sbs/DMS-SBS-Welcome.html) + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Tutorial e video** + [Guida introduttiva con AWS DMS](https://aws.amazon.com/dms/getting-started/) + [Introduzione ad Amazon EC2: server e hosting cloud elastici con AWS(video](https://www.youtube.com/watch?v=TsRBftzZsQo)) # Monitora Amazon Aurora per le istanze senza crittografia *Mansi Suratwala, Amazon Web Services* ## Riepilogo Questo modello fornisce un CloudFormation modello Amazon Web Services (AWS) che puoi implementare per configurare notifiche automatiche quando un'istanza Amazon Aurora viene creata senza la crittografia attivata. Aurora è un motore di database relazionale completamente gestito compatibile con MySQL e PostgreSQL. Con alcuni carichi di lavoro, Aurora assicura un throughput fino a cinque volte superiore a MySQL e fino al triplo di PostgreSQL e non richiede alcuna modifica alla maggior parte delle applicazioni esistenti. Il CloudFormation modello crea un evento Amazon CloudWatch Events e una funzione AWS Lambda. L'evento utilizza AWS CloudTrail per monitorare la creazione di qualsiasi istanza Aurora o il ripristino point-in-time di un'istanza esistente. L'evento Cloudwatch Events avvia la funzione Lambda, che verifica se la crittografia è abilitata. Se la crittografia non è attivata, la funzione Lambda invia una notifica Amazon Simple Notification Service (Amazon SNS) che ti informa della violazione. ## Prerequisiti e limitazioni **Prerequisiti****** + Un account AWS attivo **Limitazioni** + Questo controllo del servizio funziona solo con le istanze di Amazon Aurora. Non supporta altre istanze di Amazon Relational Database Service (Amazon RDS). + **Il CloudFormation modello deve essere distribuito solo per `CreateDBInstance`**** e. `RestoreDBClusterToPointInTim`** **Versioni del prodotto** + Versioni PostgreSQL supportate in Amazon Aurora + Versioni di MySQL supportate in Amazon Aurora ## Architecture **Stack tecnologico Target** + Amazon Aurora + AWS CloudTrail + Amazon CloudWatch + AWS Lambda + Amazon Simple Storage Service (Amazon S3) + Amazon SNS **Architettura Target** ![\[Avvio di Aurora senza invocazione della crittografia CloudTrail, Events CloudWatch , Lambda e un messaggio SNS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/de1528b8-a5a4-4c66-8ab3-7d9863572cbc/images/7dcab41a-d805-4bb0-99d1-1dcef37c4e55.png) **Automazione e scalabilità** Puoi utilizzare il CloudFormation modello più volte per diverse regioni e account. Devi eseguirlo solo una volta in ogni regione o account. ## Tools (Strumenti) **Strumenti** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) — Amazon Aurora è un motore di database relazionale completamente gestito compatibile con MySQL e PostgreSQL. + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html): AWS ti CloudTrail aiuta a gestire la governance, la conformità e il controllo operativo e dei rischi del tuo account AWS. Le azioni intraprese da un utente, un ruolo o un servizio AWS vengono registrate come eventi in CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html): Amazon CloudWatch Events offre un near-real-time flusso di eventi di sistema che descrivono i cambiamenti nelle risorse AWS. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda è un servizio di elaborazione che supporta l'esecuzione di codice senza effettuare il provisioning o la gestione di server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html) — Amazon Simple Storage Service (Amazon S3) è un servizio di storage di oggetti altamente scalabile che puoi utilizzare per un'ampia gamma di soluzioni di storage, tra cui siti Web, applicazioni mobili, backup e data lake. + [Amazon SNS — Amazon Simple](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) Notification Service (Amazon SNS) è un servizio gestito che fornisce il recapito di messaggi tramite Lambda, HTTP, e-mail, notifiche push mobili e messaggi di testo mobili (SMS). **Codice** Un file.zip del progetto è disponibile come allegato. ## Epiche ### Crea il bucket S3 per lo script Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Definisci il bucket S3. | Apri la console Amazon S3 e scegli o crea un bucket S3. Questo bucket S3 ospiterà il file.zip con codice Lambda. Il tuo bucket S3 deve trovarsi nella stessa regione di Aurora. Il nome del bucket S3 non può contenere barre iniziali. | Architetto del cloud | ### Carica il codice Lambda nel bucket S3 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Carica il codice Lambda. | Carica il file.zip con codice Lambda fornito nella sezione *Allegati nel bucket* S3 che hai definito. | Architetto del cloud | ### Implementa il modello CloudFormation | Operazione | Description | Competenze richieste | | --- | --- | --- | | Implementa il CloudFormation modello. | Sulla CloudFormation console, distribuisci il `RDS_Aurora_Encryption_At_Rest.yml` CloudFormation modello fornito come allegato a questo modello. Nella prossima epopea, fornisci i valori per i parametri del modello. | Architetto del cloud | ### Completa i parametri nel CloudFormation modello | Operazione | Description | Competenze richieste | | --- | --- | --- | | Fornisci il nome del bucket S3. | Inserisci il nome del bucket S3 che hai creato o scelto nella prima epic. | Architetto del cloud | | Fornisci la chiave S3. | Fornisci la posizione del file.zip del codice Lambda nel tuo bucket S3, senza barre iniziali (ad esempio,). `
(sidadm $> python systemReplicationStatus.py
sudo yum install -y awslogs| Informazioni generali su AWS | | Modifica i file di configurazione dell'agente. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Informazioni generali su AWS | | Avvia l' CloudWatch agente. | Per avviare l'agente, utilizzare il seguente comando.
$ sudo service awslogsd startDopo aver avviato l'agente, è possibile visualizzare il gruppo di log nella CloudWatch console. Il flusso di log conterrà il contenuto del file. | Informazioni generali su AWS | ### Fase 6. Crea filtri metrici per il gruppo di log | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea filtri metrici per le parole chiave ABEND e STOPPED. | Quando crei filtri metrici per il gruppo di log, ogni volta che i filtri vengono identificati nel log degli errori, avvia un allarme e invia una notifica e-mail basata sulla configurazione di Amazon SNS.Per creare filtri metrici:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | CloudWatch | ### Fase 7. Configurazione di Amazon SNS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare un argomento SNS. | In questo passaggio, configuri Amazon SNS per creare allarmi per i filtri metrici.Per creare un argomento SNS:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Amazon SNS | | Crea un abbonamento. | Per creare un abbonamento all'argomento:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Amazon SNS apre il browser Web e visualizza una conferma dell'abbonamento con il tuo ID abbonamento. | Amazon SNS | ### Fase 8. Crea un allarme per inviare notifiche per i filtri metrici | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un allarme per l'argomento SNS. | Per creare un allarme basato su un filtro metrico per gruppi di log:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Dopo questi passaggi, ogni volta che questi schemi vengono rilevati nel file di registro degli GoldenGate errori (`ggserr.log`) che stai monitorando, riceverai una notifica via email. | CloudWatch | ## Risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Il flusso di log proveniente dal registro GoldenGate degli errori non confluisce in CloudWatch. | Controlla il `/etc/awslogs/awslogs.conf` file per verificare il nome del file, il nome del gruppo di log e il date/time formato. È necessario specificare il date/time formato della data in cui deve corrispondere`ggserror.log`. In caso contrario, il flusso di log non confluirà in CloudWatch. | ## Risorse correlate + [ CloudWatch Documentazione Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Raccolta di metriche e registri con l'agente CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) + [Documentazione Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) # Ripiattaforma Oracle Database Enterprise Edition alla Standard Edition 2 su Amazon RDS per Oracle *Showunmi Lanre (Lan-Ray) e Tarun Chawla, Amazon Web Services* ## Riepilogo Oracle Database Enterprise Edition (EE) è una scelta popolare per l'esecuzione di applicazioni in molte aziende. In alcuni casi, tuttavia, le applicazioni utilizzano poche o nessuna funzionalità di Oracle Database EE, quindi non esiste alcuna giustificazione per sostenere ingenti costi di licenza. Puoi ottenere risparmi sui costi effettuando il downgrade di tali database a Oracle Database Standard Edition 2 (SE2) quando esegui la migrazione ad Amazon RDS. Questo modello descrive come effettuare il downgrade da Oracle Database EE a Oracle Database SE2 durante la migrazione da locale ad [Amazon RDS](https://aws.amazon.com/rds/oracle/) for Oracle. I passaggi presentati in questo modello si applicano anche se il database EE Oracle è già in esecuzione su Amazon RDS o su un'istanza [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) EC2 (Amazon). Per ulteriori informazioni, consulta la guida AWS Prescriptive Guidance su come [valutare il downgrade dei database Oracle alla Standard Edition](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) 2 su AWS. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Edizione Enterprise del database Oracle + Uno strumento client, come [Oracle SQL Developer](https://www.oracle.com/database/sqldeveloper/) o SQL\$1Plus, per la connessione e l'esecuzione di comandi SQL sul database Oracle + Utente del database per l'esecuzione della valutazione; ad esempio, uno dei seguenti: + Utente con [privilegi](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Permissions) sufficienti per eseguire la valutazione di [AWS Schema Conversion Tool (AWS SCT](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)) + Utente con privilegi sufficienti per eseguire query SQL sulle tabelle dei dizionari del database Oracle + Utente del database per l'esecuzione della migrazione del database; ad esempio, uno dei seguenti: + Utente con [privilegi](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Self-Managed) sufficienti per eseguire [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) + Utente con [privilegi sufficienti per eseguire l'esportazione e l'importazione di Oracle Data Pump](https://docs.oracle.com/database/121/SUTIL/GUID-8B6975D3-3BEC-4584-B416-280125EEC57E.htm#SUTIL807) + Utente con [privilegi sufficienti per eseguire Oracle GoldenGate](https://docs.oracle.com/goldengate/1212/gg-winux/GIORA/user_assignment.htm#GIORA546) **Limitazioni** + Amazon RDS for Oracle ha una dimensione massima del database. Per ulteriori informazioni, consulta [Storage delle istanze di database Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html). **Versioni del prodotto** La logica generale descritta in questo documento si applica alle versioni Oracle dalla 9i in poi. Per le versioni supportate dei database autogestiti e Amazon RDS for Oracle, [consulta la documentazione di AWS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) DMS. Per identificare l'utilizzo delle funzionalità nei casi in cui AWS SCT non è supportato, esegui query SQL sul database di origine. Per migrare da versioni precedenti di Oracle in cui AWS DMS e Oracle Data Pump non sono supportati, utilizza [le utilità Oracle Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm). Per un elenco aggiornato delle versioni ed edizioni supportate, consulta [Oracle on Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) nella documentazione AWS. Per informazioni dettagliate sui prezzi e sulle classi di istanze supportate, consulta [Prezzi di Amazon RDS per Oracle](https://aws.amazon.com/rds/oracle/pricing/). ## Architecture **Stack tecnologico di origine** + Oracle Database Enterprise Edition in esecuzione in locale o su Amazon EC2 **Scegli lo stack tecnologico utilizzando strumenti Oracle nativi** + Amazon RDS per Oracle che esegue Oracle Database SE2 ![\[Processo in tre fasi per la migrazione da Oracle DB locale ad Amazon RDS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/bf765c5b-4b12-4a8c-b27c-c5e0bd605dd1.png) 1. Esporta i dati utilizzando Oracle Data Pump. 1. Copia i file di dump su Amazon RDS tramite un collegamento al database. 1. Importa file di dump in Amazon RDS utilizzando Oracle Data Pump. **Stack tecnologico di destinazione con AWS DMS** + Amazon RDS per Oracle che esegue Oracle Database SE2 + AWS DMS ![\[Processo in quattro fasi per la migrazione da Oracle DB locale ad Amazon RDS utilizzando AWS DMS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/fef4eced-1acb-4303-baaa-5c1c29650935.png) 1. Esporta i dati utilizzando Oracle Data Pump con FLASHBACK\$1SCN. 1. Copia i file di dump su Amazon RDS tramite un collegamento al database. 1. Importa file di dump in Amazon RDS utilizzando Oracle Data Pump. 1. Usa AWS DMS [Change Data Capture (CDC](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html)). ## Tools (Strumenti) **Servizi AWS** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ti aiuta a migrare gli archivi di dati nel cloud AWS o tra combinazioni di configurazioni cloud e locali. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale nel cloud AWS. Questo modello utilizza Amazon RDS for Oracle. + [AWS SCT****](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) fornisce un'interfaccia utente basata su progetti per valutare, convertire e copiare automaticamente lo schema del database Oracle di origine in un formato compatibile con Amazon RDS for Oracle. AWS SCT consente di analizzare i potenziali risparmi sui costi che è possibile ottenere cambiando il tipo di licenza da Enterprise a Standard Edition di Oracle. La sezione **License Evaluation and Cloud Support** del report AWS SCT fornisce informazioni dettagliate sulle funzionalità Oracle in uso in modo da poter prendere una decisione informata durante la migrazione ad Amazon RDS for Oracle. **Altri strumenti** + Le utilità native di importazione ed esportazione di Oracle supportano lo spostamento dei dati Oracle all'interno e all'esterno dei database Oracle. Oracle offre due tipi di utilità di importazione ed esportazione dei database: [Original Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) (per le release precedenti) e [Oracle Data Pump Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/part_dp.htm#CEGJCCHC) (disponibile in Oracle Database 10g release 1 e successive). + [Oracle GoldenGate](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.OracleGoldenGate.html) offre funzionalità di replica in tempo reale che consentono di sincronizzare il database di destinazione dopo un caricamento iniziale. Questa opzione può aiutare a ridurre i tempi di inattività delle applicazioni durante il go-live. ## Epiche ### Effettua una valutazione pre-migrazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Convalida i requisiti del database per le tue applicazioni. | Assicurati che le tue applicazioni siano certificate per l'esecuzione su Oracle Database SE2. Consulta direttamente la documentazione del fornitore del software, dello sviluppatore o dell'applicazione. | Sviluppatore di app, DBA, proprietario dell'app | | Esamina l'uso delle funzionalità EE direttamente nel database. | Per determinare l'utilizzo della funzionalità EE, effettuate una delle seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | Proprietario dell'app, DBA, sviluppatore dell'app | | Identifica l'uso delle funzionalità EE per le attività operative. | Gli amministratori di database o applicazioni a volte si affidano a funzionalità esclusive di EE per le attività operative. Gli esempi più comuni includono le attività di manutenzione online (ricostruzione dell'indice, spostamento delle tabelle) e l'uso del parallelismo nei processi in batch.Queste dipendenze possono essere mitigate modificando le operazioni ove possibile. Identifica l'uso di queste funzionalità e prendi una decisione in base ai costi rispetto ai vantaggi.Utilizza la tabella di [confronto tra Oracle Database EE e le SE2 funzionalità](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/compare-features.html) come guida per identificare le funzionalità disponibili in Oracle Database SE2. | Sviluppatore di app, DBA, proprietario dell'app | | Esamina i modelli di carico di lavoro del database EE Oracle. | Oracle Database limita SE2 automaticamente l'utilizzo a un massimo di 16 thread della CPU in qualsiasi momento.Se il database Oracle EE è autorizzato a utilizzare Oracle Diagnostic Pack, utilizza lo strumento Automatic Workload Repository (AWR) o le viste DBA\$1HIST\$1\$1 per analizzare i modelli di carico di lavoro del database e determinare se il limite massimo di 16 thread della CPU avrà un impatto negativo sui livelli di servizio in caso di downgrade a. SE2Assicurati che la valutazione copra i periodi di picco di attività, ad esempio l'elaborazione di fine giornata, mese o anno. | Proprietario dell'app, DBA, sviluppatore dell'app | ### Prepara l'infrastruttura di destinazione su AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Implementa e configura l'infrastruttura di rete. | Crea un [cloud privato virtuale (VPC) e sottoreti, [gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) ed](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) elenchi di controllo degli accessi [alla rete](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html). | Amministratore AWS, architetto cloud, amministratore di rete, DevOps ingegnere | | Effettua il provisioning del database Amazon RDS for SE2 Oracle. | Effettua il provisioning del database [Amazon RDS for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) SE2 Oracle di destinazione per soddisfare i requisiti di prestazioni, disponibilità e sicurezza delle tue applicazioni. Consigliamo la configurazione Multi-AZ per i carichi di lavoro di produzione. Tuttavia, per migliorare le prestazioni di migrazione, puoi rimandare l'[attivazione di Multi-AZ](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) a dopo la migrazione dei dati. | Amministratore cloud, architetto cloud, DBA, DevOps ingegnere, amministratore AWS | | Personalizza l'ambiente Amazon RDS. | Configura [parametri](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) e [opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html) personalizzati e abilita un [monitoraggio](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MonitoringOverview.html) aggiuntivo. Per ulteriori informazioni, consulta [Best practice per la migrazione ad Amazon RDS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html) for Oracle. | Amministratore AWS, amministratore di sistema AWS, amministratore cloud, DBA, architetto cloud | ### Esegui la migrazione, il dry run e il test delle applicazioni | Operazione | Description | Competenze richieste | | --- | --- | --- | | Migrazione dei dati (funzionamento a secco). | Esegui la migrazione dei dati dal database Oracle EE di origine all'istanza di database Amazon RDS for SE2 Oracle utilizzando l'approccio più adatto al tuo ambiente specifico. Seleziona una strategia di migrazione basata su fattori quali dimensioni, complessità e periodo di inattività disponibile. Utilizza uno o una combinazione dei seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | DBA | | Convalida il database di destinazione. | Esegui la convalida post-migrazione dello storage del database e degli oggetti di codice. Esamina i log di migrazione e risolvi eventuali problemi identificati. Per ulteriori informazioni, consulta la guida [Migrazione dei database Oracle al cloud AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#post-import). | DBA | | Prova le applicazioni. | Gli amministratori delle applicazioni e dei database devono eseguire test funzionali, prestazionali e operativi, a seconda dei casi. Per ulteriori informazioni, consulta [Best practice per la migrazione ad Amazon RDS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#test-migration) for Oracle.Infine, ottieni l'approvazione dei risultati dei test dalle parti interessate. | Sviluppatore di app, proprietario dell'app, DBA, ingegnere addetto alla migrazione, responsabile della migrazione | ### Tagliare | Operazione | Description | Competenze richieste | | --- | --- | --- | | Aggiorna i dati da Oracle Database EE. | Seleziona un approccio di aggiornamento dei dati in base ai requisiti di disponibilità dell'applicazione. Per ulteriori informazioni, consulta i metodi di migrazione in [Strategie per la migrazione dei database Oracle su AWS](https://docs.aws.amazon.com/whitepapers/latest/strategies-migrating-oracle-db-to-aws/data-migration-methods.html).Ad esempio, puoi ottenere tempi di inattività vicini allo zero utilizzando strumenti come Oracle o GoldenGate AWS DMS con replica continua. Se il periodo di inattività lo consente, puoi eseguire il cutover finale dei dati utilizzando metodi offline come le utilità Oracle Data Pump o Original Export-Import. | Proprietario dell'app, responsabile Cutover, DBA, ingegnere addetto alla migrazione, responsabile della migrazione | | Indirizza le applicazioni all'istanza del database di destinazione. | Aggiorna i parametri di connessione nelle applicazioni e in altri client in modo che puntino al database Amazon RDS for SE2 Oracle. | Sviluppatore di app, proprietario dell'app, tecnico addetto alla migrazione, responsabile della migrazione, responsabile Cutover | | Esegui attività post-migrazione. | Esegui attività successive alla migrazione dei dati, come l'attivazione di Multi-AZ, la convalida dei dati e altri controlli. | DBA, ingegnere addetto alla migrazione | | Esegui il monitoraggio post-cutover. | Utilizza strumenti come [Amazon CloudWatch e Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-cloudwatch.html) [RDS Performance Insights](https://aws.amazon.com/rds/performance-insights/) per monitorare il database Amazon RDS for SE2 Oracle. | Sviluppatore di app, proprietario dell'app, amministratore AWS, DBA, ingegnere addetto alla migrazione | ## Risorse correlate **Prontuario AWS** + [Migrazione dei database Oracle al cloud AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/welcome.html) (guida) + [Valuta il downgrade dei database Oracle alla Standard Edition 2 su AWS (guida](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html)) + [Migrazione di un database Oracle locale su Amazon RDS for](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.html?did=pg_card&trk=pg_card) Oracle (modello) + [Migrazione di un database Oracle on-premise su Amazon RDS per Oracle utilizzando Oracle Data Pump](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.html?did=pg_card&trk=pg_card) (modello) **Post di blog** + [Migrazione dei database Oracle con tempi di inattività quasi nulli utilizzando AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/) + [Analisi della gestione delle prestazioni in Oracle SE con Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/analyzing-performance-management-in-oracle-se-using-amazon-rds-for-oracle/) + [Gestione del piano SQL in Oracle SE con Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/managing-your-sql-plan-in-oracle-se-with-amazon-rds-for-oracle/) + [Implementazione del partizionamento delle tabelle in Oracle Standard Edition: parte 1](https://aws.amazon.com/blogs/database/implementing-table-partitioning-in-oracle-standard-edition-part-1/) # Replica i database mainframe su AWS utilizzando Precisly Connect *Lucio Pereira, Sayantan Giri e Balaji Mohan, Amazon Web Services* ## Riepilogo Questo modello descrive i passaggi per replicare i dati dai database mainframe agli archivi dati Amazon quasi in tempo reale utilizzando Precisly Connect. Implementa un'architettura basata su eventi con Amazon Managed Streaming for Apache Kafka (Amazon MSK) e connettori di database personalizzati nel cloud per migliorare scalabilità, resilienza e prestazioni. Precisly Connect è uno strumento di replica che acquisisce i dati dai sistemi mainframe legacy e li integra in ambienti cloud. I dati vengono replicati dai mainframe ad AWS tramite Change Data Capture (CDC) utilizzando flussi di messaggi quasi in tempo reale con pipeline di dati eterogenee a bassa latenza e ad alto throughput. Questo modello copre anche una strategia di disaster recovery per pipeline di dati resilienti con replica dei dati in più regioni e routing di failover. ## Prerequisiti e limitazioni **Prerequisiti** + Un database mainframe esistente, ad esempio IBM DB2, IBM Information Management System (IMS) o Virtual Storage Access Method (VSAM), che desideri replicare nel cloud AWS + Un [account AWS](https://aws.amazon.com/account/) attivo + [AWS Direct Connect](https://aws.amazon.com/directconnect/) o [AWS Virtual Private Network (AWS VPN](https://aws.amazon.com/vpn/)) dal tuo ambiente aziendale ad AWS + Un [cloud privato virtuale](https://aws.amazon.com/vpc/) con una sottorete raggiungibile dalla tua piattaforma legacy ## Architecture **Stack tecnologico di origine** Un ambiente mainframe che include almeno uno dei seguenti database: + Database IBM IMS + Banca dati IBM DB2 + file VSAM **Stack tecnologico Target** + MSK Amazon + Amazon Elastic Kubernetes Service (Amazon EKS) e Amazon EKS Anywhere + Docker + Un database relazionale AWS o NoSQL come il seguente: + Amazon DynamoDB + Amazon Relational Database Service (Amazon RDS) per Oracle, Amazon RDS per PostgreSQL o Amazon Aurora + Amazon ElastiCache per Redis + Amazon Keyspaces (per Apache Cassandra) **Architettura Target** *Replica dei dati del mainframe nei database AWS* Il diagramma seguente illustra la replica dei dati mainframe su un database AWS come DynamoDB, Amazon RDS, Amazon o Amazon Keyspaces. ElastiCache La replica avviene quasi in tempo reale utilizzando Precisly Capture and Publisher nell'ambiente mainframe locale, Precisly Dispatcher su Amazon EKS Anywhere nell'ambiente distribuito locale e Precisly Apply Engine e connettori di database nel cloud AWS. ![\[Replica dei dati del mainframe nei database AWS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/777dd7da-48ed-4510-b8fa-9041be042671.png) Il diagramma mostra il flusso di lavoro seguente: 1. Precisly Capture ottiene i dati del mainframe dai log del CDC e li conserva in uno storage transitorio interno. 1. Precisly Publisher ascolta le modifiche nella memoria interna dei dati e invia i record CDC a Precisly Dispatcher tramite una connessione. TCP/IP 1. Precisamente Dispatcher riceve i record CDC da Publisher e li invia ad Amazon MSK. Dispatcher crea chiavi Kafka in base alla configurazione dell'utente e a più attività di lavoro per inviare i dati in parallelo. Dispatcher invia una conferma a Publisher quando i record sono stati archiviati in Amazon MSK. 1. Amazon MSK detiene i record CDC nell'ambiente cloud. La dimensione della partizione degli argomenti dipende dai requisiti del sistema di elaborazione delle transazioni (TPS) per la velocità effettiva. La chiave Kafka è obbligatoria per l'ulteriore trasformazione e l'ordinamento delle transazioni. 1. Il Precisly Apply Engine ascolta i record CDC di Amazon MSK e trasforma i dati (ad esempio, filtrandoli o mappandoli) in base ai requisiti del database di destinazione. È possibile aggiungere logica personalizzata agli script Precisly SQD. (SQD è il linguaggio proprietario di Precisly.) Il Precisly Apply Engine trasforma ogni record CDC in formato Apache Avro o JSON e lo distribuisce su diversi argomenti in base alle esigenze dell'utente. 1. Gli argomenti Kafka di destinazione contengono i record CDC in più argomenti basati sul database di destinazione e Kafka facilita l'ordinamento delle transazioni in base alla chiave Kafka definita. Le chiavi di partizione si allineano con le partizioni corrispondenti per supportare un processo sequenziale. 1. I connettori di database (applicazioni Java personalizzate) ascoltano i record CDC di Amazon MSK e li archiviano nel database di destinazione. 1. Puoi selezionare un database di destinazione in base alle tue esigenze. Questo modello supporta sia i database NoSQL che quelli relazionali. *Ripristino di emergenza* La continuità aziendale è fondamentale per il successo dell'organizzazione. Il cloud AWS offre funzionalità per l'alta disponibilità (HA) e il disaster recovery (DR) e supporta i piani di failover e fallback dell'organizzazione. Questo modello segue una strategia di active/passive DR e fornisce linee guida di alto livello per l'implementazione di una strategia DR che soddisfi i requisiti RTO e RPO. Il diagramma seguente illustra il flusso di lavoro del DR. ![\[Flusso di lavoro di disaster recovery per la replica dei dati mainframe su AWS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/9cccba7a-7a25-411e-829f-7cd5a7a20ab4.png) Il diagramma mostra: 1. È necessario un failover semiautomatico in caso di guasto nella regione 1 di AWS. In caso di errore nella Regione 1, il sistema deve avviare le modifiche al routing per connettere Precisly Dispatcher alla Regione 2. 1. Amazon MSK replica i dati tramite mirroring tra regioni. Per questo motivo, durante il failover, il cluster Amazon MSK nella Regione 2 deve essere promosso come leader principale. 1. Il motore di applicazione precisa e i connettori del database sono applicazioni stateless che possono funzionare in qualsiasi regione. 1. La sincronizzazione del database dipende dal database di destinazione. Ad esempio, DynamoDB può utilizzare tabelle globali ElastiCache e datastore globali. *Elaborazione a bassa latenza e ad alto rendimento tramite connettori di database* I connettori di database sono componenti fondamentali in questo modello. I connettori seguono un approccio basato su listener per raccogliere dati da Amazon MSK e inviare transazioni al database tramite elaborazione ad alta velocità e bassa latenza per applicazioni mission-critical (livelli 0 e 1). Il diagramma seguente illustra tale processo. ![\[Utilizzo di connettori di database per replicare i dati del mainframe su AWS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/79479634-becb-4212-bbfc-1a3b17ae1bed.png) Questo modello supporta lo sviluppo di un'applicazione personalizzata con utilizzo a thread singolo tramite un motore di elaborazione multithread. 1. Il thread principale del connettore consuma i record CDC da Amazon MSK e li invia al pool di thread per l'elaborazione. 1. I thread del pool di thread elaborano i record CDC e li inviano al database di destinazione. 1. Se tutti i thread sono occupati, i record CDC vengono mantenuti in attesa dalla coda dei thread. 1. Il thread principale attende che tutti i record vengano cancellati dalla coda dei thread e trasferisce gli offset in Amazon MSK. 1. I thread secondari gestiscono gli errori. Se si verificano errori durante l'elaborazione, i messaggi non riusciti vengono inviati all'argomento DLQ (coda di lettere morte). 1. I thread secondari avviano gli aggiornamenti condizionali (vedi [Condition expression](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) nella documentazione di DynamoDB), in base al timestamp del mainframe, per evitare duplicazioni o aggiornamenti nel database. out-of-order [Per informazioni su come implementare un'applicazione Kafka consumer con funzionalità multi-threading, consulta il post di blog Multi-Threaded Message Consumption with the Apache Kafka Consumer sul sito Web di Confluent.](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) ## Tools (Strumenti) **Servizi AWS** + [Amazon Managed Streaming for Apache Kafka (Amazon](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) MSK) è un servizio completamente gestito che ti aiuta a creare ed eseguire applicazioni che utilizzano Apache Kafka per elaborare dati di streaming. + [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o mantenere il tuo piano di controllo o i tuoi nodi Kubernetes. + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) ti aiuta a distribuire, utilizzare e gestire i cluster Kubernetes eseguiti nei tuoi data center. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale nel cloud AWS. + [Amazon](https://docs.aws.amazon.com/elasticache/) ti ElastiCache aiuta a configurare, gestire e scalare ambienti di cache in memoria distribuiti nel cloud AWS. + [Amazon Keyspaces (per Apache Cassandra)](https://docs.aws.amazon.com/keyspaces/latest/devguide/what-is-keyspaces.html) è un servizio di database gestito che ti aiuta a migrare, eseguire e scalare i carichi di lavoro Cassandra nel cloud AWS. **Altri strumenti** + [Precisly Connect](https://www.precisely.com/product/precisely-connect/connect) integra i dati provenienti da sistemi mainframe legacy come set di dati VSAM o database mainframe IBM in piattaforme cloud e dati di nuova generazione. ## Best practice + Trova la combinazione migliore di partizioni Kafka e connettori multithread per bilanciare prestazioni e costi ottimali. Più istanze Precisly Capture e Dispatcher possono aumentare i costi a causa del maggiore consumo di MIPS (milioni di istruzioni al secondo). + Evita di aggiungere logica di manipolazione e trasformazione dei dati ai connettori del database. A tale scopo, utilizzate Precisly Apply Engine, che fornisce tempi di elaborazione in microsecondi. + Crea chiamate periodiche di richiesta o controllo dello stato di salute al database (*heartbeats*) nei connettori del database per riscaldare frequentemente la connessione e ridurre la latenza. + Implementa la logica di convalida del pool di thread per comprendere le attività in sospeso nella coda dei thread e attendi che tutti i thread vengano completati prima del prossimo sondaggio di Kafka. Ciò consente di evitare la perdita di dati in caso di arresto anomalo di un nodo, contenitore o processo. + Esponi le metriche di latenza attraverso gli endpoint sanitari per migliorare le capacità di osservabilità tramite dashboard e meccanismi di tracciamento. ## Epiche ### Prepara l'ambiente di origine (locale) | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura il processo mainframe (batch o utilità online) per avviare il processo CDC dai database mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingegnere del mainframe | | Attiva i flussi di log del database mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Specialista in database mainframe | | Utilizzate il componente Capture per acquisire i record CDC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingegnere mainframe, Precisly Connect SME | | Configura il componente Publisher per ascoltare il componente Capture. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingegnere mainframe, Precisly Connect SME | | Esegui il provisioning di Amazon EKS Anywhere nell'ambiente distribuito locale. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingegnere | | Distribuisci e configura il componente Dispatcher nell'ambiente distribuito per pubblicare gli argomenti nel cloud AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingegnere, Precisly Connect SME | ### Preparare l'ambiente di destinazione (AWS) | Operazione | Description | Competenze richieste | | --- | --- | --- | | Effettua il provisioning di un cluster Amazon EKS nella regione AWS designata. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingegnere, amministratore di rete | | Esegui il provisioning di un cluster MSK e configura gli argomenti Kafka applicabili. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingegnere, amministratore di rete | | Configura il componente Apply Engine per ascoltare gli argomenti di Kafka replicati. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Precisamente Connect SME | | Effettua il provisioning di istanze DB nel cloud AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingegnere dei dati, ingegnere DevOps | | Configura e distribuisci connettori di database per ascoltare gli argomenti pubblicati da Apply Engine. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Sviluppatore di app, architetto del cloud, ingegnere dei dati | ### Configura la continuità aziendale e il disaster recovery | Operazione | Description | Competenze richieste | | --- | --- | --- | | Definisci gli obiettivi di disaster recovery per le tue applicazioni aziendali. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Architetto del cloud, ingegnere dei dati, proprietario dell'app | | Progetta strategie di disaster recovery basate su RTO/RPO definiti. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Architetto del cloud, ingegnere dei dati | | Fornisci cluster e configurazioni di disaster recovery. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingegnere, amministratore di rete, architetto cloud | | Testa la pipeline CDC per il disaster recovery. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Proprietario dell'app, ingegnere dei dati, architetto cloud | ## Risorse correlate **Risorse AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Espressioni di condizione con Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) + [Amazon EKS](https://docs.aws.amazon.com/eks/index.html) + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) + [Amazon ElasticCache](https://docs.aws.amazon.com/elasticache/index.html) + [Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/?icmpid=docs_homepage_databases) + [Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) + [Amazon RDS e Amazon Aurora](https://docs.aws.amazon.com/rds/index.html) + [Amazon VPC](https://docs.aws.amazon.com/vpc/index.html) **Risorse Precisly Connect** + [Panoramica di Precisly Connect](https://www.precisely.com/product/precisely-connect/connect) + [Modifica l'acquisizione dei dati con Precisly Connect](https://help.precisely.com/r/Connect-CDC-SQData/4.1/en-US/Connect-CDC-SQData-Installation/Connect-CDC-SQData-Architecture) **Risorse confluenti** + [Consumo di messaggi multithread con Apache Kafka Consumer](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) # Pianifica i lavori per Amazon RDS for PostgreSQL e Aurora PostgreSQL utilizzando Lambda e Secrets Manager *Yaser Raja, Amazon Web Services* ## Riepilogo Per i database e i database locali ospitati su istanze Amazon Elastic Compute Cloud EC2 (Amazon), gli amministratori di database utilizzano spesso l'utilità **cron per pianificare i lavori.** **Ad esempio, un lavoro per l'estrazione dei dati o un lavoro per l'eliminazione dei dati può essere facilmente pianificato utilizzando cron.** Per questi lavori, le credenziali del database sono in genere codificate o archiviate in un file di proprietà. **Tuttavia, quando esegui la migrazione ad Amazon Relational Database Service (Amazon RDS) o Amazon Aurora PostgreSQL Compatible Edition, perdi la possibilità di accedere all'istanza host per pianificare cron job.** Questo modello descrive come utilizzare AWS Lambda e pianificare i lavori per Gestione dei segreti AWS i database compatibili con Amazon RDS for PostgreSQL e Aurora PostgreSQL dopo la migrazione. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS + Un database compatibile con Amazon RDS per PostgreSQL o Aurora PostgreSQL **Limitazioni** + Un processo deve essere completato entro 15 minuti, che è il limite di timeout della funzione Lambda. [Per altri limiti, consulta la AWS Lambda documentazione.](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + Il codice Job deve essere scritto in un [linguaggio supportato da Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). ## Architecture **Stack tecnologico di origine** Questo stack include lavori scritti in linguaggi come Bash, Python e Java. **Le credenziali del database sono memorizzate nel file delle proprietà e il lavoro viene pianificato utilizzando Linux cron.** **Stack tecnologico Target** Questo stack ha una funzione Lambda che utilizza le credenziali archiviate in Secrets Manager per connettersi al database ed eseguire l'attività. La funzione Lambda viene avviata a intervalli pianificati utilizzando Amazon Events. CloudWatch **Architettura Target** ![\[CloudWatch evento che avvia una funzione Lambda che pianifica i lavori per l'istanza DB RDS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/8e0d1c90-0599-4909-a800-26a89b87f686/images/61f9ca34-9157-4565-96ba-5234d389ac2a.png) ## Tools (Strumenti) + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) offre un flusso quasi in tempo reale di eventi di sistema che descrivono i cambiamenti nelle AWS risorse. Utilizzando semplici regole che puoi configurare rapidamente, puoi abbinare gli eventi e indirizzarli a una o più funzioni o flussi di destinazione. CloudWatch Gli eventi vengono a conoscenza dei cambiamenti operativi man mano che si verificano. Risponde a questi cambiamenti operativi e adotta le azioni correttive necessarie, inviando messaggi per rispondere all'ambiente, attivando funzioni, apportando modifiche e acquisendo informazioni sullo stato. ****Puoi anche utilizzare CloudWatch Events per pianificare azioni automatiche che si avviano automaticamente in determinati momenti utilizzando le espressioni cron o rate.**** + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che consente di eseguire del codice senza la necessità di effettuare il provisioning o la gestione dei server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. Paghi solo per il tempo di elaborazione che consumi; non è previsto alcun addebito quando il codice non è in esecuzione. Con Lambda, puoi eseguire codice praticamente per qualsiasi tipo di applicazione o servizio di backend senza alcuna amministrazione. Lambda esegue il codice su un'infrastruttura di elaborazione ad alta disponibilità e gestisce tutte le risorse di calcolo, tra cui la manutenzione di server e sistemi operativi, il provisioning della capacità e il ridimensionamento automatico, il monitoraggio del codice e la registrazione. Tutto ciò che devi fare è fornire il codice in una delle [lingue supportate da Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). + [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)ti aiuta a proteggere i segreti per l'accesso alle tue applicazioni, servizi e risorse IT. Puoi ruotare, gestire e recuperare facilmente le credenziali del database, le chiavi API e altri segreti durante tutto il loro ciclo di vita. Gli utenti e le applicazioni recuperano i segreti chiamando Secrets Manager APIs, che elimina la necessità di codificare le informazioni sensibili in testo normale. Secrets Manager offre una rotazione segreta con integrazione integrata per Amazon RDS, Amazon Redshift e Amazon DocumentDB. Il servizio è estensibile ad altri tipi di segreti, tra cui chiavi e token API. OAuth Secrets Manager consente di controllare l'accesso ai segreti utilizzando autorizzazioni granulari e di controllare centralmente la rotazione segreta per le risorse nei servizi di terze parti e in locale. Cloud AWS ## Epiche ### Memorizza le credenziali del database in Secrets Manager | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un utente del database per la funzione Lambda. | È buona norma utilizzare utenti di database separati per diverse parti dell'applicazione. Se esiste già un utente del database separato per i tuoi cron job, usalo. Altrimenti, crea un nuovo utente del database. Per ulteriori informazioni, consulta [Gestione degli utenti e dei ruoli PostgreSQL (post del blog](https://aws.amazon.com/blogs/database/managing-postgresql-users-and-roles/)).AWS | DBA | | Memorizza le credenziali del database come segreto in Secrets Manager. | Segui le istruzioni riportate in [Creare un database segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) (documentazione di Secrets Manager). | DBA, DevOps | ### Crea il codice per la funzione Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Scegli un linguaggio di programmazione supportato da Lambda. | Per un elenco delle lingue supportate, consulta [Lambda runtimes (documentazione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) Lambda). | Developer | | Scrivi la logica per recuperare le credenziali del database da Secrets Manager. | Per un codice di esempio, vedi [Come fornire in modo sicuro le credenziali del database alle funzioni Lambda utilizzando Gestione dei segreti AWS](https://aws.amazon.com/blogs/security/how-to-securely-provide-database-credentials-to-lambda-functions-by-using-aws-secrets-manager/) (AWS post del blog). | Developer | | Scrivi la logica per eseguire l'attività pianificata del database. | Esegui la migrazione del codice esistente per il processo di pianificazione che stai utilizzando in locale alla funzione Lambda. Per ulteriori informazioni, consulta [Implementazione delle funzioni Lambda (documentazione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-deploy-functions.html) Lambda). | Developer | ### Distribuisci il codice e crea la funzione Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea il pacchetto di distribuzione della funzione Lambda. | Questo pacchetto contiene il codice e le sue dipendenze. Per ulteriori informazioni, consulta [Pacchetti di distribuzione](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) (documentazione Lambda). | Developer | | Creazione della funzione Lambda | Nella console Lambda, scegli **Crea funzione**, inserisci il nome di una funzione, scegli l'ambiente di runtime, quindi scegli **Crea** funzione. | DevOps | | Carica il pacchetto di distribuzione. | Scegli la funzione Lambda che hai creato per aprirne la configurazione. Puoi scrivere il codice direttamente nella sezione codice o caricare il pacchetto di distribuzione. Per caricare il pacchetto, vai alla sezione **Codice funzione**, scegli il **tipo di immissione del codice** per caricare un file.zip, quindi seleziona il pacchetto. | DevOps | | Configura la funzione Lambda in base alle tue esigenze. | Ad esempio, puoi impostare il parametro **Timeout** sulla durata prevista per la funzione Lambda. Per ulteriori informazioni, consulta [Configurazione delle opzioni delle funzioni](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) (documentazione Lambda). | DevOps | | Imposta le autorizzazioni per il ruolo della funzione Lambda per accedere a Secrets Manager. | Per istruzioni, consulta [Utilizzare i segreti nelle AWS Lambda funzioni](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_lambda.html) (documentazione di Secrets Manager). | DevOps | | Prova la funzione Lambda. | Avvia manualmente la funzione Lambda per assicurarti che funzioni come previsto. | DevOps | ### Pianifica la funzione Lambda utilizzando Events CloudWatch | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una regola per eseguire la funzione Lambda secondo una pianificazione. | Pianifica la funzione Lambda utilizzando CloudWatch Events. Per istruzioni, consulta [Pianifica le funzioni Lambda utilizzando CloudWatch gli eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/RunLambdaSchedule.html) (tutorial sugli CloudWatch eventi). | DevOps | ## Risorse correlate + [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [Guida introduttiva a Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) + [Creazione di una regola per CloudWatch gli eventi che si attiva su un evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html) + [AWS Lambda Limiti](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + [Interroga il AWS database dalla tua applicazione serverless](https://aws.amazon.com/blogs/database/query-your-aws-database-from-your-serverless-application/) (post sul blog) # Invia notifiche per un'istanza di database Amazon RDS for SQL Server utilizzando un server SMTP locale e Database Mail *Nishad Mankar, Amazon Web Services* ## Riepilogo [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver16) (documentazione Microsoft) invia messaggi di posta elettronica, come notifiche o avvisi, da un database di Microsoft SQL Server utilizzando un server SMTP (Simple Mail Transfer Protocol). La documentazione di Amazon Relational Database Service (Amazon RDS) per Microsoft SQL Server fornisce istruzioni per utilizzare Amazon Simple Email Service (Amazon SES) come server SMTP per Database Mail. Per ulteriori informazioni, consulta [Utilizzo di Database Mail in Amazon RDS for SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html). Come configurazione alternativa, questo modello spiega come configurare Database Mail per inviare e-mail da un'istanza di database Amazon RDS for SQL Server (DB) utilizzando un server SMTP locale come server di posta. ## Prerequisiti e limitazioni **Prerequisiti** + Un account AWS attivo + Un'istanza database Amazon RDS che esegue un'edizione Standard o Enterprise di SQL Server + L'indirizzo IP o il nome host del server SMTP locale + Una [regola del gruppo di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html#working-with-security-group-rules) in entrata che consente le connessioni all'istanza DB di Amazon RDS for SQL Server dall'indirizzo IP del server SMTP + Una connessione, ad esempio una connessione [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html), tra la rete locale e il cloud privato virtuale (VPC) che contiene l'istanza database Amazon RDS **Limitazioni** + Le edizioni Express di SQL Server non sono supportate. + Per ulteriori informazioni sulle limitazioni, consulta [Limitazioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport.Limits) nell'*uso di Database Mail su Amazon RDS for SQL* Server nella documentazione di Amazon RDS. **Versioni del prodotto** + Edizioni Standard ed Enterprise delle [versioni di SQL Server supportate in RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.VersionSupport) ## Architecture **Stack tecnologico Target** + Istanza di database Amazon RDS per SQL Server + Regola di inoltro di Amazon Route 53 + Posta elettronica database + Server SMTP locale + Microsoft SQL Server Management Studio (SSMS) **Architettura Target** L'immagine seguente mostra l'architettura di destinazione per questo modello. Quando si verifica un evento o un'azione che avvia una notifica o un avviso relativo all'istanza del database, Amazon RDS for SQL Server utilizza Database Mail per inviare una notifica e-mail. Database Mail utilizza il server SMTP locale per inviare l'e-mail. ![\[Amazon RDS per SQL Server utilizza un server SMTP locale per inviare notifiche e-mail agli utenti.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e5599724-43cf-4fe1-8c5a-8fca1a424993/images/47efb12f-3505-4a60-ac43-194a176e71c8.png) ## Tools (Strumenti) **Servizi AWS** + [Amazon Relational Database Service (Amazon RDS) per Microsoft SQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) Server ti aiuta a configurare, gestire e scalare un database relazionale SQL Server nel cloud AWS. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) è un servizio Web DNS altamente scalabile e disponibile. **Altri strumenti** + [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail) è uno strumento che invia messaggi di posta elettronica, come notifiche e avvisi, dal motore di database di SQL Server agli utenti. + [Microsoft SQL Server Management Studio (SSMS)](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms) è uno strumento per la gestione di SQL Server, che include l'accesso, la configurazione e l'amministrazione dei componenti di SQL Server. In questo modello, usi SSMS per eseguire i comandi SQL per configurare Database Mail su un'istanza DB di Amazon RDS for SQL Server. ## Epiche ### Abilita la connettività di rete con il server SMTP locale | Operazione | Description | Competenze richieste | | --- | --- | --- | | Rimuovi Multi-AZ dall'istanza DB RDS. | Se utilizzi un'istanza DB RDS multi-zona, converti l'istanza Multi-AZ in un'istanza Single-AZ. Al termine della configurazione di Database Mail, riconvertirai l'istanza DB in una distribuzione Multi-AZ. La configurazione di Database Mail funziona quindi sia nel nodo primario che in quello secondario. Per istruzioni, vedere [Rimozione di Multi-AZ da un'istanza DB di Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Removing). | DBA | | Crea un elenco di indirizzi consentiti per l'endpoint o l'indirizzo IP di Amazon RDS sul server SMTP locale. | Il server SMTP è esterno alla rete AWS. Sul server SMTP locale, crea un elenco di autorizzazioni che consenta al server di comunicare con l'endpoint o l'indirizzo IP in uscita per l'istanza Amazon RDS o l'istanza Amazon Elastic Compute Cloud (Amazon EC2) ospitata su Amazon RDS. Questa procedura varia da organizzazione a organizzazione. Per ulteriori informazioni sull'endpoint dell'istanza DB, vedere [Individuazione dell'endpoint e del numero di porta dell'istanza DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#sqlserver-endpoint). | DBA | | Rimuovi le restrizioni sulla porta 25. | Per impostazione predefinita, AWS limita la porta 25 sulle EC2 istanze. Per rimuovere la restrizione sulla porta 25, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html) | Informazioni generali su AWS | | Aggiungi una regola Route 53 per risolvere le query DNS per il server SMTP. | Usa Route 53 per risolvere le query DNS tra le tue risorse AWS e il server SMTP locale. È necessario creare una regola che inoltri le query DNS al dominio del server SMTP, ad esempio. `example.com` Per istruzioni, consulta [Creazione di regole di inoltro](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-rules-managing.html#resolver-rules-managing-creating-rules) nella documentazione di Route 53. | Amministratore di rete | ### Configurare Database Mail sull'istanza DB di Amazon RDS for SQL Server | Operazione | Description | Competenze richieste | | --- | --- | --- | | Abilita Database Mail. | Crea un gruppo di parametri per Database Mail, imposta il `database mail xps` parametro su e quindi associa `1` il gruppo di parametri Database Mail all'istanza DB RDS di destinazione. Per istruzioni, consulta [Enabling Database Mail](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.Enable) nella documentazione di Amazon RDS. Non procedere alla sezione *Configurazione di Database Mail* in queste istruzioni. La configurazione del server SMTP locale è diversa da quella di Amazon SES. | DBA | | Effettua la connessione all'istanza database. | Da un host bastion, usa Microsoft SQL Server Management Studio (SSMS) per connetterti all'istanza del database Amazon RDS for SQL Server. Per istruzioni, vedere [Connessione a un'istanza DB che esegue il motore di database Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html). In caso di errori, consulta i riferimenti per la risoluzione dei problemi di connessione nella sezione [Risorse correlate](#send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail-resources). | DBA | | Crea il profilo. | In SSMS, inserisci la seguente istruzione SQL per creare il profilo Database Mail. Sostituisci i valori seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Per ulteriori informazioni su questa stored procedure e sui relativi argomenti, vedere [sysmail\$1add\$1profile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) nella documentazione Microsoft.
EXECUTE msdb.dbo.sysmail_add_profile_sp| DBA | | Aggiungi i principali al profilo. | Immettere la seguente istruzione SQL per aggiungere i principali pubblici o privati al profilo Database Mail. Un *principal* è un'entità che può richiedere risorse di SQL Server. Sostituisci i valori seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Per ulteriori informazioni su questa stored procedure e sui relativi argomenti, vedere [sysmail\$1add\$1principalprofile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql) nella documentazione Microsoft.
@profile_name = 'SQL Alerts profile',
@description = 'Profile used for sending outgoing notifications using OM SMTP Server.';
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp| DBA | | Crea l'account. | Immettere la seguente istruzione SQL per creare l'account Database Mail. Sostituisci i valori seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Per ulteriori informazioni su questa stored procedure e sui relativi argomenti, vedere [sysmail\$1add\$1account\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) nella documentazione Microsoft.
@profile_name = 'SQL Alerts profile',
@principal_name = 'public',
@is_default = 1 ;
EXECUTE msdb.dbo.sysmail_add_account_sp| DBA | | Aggiungi l'account al profilo. | Immettere la seguente istruzione SQL per aggiungere l'account Database Mail al profilo Database Mail. Sostituisci i valori seguenti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Per ulteriori informazioni su questa stored procedure e sui relativi argomenti, vedere [sysmail\$1add\$1profileaccount\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql) nella documentazione Microsoft.
@account_name = 'SQL Alerts account',
@description = 'Database Mail account for sending outgoing notifications.',
@email_address = 'xyz@example.com',
@display_name = 'xyz@example.com',
@mailserver_name = 'test_smtp.example.com',
@port = 25,
@enable_ssl = 1,
@username = 'SMTP-username',
@password = 'SMTP-password';
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp| DBA | | (Facoltativo) Aggiungi Multi-AZ all'istanza DB RDS. | Se desideri aggiungere Multi-AZ con Database Mirroring (DBM) o Always On Availability Groups (AGs), consulta le istruzioni in [Aggiungere Multi-AZ a un'istanza DB di Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Adding). | DBA | ## Risorse correlate + [Utilizzo di Database Mail su Amazon RDS per SQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html) Server (documentazione Amazon RDS) + [Utilizzo dei file allegati](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.MAZ) (documentazione Amazon RDS) + [Risoluzione dei problemi di connessione all'istanza DB di SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting) (documentazione Amazon RDS) + [Impossibile connettersi all'istanza database Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Troubleshooting.html#CHAP_Troubleshooting.Connecting) (documentazione Amazon RDS) # Configura il disaster recovery per SAP su IBM Db2 su AWS *Ambarish Satarkar e Debasis Sahoo, Amazon Web Services* ## Riepilogo Questo modello delinea i passaggi per configurare un sistema di disaster recovery (DR) per carichi di lavoro SAP con IBM Db2 come piattaforma di database, in esecuzione sul cloud Amazon Web Services (AWS). L'obiettivo è fornire una soluzione a basso costo per garantire la continuità aziendale in caso di interruzione. Il modello utilizza l'approccio della [luce pilota.](https://aws.amazon.com/blogs/architecture/disaster-recovery-dr-architecture-on-aws-part-iii-pilot-light-and-warm-standby/) Implementando il DR pilota light su AWS, puoi ridurre i tempi di inattività e mantenere la continuità aziendale. L'approccio pilota si concentra sulla configurazione di un ambiente DR minimo in AWS, che include un sistema SAP e un database Db2 in standby, sincronizzato con l'ambiente di produzione. Questa soluzione è scalabile. Se necessario, è possibile estenderla a un ambiente di disaster recovery completo. ## Prerequisiti e limitazioni **Prerequisiti** + Un'istanza SAP in esecuzione su un'istanza Amazon Elastic Compute Cloud (Amazon EC2) + Un database IBM Db2 + Un sistema operativo supportato da SAP Product Availability Matrix (PAM) + Nomi host di database fisici diversi per gli host di database di produzione e di standby + Un bucket Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) in ogni [regione AWS con Replicazione multiregione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html) (CRR) abilitata **Versioni del prodotto** + Database IBM Db2 versione 11.5.7 o successiva ## Architecture **Stack tecnologico Target** + Amazon EC2 + Amazon Simple Storage Service (Amazon S3) + Amazon Virtual Private Cloud (peering VPC) + Amazon Route 53 + IBM Db2 High Availability Disaster Recovery (HADR) **Architettura di destinazione** Questa architettura implementa una soluzione DR per carichi di lavoro SAP con Db2 come piattaforma di database. Il database di produzione viene distribuito nella regione AWS 1 e un database di standby viene distribuito in una seconda regione. Il database di standby è denominato sistema DR. Il database Db2 supporta più database in standby (fino a tre). Utilizza Db2 HADR per configurare il database DR e automatizzare la spedizione dei log tra i database di produzione e quelli di standby. In caso di emergenza che renda indisponibile la Regione 1, il database di standby nella regione DR assume il ruolo di database di produzione. Gli application server SAP possono essere creati in anticipo o utilizzando [AWS Elastic Disaster Recovery](https://aws.amazon.com/disaster-recovery/) o Amazon Machine Image (AMI) per soddisfare i requisiti RTO (Recovery Time Objective). Questo modello utilizza un AMI. Db2 HADR implementa una configurazione di produzione in standby, in cui la produzione funge da server principale e tutti gli utenti sono collegati ad essa. Tutte le transazioni vengono scritte in file di registro, che vengono trasferiti al server di standby tramite TCP/IP. Il server di standby aggiorna il database locale trasferendo i record di registro trasferiti, il che aiuta a garantire che siano mantenuti sincronizzati con il server di produzione. Il peering VPC viene utilizzato in modo che le istanze nella regione di produzione e nella regione DR possano comunicare tra loro. Amazon Route 53 indirizza gli utenti finali verso le applicazioni Internet. ![\[Db2 su AWS con replica tra regioni\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/06edfa4c-0827-4d05-95cf-2d2651e74323/images/e77c1e4e-36f3-4af4-89d0-8eec72348f0a.png) 1. [Crea un'AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) del server delle applicazioni nella regione 1 e [copia l'AMI](https://repost.aws/knowledge-center/copy-ami-region) nella regione 2. Utilizza l'AMI per avviare i server nella Regione 2 in caso di emergenza. 1. Imposta la replica Db2 HADR tra il database di produzione (nella Regione 1) e il database di standby (nella Regione 2). 1. Modifica il tipo di EC2 istanza in modo che corrisponda all'istanza di produzione in caso di emergenza. 1. Nella Regione 1, `LOGARCHMETH1` è impostato su`db2remote: S3 path`. 1. Nella Regione 2, `LOGARCHMETH1` è impostato su`db2remote: S3 path`. 1. La replica tra regioni viene eseguita tra i bucket S3. ## Tools (Strumenti) **Servizi AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fornisce capacità di calcolo scalabile nel cloud AWS. Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) è un servizio Web DNS altamente scalabile e disponibile. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ti aiuta a lanciare le risorse AWS in una rete virtuale che hai definito. Questa rete virtuale è simile a una rete tradizionale che gestiresti nel tuo data center, con i vantaggi dell'utilizzo dell'infrastruttura scalabile di AWS. Questo modello utilizza il [peering VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) ## Best practice + La rete svolge un ruolo chiave nel decidere la modalità di replica HADR. Per il DR in tutte le regioni AWS, ti consigliamo di utilizzare la modalità Db2 HADR ASYNC o SUPERASYNC. + [Per ulteriori informazioni sulle modalità di replica per Db2 HADR, consulta la documentazione IBM.](https://ibm.github.io/db2-hadr-wiki/hadrSyncMode.html#Description_of_the_Modes) + Puoi utilizzare la Console di gestione AWS o l'AWS Command Line Interface (AWS CLI) [per creare una nuova AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) del tuo sistema SAP esistente. È quindi possibile utilizzare l'AMI per ripristinare il sistema SAP esistente o per creare un clone. + [AWS Systems Manager Automation](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) può aiutarti con le attività comuni di manutenzione e distribuzione di EC2 istanze e altre risorse AWS. + AWS offre diversi servizi nativi per monitorare e gestire l'infrastruttura e le applicazioni su AWS. Servizi come Amazon CloudWatch e AWS CloudTrail possono essere utilizzati rispettivamente per monitorare l'infrastruttura sottostante e le operazioni API. Per ulteriori dettagli, consulta [SAP on AWS — IBM Db2](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) HADR with Pacemaker. ## Epiche ### Prepara l'ambiente | Operazione | Description | Competenze richieste | | --- | --- | --- | | Controlla il sistema e i registri. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore AWS, amministratore SAP Basis | ### Configura i server e la replica | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea i server SAP e di database. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html)Lo stato di rollforward pending viene impostato di default dopo il ripristino del backup completo. Lo stato di rollforward pending indica che il database è in fase di ripristino e che potrebbe essere necessario applicare alcune modifiche. Per ulteriori informazioni, consulta la documentazione [IBM](https://www.ibm.com/docs/en/db2/11.5?topic=commands-rollforward-database). | Amministratore SAP Basis | | Controlla la configurazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore AWS, amministratore SAP Basis | | Imposta la replica dal DB di produzione al DB DR (utilizzando la modalità ASYNC). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore SAP Basis | ### Test delle attività di failover del DR | Operazione | Description | Competenze richieste | | --- | --- | --- | | Pianifica i tempi di inattività dell'attività di produzione per il test DR. | Assicurati di pianificare i tempi di inattività aziendali richiesti nell'ambiente di produzione per testare lo scenario di failover del DR. | Amministratore SAP Basis | | Crea un utente di prova. | Crea un utente di test (o eventuali modifiche al test) che possa essere convalidato nell'host DR per confermare la replica dei log dopo il failover DR. | Amministratore SAP Basis | | Sulla console, arresta le EC2 istanze di produzione. | In questa fase viene avviato lo spegnimento indesiderato per simulare uno scenario di emergenza. | Amministratore di sistema AWS | | Scala l' EC2 istanza DR per soddisfare i requisiti. | Sulla EC2 console, modifica il tipo di istanza nella regione DR.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | SAP Basis Admin | | Avviare l'acquisizione. | Dal sistema DR (`host2`), avvia il processo di acquisizione e richiama il database DR come principale.
@profile_name = 'SQL Alerts profile',
@account_name = 'SQL Alerts account',
@sequence_number = 1;
db2 takeover hadr on databaseFacoltativamente, è possibile impostare i seguenti parametri per regolare automaticamente l'allocazione della memoria del database in base al tipo di istanza. Il `INSTANCE_MEMORY` valore può essere deciso in base alla porzione di memoria dedicata da allocare al database Db2.by force
db2 update db cfg forVerifica la modifica utilizzando i seguenti comandi.using INSTANCE_MEMORY IMMEDIATE;
db2 get db cfg for| grep -i DATABASE_MEMORY AUTOMATIC IMMEDIATE;
db2 update db cfg forusing self_tuning_mem ON IMMEDIATE;
db2 get db cfg for| Amministratore SAP Basis | | Avvia il server delle applicazioni per SAP nella regione DR. | Utilizzando l'AMI che hai creato per il sistema di produzione, [avvia un nuovo server di applicazioni aggiuntivo](https://aws.amazon.com/premiumsupport/knowledge-center/launch-instance-custom-ami/) nella regione DR. | Amministratore SAP Basis | | Esegui la convalida prima di avviare l'applicazione SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore AWS, amministratore SAP Basis | | Avvia l'applicazione SAP sul sistema DR. | Avviare l'applicazione SAP sul sistema DR utilizzando `| grep -i MEMORY
db2 get db cfg for| grep -i self_tuning_mem
sapconrol -nr XX -function StartService| Amministratore SAP Basis | | Eseguire la convalida SAP. | Viene eseguito come test DR per fornire prove o per verificare il successo della replica dei dati nella regione DR. | Tecnico di test | ### Esegui attività di failback del DR | Operazione | Description | Competenze richieste | | --- | --- | --- | | Avvia i server SAP e di database di produzione. | Sulla console, avvia le EC2 istanze che ospitano SAP e il database nel sistema di produzione. | Amministratore SAP Basis | | Avvia il database di produzione e configura HADR. | Accedere al sistema di produzione (`host1`) e verificare che il DB sia in modalità di ripristino utilizzando il comando seguente.
sapconrol -nr XX -function StartSystem
sapconrol -nr YY -function StartService
sapconrol -nr YY -function StartSystem
db2startVerificate che lo stato HADR sia`connected`. Lo stato di replica dovrebbe essere. `peer`
db2 start HADR on db P3V as standby
db2 connect to
db2pd -dSe il database non è incoerente e non è in `connected` uno `peer` stato, potrebbero essere necessari un backup e un ripristino per sincronizzare il database (acceso`host1`) con il database attualmente attivo (`host2`nella regione DR). In tal caso, ripristina il backup del DB dal database nella regione `host2` DR al database nella regione `host1` di produzione. | Amministratore SAP Basis | | Esegui il failback del database nella regione di produzione. | In uno business-as-usual scenario normale, questo passaggio viene eseguito in un periodo di inattività programmato. Le applicazioni in esecuzione sul sistema DR vengono interrotte e il database viene riportato alla regione di produzione (Regione 1) per riprendere le operazioni dalla regione di produzione.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore SAP Basis | | Esegui la convalida prima di avviare l'applicazione SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore AWS, amministratore SAP Basis | | Avvia l'applicazione SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Amministratore SAP Basis | ## risoluzione dei problemi | Problema | Soluzione | | --- | --- | | File di registro e comandi chiave per la risoluzione dei problemi relativi all'HADR | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | | Nota SAP per la risoluzione dei problemi HADR su Db2 UDB | Fare riferimento alla [Nota SAP 1154013 - DB6](https://service.sap.com/sap/support/notes/1154013): problemi del DB in ambiente HADR. (Sono necessarie le credenziali del portale SAP per accedere a questa nota.) | ## Risorse correlate + [Approcci di disaster recovery per database Db2 su AWS](https://aws.amazon.com/blogs/architecture/disaster-recovery-approaches-for-db2-databases-on-aws/) (post sul blog) + [SAP su AWS — IBM Db2 HADR con Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) + [Procedura dettagliata per configurare la replica HADR tra database DB2 ](https://www.ibm.com/support/pages/step-step-procedure-set-hadr-replication-between-db2-databases) + [Wiki Db2 HADR](https://ibm.github.io/db2-hadr-wiki/index.html) ## Informazioni aggiuntive Utilizzando questo modello, è possibile configurare un sistema di disaster recovery per un sistema SAP in esecuzione sul database Db2. In una situazione di emergenza, l'azienda dovrebbe essere in grado di continuare a rispettare i requisiti RTO (Recovery Time Objective) e RPO (Recovery Point Objective) definiti: + L'**RTO** è il ritardo massimo accettabile tra l'interruzione del servizio e il ripristino del servizio. Questo determina ciò che viene considerato un intervallo di tempo accettabile in caso di indisponibilità del servizio. + L'**RPO** è il periodo di tempo massimo accettabile dall'ultimo punto di ripristino dei dati. Questo determina ciò che si considera una perdita di dati accettabile tra l’ultimo punto di ripristino e l’interruzione del servizio. Per informazioni FAQs relative all'HADR, consulta la [nota SAP \$11612105 - DB6: Domande frequenti su Db2 High Availability Disaster Recovery](https://launchpad.support.sap.com/#/notes/1612105) (HADR). (Sono necessarie le credenziali del portale SAP per accedere a questa nota.) # Configura una CI/CD pipeline per la migrazione del database utilizzando Terraform *Dott. Rahul Sharad Gaikwad, Ashish Bhatt, Aniket Dekate, Ruchika Modi, Tamilselvan P, Nadeem Rahaman, Aarti Rajput e Naveen Suthar, Amazon Web Services* ## Riepilogo Questo modello prevede la creazione di una pipeline di integrazione e distribuzione continua (CI/CD) per la gestione delle migrazioni dei database in modo affidabile e automatizzato. Copre il processo di fornitura dell'infrastruttura necessaria, la migrazione dei dati e la personalizzazione delle modifiche allo schema utilizzando Terraform, che è uno strumento di infrastruttura come codice (IaC). In particolare, il modello imposta una CI/CD pipeline per migrare un database Microsoft SQL Server locale su Amazon Relational Database Service (Amazon RDS) su. AWS Puoi anche utilizzare questo modello per migrare un database SQL Server che si trova su una macchina virtuale (VM) o in un altro ambiente cloud su Amazon RDS. Questo modello affronta le seguenti sfide associate alla gestione e alla distribuzione dei database: + Le implementazioni manuali dei database richiedono molto tempo, sono soggette a errori e mancano di coerenza tra gli ambienti. + Il coordinamento del provisioning dell'infrastruttura, delle migrazioni dei dati e delle modifiche allo schema può essere complesso e difficile da gestire. + Garantire l'integrità dei dati e ridurre al minimo i tempi di inattività durante gli aggiornamenti del database è fondamentale per i sistemi di produzione. Questo modello offre i seguenti vantaggi: + Semplifica il processo di aggiornamento e implementazione delle modifiche al database implementando una CI/CD pipeline per le migrazioni dei database. Ciò riduce il rischio di errori, garantisce la coerenza tra gli ambienti e riduce al minimo i tempi di inattività. + Aiuta a migliorare l'affidabilità, l'efficienza e la collaborazione. Consente un time-to-market più rapido e tempi di inattività ridotti durante gli aggiornamenti del database. + Ti aiuta ad adottare DevOps pratiche moderne per la gestione dei database, il che porta a una maggiore agilità, affidabilità ed efficienza nei processi di distribuzione del software. ## Prerequisiti e limitazioni **Prerequisiti** + Un attivo Account AWS + Terraform 0.12 o versione successiva installato sul computer locale (per le istruzioni, consulta la documentazione di [Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)) + [Terraform AWS Provider versione 3.0.0 o successiva da HashiCorp (consulta il repository di questo provider) GitHub ](https://github.com/hashicorp/terraform-provider-aws) + Politica sui privilegi minimi AWS Identity and Access Management (IAM) (vedi il post sul blog [Tecniche per scrivere](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/) politiche IAM con privilegi minimi) ## Architecture Questo modello implementa la seguente architettura, che fornisce l'infrastruttura completa per il processo di migrazione del database. ![\[Architettura di pipeline CI/CD per la migrazione di un database SQL Server locale su Amazon RDS su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/a1e95458-419a-4de9-85ef-b17d8340700a.png) In questa architettura: + Il database di origine è un database SQL Server locale, su una macchina virtuale (VM) o ospitato da un altro provider di servizi cloud. Il diagramma presuppone che il database di origine si trovi in un data center locale. + I data center locali AWS sono collegati tramite una VPN o una connessione. AWS Direct Connect Ciò fornisce comunicazioni sicure tra il database di origine e l' AWS infrastruttura. + Il database di destinazione è un database Amazon RDS ospitato all'interno del cloud privato virtuale (VPC) con l'aiuto di una AWS pipeline di provisioning del database. + AWS Database Migration Service (AWS DMS) replica il database locale su. AWS Viene utilizzato per configurare la replica del database di origine nel database di destinazione. Il diagramma seguente mostra l'infrastruttura configurata con diversi livelli del processo di migrazione del database, che prevede il provisioning, la AWS DMS configurazione e la convalida. ![\[Dettagli della pipeline CI/CD del processo di migrazione dall'ambiente locale ad AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/3aca17e5-6fd7-4317-b578-ab5e485c6efb.png) In questo processo: + La pipeline di convalida convalida tutti i controlli. La pipeline integrata passa alla fase successiva quando tutte le convalide necessarie sono state completate. + La pipeline di provisioning del DB è composta da varie AWS CodeBuild fasi che eseguono azioni Terraform sul codice Terraform fornito per il database. Una volta completati questi passaggi, distribuisce le risorse nell'obiettivo. Account AWS + La AWS DMS pipeline è composta da varie CodeBuild fasi che eseguono i test e quindi forniscono l' AWS DMS infrastruttura per eseguire la migrazione utilizzando IaC. ## Tools (Strumenti) **Servizi AWS e strumenti** + [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)è un servizio di integrazione continua completamente gestito che compila codice sorgente, esegue test e produce pacchetti ready-to-deploy software. + [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)è un servizio di distribuzione continua completamente gestito che consente di automatizzare le pipeline di rilascio per aggiornamenti rapidi e affidabili di applicazioni e infrastrutture. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) ti aiuta a configurare, gestire e scalare un database relazionale in. Cloud AWS + [Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) S3) è un servizio di storage di oggetti che offre scalabilità, disponibilità dei dati, sicurezza e prestazioni. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ti aiuta a migrare gli archivi di dati all'interno Cloud AWS o tra combinazioni di configurazioni cloud e locali. **Altri servizi** + [Terraform](https://www.terraform.io/) è uno strumento IaC HashiCorp che ti aiuta a creare e gestire risorse cloud e locali. **Archivio di codice** Il codice per questo modello è disponibile nel GitHub [Database Migration DevOps Framework utilizzando il repository di esempi Terraform](https://github.com/aws-samples/aws-terraform-db-migration-framework-samples). ## Best practice + Implementa test automatici per la migrazione del database per verificare la correttezza delle modifiche allo schema e l'integrità dei dati. Ciò include test unitari, test di integrazione e end-to-end test. + Implementa una solida strategia di backup e ripristino per i tuoi database, soprattutto prima della migrazione. Ciò garantisce l'integrità dei dati e fornisce un'opzione di riserva in caso di guasti. + Implementa una solida strategia di rollback per annullare le modifiche al database in caso di errori o problemi durante la migrazione. Ciò potrebbe comportare il ripristino a uno stato precedente del database o il ripristino di singoli script di migrazione. + Imposta meccanismi di monitoraggio e registrazione per tenere traccia dell'avanzamento e dello stato delle migrazioni del database. Questo ti aiuta a identificare e risolvere rapidamente i problemi. ## Epiche ### Configura la tua workstation locale | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura e configura Git sulla tua workstation locale. | Installa e configura Git sulla tua workstation locale seguendo le istruzioni nella [documentazione di Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). | DevOps ingegnere | | Crea una cartella di progetto e aggiungi i file dal GitHub repository. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingegnere | ### Fornisci l'architettura di destinazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Aggiorna i parametri richiesti. | Il `ssm-parameters.sh` file memorizza tutti i AWS Systems Manager parametri richiesti. Puoi configurare questi parametri con i valori personalizzati per il tuo progetto.Nella `setup/db-ssm-params` cartella sulla workstation locale, aprite il `ssm-parameters.sh` file e impostate questi parametri prima di eseguire la CI/CD pipeline. | DevOps ingegnere | | Inizializza la configurazione Terraform. | Nella `db-cicd-integration` cartella, inserisci il seguente comando per inizializzare la tua directory di lavoro che contiene i file di configurazione Terraform:-hadr
terraform init| DevOps ingegnere | | Visualizza l'anteprima del piano Terraform. | Per creare un piano Terraform, inserisci il seguente comando:
terraform plan -var-file="terraform.sample"Terraform valuta i file di configurazione per determinare lo stato di destinazione per le risorse dichiarate. Quindi confronta lo stato di destinazione con lo stato attuale e crea un piano. | DevOps ingegnere | | Verifica il piano. | Rivedi il piano e conferma che configuri l'architettura richiesta nel tuo obiettivo Account AWS. | DevOps ingegnere | | Distribuire la soluzione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingegnere | ### Verifica della distribuzione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Convalida la distribuzione. | Verifica lo stato della `db-cicd-integration` pipeline per confermare che la migrazione del database sia completa.1. Accedi a Console di gestione AWS, quindi apri la [AWS CodePipeline console](https://console.aws.amazon.com/codesuite/codepipeline/home).2. Nel riquadro di navigazione, scegli **Pipelines.**3. Scegliete la `db-cicd-integration` pipeline.4. Verifica che l'esecuzione della pipeline sia stata completata correttamente. | DevOps ingegnere | ### Pulisci l'infrastruttura dopo l'uso | Operazione | Description | Competenze richieste | | --- | --- | --- | | Pulisci l'infrastruttura. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingegnere | ## Risorse correlate **AWS documentazione** + [Iniziare con un prodotto Terraform](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) **Documentazione Terraform** + [Installazione di Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli) + [Configurazione del backend Terraform](https://developer.hashicorp.com/terraform/language/backend) + [Documentazione Terraform Provider AWS](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) # Configura un cluster di failover di Microsoft SQL Server su Amazon EC2 utilizzando FSx per Windows File Server *Sweta Krishna e Ramesh Babu Donti, Amazon Web Services* ## Riepilogo L'edizione Microsoft SQL Server Standard con un'istanza cluster di failover (FCI) può fornire un'alternativa più economica a SQL Server Enterprise. La configurazione di SQL FCI richiede lo storage di file condiviso tra i nodi e [Amazon FSx for Windows File Server](https://aws.amazon.com/fsx/windows/) fornisce uno storage completamente gestito che si replica automaticamente in modo sincrono tra le zone di disponibilità. Amazon FSx riduce i costi di storage utilizzando la deduplicazione dei dati integrata per le condivisioni di file generiche, che elimina la necessità di mantenere soluzioni di terze parti. Amazon supporta FSx anche quanto segue: + Paghi solo per ciò che usi senza costi o impegni iniziali. + Configura FCI manualmente FSx come storage condiviso. + Utilizzalo FSx come testimone della condivisione dei file per il tuo cluster SQL. + Amazon FSx per Windows File Server supporta Server Message Block (SMB) 3.0 per le condivisioni di file sempre disponibili, rendendolo adatto per le distribuzioni FCI di SQL Server. ## Prerequisiti e limitazioni **Prerequisiti** + [Account AWS](https://aws.amazon.com/account/)Attivo. + Autorizzazioni per creare e gestire risorse Amazon Virtual Private Cloud (Amazon VPC), istanze Amazon Elastic Compute Cloud ( EC2Amazon), gruppi di sicurezza AWS Identity and Access Management e ruoli (IAM). + AWS Managed Microsoft AD o il tuo Active Directory locale. + Un utente del dominio Active Directory con l'[autorizzazione necessaria](https://learn.microsoft.com/en-us/windows-server/failover-clustering/configure-failover-cluster-accounts) per configurare un cluster di failover. + Regole dei gruppi di sicurezza per le [porte SQL Server FCI e Microsoft Active Directory](https://docs.aws.amazon.com/whitepapers/latest/access-workspaces-with-access-cards/ip-address-and-port-requirements.html) per una connettività ibrida sicura. + Un [account di servizio](https://learn.microsoft.com/en-us/sql/database-engine/configure-windows/configure-windows-service-accounts-and-permissions?view=sql-server-ver16#sql-server-failover-cluster-instance) in Active Directory per SQL Server configurato con le autorizzazioni appropriate tra i nodi SQL. + Amazon FSx per Windows File Server in un cluster di failover. + File binari di installazione di SQL Server. **Limitazioni** + Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la [pagina Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. **Versioni del prodotto** + Amazon EC2 per Windows Server 2012 R2 o versione successiva + Amazon FSx per Windows File Server con tutte le versioni correnti di Windows Server + Amazon FSx for NetApp ONTAP come alternativa allo storage condiviso + SQL Server 2012/2016/2019/2022 ## Architecture **Stack tecnologico** + Amazon EC2 + File server Amazon FSx per Windows + Amazon VPC + AWS Directory Service + AWS Systems Manager + IAM **Architettura Target** Il diagramma seguente mostra l'architettura di alto livello di Microsoft SQL Server FCI su Amazon utilizzando EC2 Amazon FSx for Windows File Server. ![\[Diagramma dell'architettura per Microsoft Server FCI su Amazon utilizzando EC2 Amazon FSx per Windows File Server.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/208bf64a-8fef-4019-944a-723372450885/images/ba0c9169-9536-41c3-ae8e-7264dcc3e1ad.png) **Infrastruttura di rete** + Amazon VPC fornisce un contenitore di rete che si estende su tre zone di disponibilità. + Le sottoreti private forniscono sottoreti isolate in ogni zona di disponibilità per la distribuzione delle risorse. **Livello di elaborazione** + Amazon EC2 contiene un nodo 1 del cluster SQL Server, distribuito nella Zona di disponibilità 1 come parte del Windows Server Failover Cluster (WSFC). + Amazon EC2 contiene un nodo 2 del cluster SQL Server, distribuito nella Zona di disponibilità 2 come parte del WSFC. + Il cluster WSFC collega entrambi i nodi SQL Server per la funzionalità di failover. **Livello di archiviazione per Amazon FSx per Windows File Server** ** FSx Implementazione Multi-AZ (che copre le zone di disponibilità 1 e 2)** + Un FSx file system primario nella Zona di disponibilità 1 ospita dati e file di registro attivi di SQL Server. + Un FSx file system secondario nella Zona di disponibilità 2 offre funzionalità di failover automatico. + Una condivisione di file SMB condivisa (\$1\$1 fsx.domain\$1 sqlshare), accessibile da entrambi i nodi del cluster per i database SQL Server. **Implementazione Single-AZ (in) FSx AZ3** + Amazon FSx File Server Witness in Availability Zone 3 funge da testimone del quorum del cluster. + Il file share witness (`\\fsx.domain\witness`) mantiene il quorum del cluster e previene gli scenari split-brain. **Servizi di directory** + AWS Managed Microsoft AD fornisce i servizi di autenticazione e dominio di Windows necessari per la funzionalità del cluster. **Funzionalità di elevata disponibilità** + I componenti Multi-AZ offrono tolleranza agli errori in tutte le zone di disponibilità. + FSx il file server di standby fornisce il failover automatico in caso di guasto del server primario. + File share witness consente la gestione del quorum del cluster nella zona di disponibilità 3 per garantire il corretto funzionamento del cluster in caso di guasti. + Domain è integrato con AWS Managed Microsoft AD per un'autenticazione Windows senza interruzioni. ## Tools (Strumenti) **Servizi AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornisce capacità di elaborazione scalabile in. Cloud AWS Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente. + [Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) fornisce file system che supportano i protocolli di connettività standard del settore e offrono disponibilità e replica elevate in tutto il mondo. Regioni AWS + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ti aiuta a lanciare AWS risorse in una rete virtuale che hai definito. Questa rete virtuale è simile a una comune rete da gestire all'interno del proprio data center, ma con i vantaggi dell'infrastruttura scalabile di AWS. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)consente ai carichi di lavoro e alle risorse compatibili con le directory di AWS utilizzare Microsoft Active Directory in. Cloud AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html)ti aiuta a gestire le applicazioni e l'infrastruttura in esecuzione in. Cloud AWS Semplifica la gestione delle applicazioni e delle risorse, riduce i tempi di rilevamento e risoluzione dei problemi operativi e aiuta a gestire le AWS risorse in modo sicuro su larga scala. ## Best practice + Posiziona le istanze di database in sottoreti private per proteggerle dall'accesso pubblico da Internet, pur consentendo loro di connettersi ed eseguire aggiornamenti. Servizi AWS + Per le best practice generali, consulta [Best practice per la distribuzione di Microsoft SQL Server su Amazon EC2](https://docs.aws.amazon.com/prescriptive-guidance/latest/sql-server-ec2-best-practices/welcome.html). + Da utilizzare PowerShell per amministrare il tuo file server Amazon FSx for Windows, consulta [Amministrazione FSx per i file system Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/administering-file-systems.html). ## Epiche ### Crea e configura EC2 nodi Amazon per SQL Server | Operazione | Description | Competenze richieste | | --- | --- | --- | | Aggiungi nomi e tag. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Scegli un AMI Windows. | Scegli un'Amazon Machine Image (AMI) per Windows che soddisfi i requisiti di SQL Server. | DBA | | Selezione di un tipo di istanza. | Seleziona un tipo di EC2 istanza Amazon che soddisfi i tuoi requisiti. | DBA | | Usa una key pair. | Puoi usare una key pair per connetterti in modo sicuro alla tua istanza. Assicurati di avere accesso alla coppia di key pair selezionata prima di avviare l'istanza. | DBA | | Configurazione delle impostazioni di rete. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Configura impostazioni di rete avanzate. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Configura l'archiviazione. | Configura lo spazio di archiviazione totale richiesto e scegli il tipo di archiviazione richiesto. | DBA | | Configura i dettagli avanzati e avvia l'istanza. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Crea il nodo 2. | Ripeti questi passaggi per creare e configurare il nodo 2. | DBA | ### Installa e configura il cluster di failover di Windows Server sui nodi 1 e 2 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Accedere al nodo 1. | Accedi all' EC2 istanza Amazon di Windows come amministratore. | DBA | | Installa le funzionalità FCI sul nodo 1. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Accedere al nodo 2. | Accedi all' EC2 istanza Amazon di Windows come amministratore. | DBA | | Installa le funzionalità FCI sul nodo 2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Aggiungi nodi al cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Porta il cluster online. | Per portare il cluster online, aggiorna gli indirizzi IP statici di entrambi i nodi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Convalida il cluster. | Accedi a **Failover Cluster Manager** e verifica che le risorse principali del cluster siano online. | DBA | ### Installa SQL Server sui nodi 1 e 2 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Accedere al server. | Accedi all' EC2 istanza Amazon come amministratore. | DBA | | Monta i binari SQL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | | | Aggiungere il nodo 2 al cluster di failover. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | ### Configurare Amazon FSx File Share Witness | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura le impostazioni del quorum. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Recupera i dettagli DNS. | Nella FSx console Amazon, scegli **Managed AD** e poi **Allega**. Il DNS dovrebbe avere il seguente formato: `\\example.example.net\share` | DBA | | Configura il file share witness. | Scegli il **percorso di condivisione dei FSx file di Amazon** e poi **Finish**. | DBA | ## Risorse correlate **AWS resources** + [Amazon FSx per Windows File Server](https://www.youtube.com/watch?v=IMDWTIShlyI) (video) + [Approfondimento su Amazon FSx per Windows File Server](https://www.youtube.com/watch?v=_x_Geur93oc) (video) + [Come distribuire un cluster di failover di SQL Server con Amazon EBS Multi-Attach su Windows Server](https://aws.amazon.com/blogs/modernizing-with-aws/how-to-deploy-a-sql-server-failover-cluster-with-amazon-ebs-multi-attach-on-windows-server/) (post di blog)AWS + [Semplifica le distribuzioni ad alta disponibilità di Microsoft SQL Server utilizzando Amazon FSx per Windows File Server](https://aws.amazon.com/blogs/storage/simplify-your-microsoft-sql-server-high-availability-deployments-using-amazon-fsx-for-windows-file-server/) (AWS post sul blog) + [Implementazioni ad alta disponibilità di SQL Server con Amazon FSx for NetApp ONTAP](https://aws.amazon.com/blogs/modernizing-with-aws/sql-server-high-availability-amazon-fsx-for-netapp-ontap/) (AWS post sul blog) + [Utilizzo FSx per Windows File Server con Microsoft SQL Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/sql-server.html) + [Che cos'è FSx per Windows File Server?](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) **Altre risorse** + [Creare un cluster di failover](https://learn.microsoft.com/en-us/windows-server/failover-clustering/create-failover-cluster?pivots=windows-admin-center) ## Informazioni aggiuntive **Configurazione del file share witness** Assicurati di essere connesso al file system da entrambi i nodi aggiungendo regole nel gruppo di FSx sicurezza di Amazon che consentono le connessioni in entrata. La porta SMB dovrebbe essere consentita. Ad esempio, se il nome DNS è`\\example.example.com\share`, usa. `\\example.example.com\share` Utilizza lo stesso valore per il controllo della condivisione dei file nel cluster di disponibilità Always On. Completa i seguenti passaggi per configurare il file share witness: 1. Usa RDP per connetterti alla tua EC2 istanza Amazon. 1. Vai a **Failover Cluster Manager**. 1. Apri il menu contestuale (fai clic con il pulsante destro del mouse) e scegli **Altre azioni**. 1. Scegli **Configura le impostazioni del quorum del cluster**. 1. Scegli **Next (Successivo)**. 1. Seleziona la **configurazione Quorum** e configura un file share witness. 1. Fornisci il nome DNS. 1. Esamina il riepilogo, quindi scegli **Fine.** Il file share witness dovrebbe essere online nella sezione Risorse **principali del cluster**. # Configurare un' HA/DR architettura per Oracle E-Business Suite su Amazon RDS Custom con un database di standby attivo *Simon Cunningham, Jaydeep Nandy e Nitin Saxena, Amazon Web Services* ## Riepilogo Questo modello descrive come progettare una soluzione Oracle E-Business su Amazon Relational Database Service (Amazon RDS) Custom per l'alta disponibilità (HA) e il disaster recovery (DR) configurando un database di replica di lettura personalizzato Amazon RDS in un'altra zona di disponibilità di Amazon Web Services (AWS) e convertendolo in un database di standby attivo. La creazione della replica di lettura personalizzata di Amazon RDS è completamente automatizzata tramite la Console di gestione AWS. Questo modello non descrive i passaggi per aggiungere livelli di applicazione aggiuntivi e file system condivisi, che possono anche far parte di un'architettura. HA/DR *Per ulteriori informazioni su questi argomenti, vedere le seguenti note di supporto Oracle: 1375769.1, 1375670.1 e 1383621.1 (sezione 5, Opzioni di clonazione avanzate).* (L'accesso richiede un account [Oracle Support](https://support.oracle.com/portal/)). Per migrare il sistema E-Business Suite a un'architettura single-tier, Single-AZ su Amazon Web Services (AWS), consulta lo schema [Migrate Oracle E-Business Suite](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) to Amazon RDS Custom. Oracle E-Business Suite è una soluzione Enterprise Resource Planning (ERP) per automatizzare processi a livello aziendale come quelli finanziari, delle risorse umane, delle catene di approvvigionamento e della produzione. Ha un'architettura a tre livelli: client, applicazione e database. In precedenza, dovevi eseguire il database E-Business Suite su un'[istanza Amazon Elastic Compute Cloud (Amazon EC2) autogestita,](https://aws.amazon.com/ec2/) ma ora puoi trarre vantaggio da [Amazon](https://aws.amazon.com/rds/custom/) RDS Custom. ## Prerequisiti e limitazioni **Prerequisiti** + Un'installazione esistente di E-Business Suite su Amazon RDS Custom; vedi lo schema [Migrare Oracle E-Business Suite ad](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) Amazon RDS Custom + *Se desideri modificare la replica di lettura in modalità di sola lettura e utilizzarla per trasferire i report allo standby, una licenza per [database Oracle Active Data Guard (consulta il listino prezzi commerciale di Oracle](https://www.oracle.com/corporate/pricing/) Technology)* **Limitazioni** + Limitazioni e configurazioni non supportate per i [database Oracle su Amazon](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) RDS Custom + Limitazioni associate alle repliche di [lettura di Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versioni del prodotto** Per le versioni e le classi di istanze di Oracle Database supportate da Amazon RDS Custom, consulta [Requisiti e limitazioni per Amazon RDS Custom for](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html) Oracle. ## Architecture Il diagramma seguente illustra un'architettura rappresentativa per E-Business Suite su AWS che include più zone di disponibilità e livelli di applicazione in una configurazione. active/passive Il database utilizza un'istanza DB personalizzata di Amazon RDS e una replica di lettura Amazon RDS Custom. La replica di lettura utilizza Active Data Guard per la replica in un'altra zona di disponibilità. È inoltre possibile utilizzare la replica di lettura per scaricare il traffico di lettura sul database principale e per scopi di reporting. ![\[Architettura Multi-AZ per Oracle E-Business Suite su AWS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/a17947e8-56b1-4d92-91df-096c02ff4c19/images/ffdaa2d4-123b-44a0-8d52-b1352a4eee44.png) Per ulteriori informazioni, consulta [Lavorare con le repliche di lettura per Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) nella documentazione di Amazon RDS. La replica di lettura personalizzata di Amazon RDS viene creata per impostazione predefinita come montata. [Tuttavia, se desideri trasferire alcuni carichi di lavoro di sola lettura sul database di standby per ridurre il carico sul database principale, puoi modificare manualmente la modalità delle repliche montate in sola lettura seguendo i passaggi nella sezione Epics.](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-epics) Un tipico caso d'uso in questo caso sarebbe quello di eseguire i report dal database di standby. Il passaggio alla modalità di sola lettura richiede una licenza di database in standby attiva. Quando crei una replica di lettura su AWS, il sistema utilizza il broker Oracle Data Guard sotto copertura. Questa configurazione viene generata automaticamente e configurata in modalità Maximum Performance come segue: ``` DGMGRL> show configuration Configuration - rds_dg Protection Mode: MaxPerformance Members: vis_a - Primary database vis_b - Physical standby database Fast-Start Failover: DISABLED Configuration Status: SUCCESS (status updated 58 seconds ago) ``` ## Tools (Strumenti) **Servizi AWS** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) è un servizio di database gestito per applicazioni legacy, personalizzate e confezionate che richiedono l'accesso al sistema operativo e all'ambiente di database sottostanti. Automatizza le attività e le operazioni di amministrazione del database, consentendo al contempo, in qualità di amministratore di database, di accedere e personalizzare l'ambiente di database e il sistema operativo. **Altri strumenti** + Oracle Data Guard è uno strumento che consente di creare e gestire database Oracle standby. Questo modello utilizza Oracle Data Guard per configurare un database di standby attivo su Amazon RDS Custom. ## Epiche ### Creare una replica di lettura | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea una replica di lettura dell'istanza database personalizzata di Amazon RDS. | Per creare una replica di lettura, segui le istruzioni nella [documentazione di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Create) e usa l'istanza database personalizzata di Amazon RDS che hai creato (consulta la sezione [Prerequisiti](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-prereqs)) come database di origine.Per impostazione predefinita, la replica di lettura personalizzata di Amazon RDS viene creata come standby fisico e si trova nello stato montato. Ciò è intenzionale per garantire la conformità con la licenza Oracle Active Data Guard. Segui i passaggi successivi per convertire la replica di lettura in modalità di sola lettura. | DBA | ### Cambia la replica di lettura in uno standby attivo di sola lettura | Operazione | Description | Competenze richieste | | --- | --- | --- | | Connect alla replica di lettura personalizzata di Amazon RDS. | Usa i seguenti comandi per convertire il tuo database di standby fisico in un database di standby attivo. Questi comandi richiedono una licenza Oracle Active Standby. Per ottenere una licenza, contatta il tuo rappresentante Oracle.
$ sudo su - rdsdb| DBA | | Avvia il ripristino dei file multimediali con log apply in tempo reale. | Per abilitare la funzionalità di applicazione dei log in tempo reale, utilizzate i seguenti comandi. Questi convertono e convalidano lo standby (read replica) come database in standby attivo, in modo da poter connettere ed eseguire query di sola lettura.
-bash-4.2$ sql
SQL> select process,status,sequence# from v$managed_standby;
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY MOUNTED
SQL> alter database recover managed standby database cancel;
Database altered.
Open the standby database
SQL> alter database open;
Database altered.
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY
SQL> alter database recover managed standby database using current logfile disconnect from session;| DBA | | Controlla lo stato del database. | Per verificare lo stato del database, utilizzare il seguente comando.
Database altered
SQL> select name, database_role, open_mode from v$database;| DBA | | Seleziona la modalità Redo Apply. | Per controllare la modalità Redo Apply, utilizzate il seguente comando.
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY WITH APPLY
SQL> select process,status,sequence# from v$managed_standby;| DBA | ## Risorse correlate + Esegui la [migrazione di Oracle E-Business Suite ad Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) (AWS Prescriptive Guidance) + [Utilizzo di Amazon RDS Custom](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-custom.html) (documentazione Amazon RDS) + [Utilizzo delle repliche di lettura per Amazon RDS Custom for Oracle (documentazione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) Amazon RDS) + [Amazon RDS Custom per Oracle: nuove funzionalità di controllo nell'ambiente di database](https://aws.amazon.com/blogs/aws/amazon-rds-custom-for-oracle-new-control-capabilities-in-database-environment/) (blog AWS News) + [Migrazione di Oracle E-Business Suite su AWS (white paper](https://d1.awsstatic.com/whitepapers/migrate-oracle-e-business-suite.pdf) AWS) + [Architettura di Oracle E-Business Suite su AWS](https://docs.aws.amazon.com/whitepapers/latest/overview-oracle-e-business-suite/oracle-e-business-suite-architecture-on-aws.html) (white paper AWS) # Trasmetti dati da IBM Db2, SAP, Sybase e altri database a MongoDB Atlas su AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Riepilogo Questo modello descrive i passaggi per la migrazione dei dati da IBM Db2 e altri database come database mainframe e Sybase a MongoDB Atlas su. Cloud AWS Viene utilizzato [AWS Glue](https://aws.amazon.com/glue/)per accelerare la migrazione dei dati verso MongoDB Atlas. Il modello accompagna la guida [Migrating to MongoDB Atlas sul AWS sito web Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS Fornisce le fasi di implementazione per uno degli scenari di migrazione descritti in tale guida. Per ulteriori scenari di migrazione, consulta i seguenti modelli sul sito Web AWS Prescriptive Guidance: + [Migrare un ambiente MongoDB ospitato autonomamente su MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Migrare database relazionali su MongoDB Atlas su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) Il modello è destinato ai [partner e AWS agli utenti di AWS Managed Services](https://aws.amazon.com/managed-services/partners/). ## Prerequisiti e limitazioni **Prerequisiti** + Un database di origine come SAP, Sybase, IBM Db2 e altri per la migrazione a MongoDB Atlas. + Familiarità con database come SAP, Sybase, IBM Db2, MongoDB Atlas e. Servizi AWS **Versioni del prodotto** + MongoDB versione 5.0 o successiva. ## Architecture Il diagramma seguente illustra il caricamento e lo streaming di dati in batch utilizzando AWS Glue Studio Amazon Kinesis Data Streams e MongoDB Atlas. Questa architettura di riferimento utilizza AWS Glue Studio per creare pipeline di estrazione, trasformazione e caricamento (ETL) per migrare i dati su MongoDB Atlas. An Crawler di AWS Glue si integra con MongoDB Atlas per facilitare la governance dei dati. I dati possono essere trasferiti in batch o trasmessi in streaming su MongoDB Atlas utilizzando Amazon Kinesis Data Streams. **Caricamento dati in batch** ![\[Migrazione dei dati su MongoDB Atlas in modalità batch.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/68d87202-95ba-4e2a-9b3b-27dd6db6165e.png) Per ulteriori informazioni sulla migrazione dei dati in batch, consulta il post del AWS blog [Componi i tuoi lavori ETL per MongoDB Atlas](https://aws.amazon.com/blogs/big-data/compose-your-etl-jobs-for-mongodb-atlas-with-aws-glue/) con. AWS Glue **Streaming di dati** ![\[Migrazione dei dati su MongoDB Atlas in modalità streaming di dati.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/b007a116-f463-418f-9721-647d80177e3b.png) Per le architetture di riferimento di MongoDB Atlas che supportano diversi scenari di utilizzo, consulta [Migrating to MongoDB Atlas sul sito Web Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Guidance. AWS AWS ## Tools (Strumenti) [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)● è un servizio ETL completamente gestito. Ti aiuta a classificare, pulire, arricchire e spostare i dati in modo affidabile tra archivi di dati e flussi di dati. ● [Amazon Kinesis Data](https://aws.amazon.com/kinesis/data-streams/) Streams ti aiuta a raccogliere ed elaborare grandi flussi di record di dati in tempo reale. ● [MongoDB](https://www.mongodb.com/atlas) Atlas è un database as a service (DBaaS) completamente gestito per l'implementazione e la gestione di database MongoDB nel cloud. ## Best practice Per le linee guida, consulta la [Guida alle migliori pratiche per MongoDB](https://github.com/mongodb-partners/mongodb_atlas_as_aws_bedrock_knowledge_base/blob/main/data/MongoDB_Best_Practices_Guide.pdf) nel repository MongoDB. GitHub ## Poemi epici ### Scoperta e valutazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Determina la dimensione del cluster. | Stimate la dimensione del set di lavoro utilizzando le informazioni fornite `db.stats()` per lo spazio totale dell'indice. Si supponga che si acceda frequentemente a una percentuale dello spazio dati. In alternativa, puoi stimare i requisiti di memoria in base alle tue ipotesi. Questa operazione dovrebbe richiedere circa una settimana. Per ulteriori informazioni ed esempi su questa e le altre storie di questa epopea, consulta i collegamenti nella sezione [Risorse correlate](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA, architetto dell'applicazione | | Stima dei requisiti di larghezza di banda della rete. | Per stimare i requisiti di larghezza di banda di rete, moltiplica la dimensione media dei documenti per il numero di documenti inviati al secondo. Considerate come base il traffico massimo che qualsiasi nodo del cluster sarà in grado di sopportare. Per calcolare le velocità di trasferimento dei dati a valle dal cluster alle applicazioni client, utilizza la somma del totale dei documenti restituiti in un periodo di tempo. Se le tue applicazioni leggono da nodi secondari, dividi questo numero di documenti totali per il numero di nodi che possono eseguire operazioni di lettura. Per trovare la dimensione media dei documenti per un database, utilizzate il `db.stats().avgObjSize` comando. Questa operazione richiede in genere un giorno. | MongoDB DBA | | Seleziona il livello Atlas. | Segui le istruzioni nella documentazione di [MongoDB](https://www.mongodb.com/docs/atlas/manage-clusters/) per selezionare il livello di cluster Atlas corretto. | MongoDB DBA | | Piano di cutover. | Piano per il completamento dell'applicazione. | MongoDB DBA, architetto dell'applicazione | ### Configura un nuovo ambiente MongoDB Atlas su AWS | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un nuovo cluster MongoDB Atlas su. AWS | In MongoDB Atlas, **scegli Crea un** cluster e AWS seleziona come fornitore di servizi cloud. | MongoDB DBA | | Configurazione selettiva Regioni AWS e globale del cluster. | Seleziona dall'elenco delle opzioni disponibili Regioni AWS per il tuo cluster Atlas. Se necessario, configura i cluster globali. | MongoDB DBA | | Seleziona il livello del cluster. | Seleziona il livello di cluster preferito. La selezione del livello determina fattori quali memoria, storage e specifiche IOPS. | MongoDB DBA | | Configura impostazioni aggiuntive del cluster. | Configura impostazioni cluster aggiuntive come la versione di MongoDB, il backup e le opzioni di crittografia. Per ulteriori informazioni su queste opzioni, consulta la sezione [Risorse correlate](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA | ### Configura sicurezza e conformità | Operazione | Description | Competenze richieste | | --- | --- | --- | | Configura l'elenco di accesso. | Per connettersi al cluster Atlas, è necessario aggiungere una voce all'[elenco di accesso del progetto](https://www.mongodb.com/docs/atlas/setup-cluster-security/#configure-security-features-for-clusters). Atlas utilizza Transport Layer Security (TLS)/Secure Sockets Layer (SSL) per crittografare le connessioni al cloud privato virtuale (VPC) per il database. [Per impostare l'elenco di accesso al progetto e per ulteriori informazioni sulle storie di questa epopea, consulta i collegamenti nella sezione Risorse correlate.](#stream-data-from-ibm-db2-to-mongodb-atlas-resources) | MongoDB DBA | | Autentica e autorizza gli utenti. | È necessario creare e autenticare gli utenti del database che accederanno ai cluster MongoDB Atlas. Per accedere ai cluster di un progetto, gli utenti devono appartenere a quel progetto e possono appartenere a più progetti. Puoi anche abilitare l'autorizzazione con AWS Identity and Access Management (IAM). Per ulteriori informazioni, consulta [Configurare l'autenticazione con IAM](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam) nella documentazione di MongoDB. | MongoDB DBA | | Crea ruoli personalizzati. | (Facoltativo) Atlas supporta la creazione di [ruoli personalizzati](https://www.mongodb.com/docs/atlas/reference/custom-role-actions/) se i privilegi utente del database Atlas integrato non coprono il set di privilegi desiderato. | MongoDB DBA | | Configura il peering VPC. | (Facoltativo) Atlas supporta il [peering VPC con altri AWS](https://www.mongodb.com/docs/atlas/security-vpc-peering/#set-up-a-network-peering-connection). VPCs | MongoDB DBA | | Configura un endpoint. AWS PrivateLink | (Facoltativo) Puoi configurare endpoint privati utilizzando AWS . [AWS PrivateLink](https://www.mongodb.com/docs/atlas/security-private-endpoint/) | MongoDB DBA | | Abilita l'autenticazione a due fattori. | (Facoltativo) Atlas supporta l'autenticazione a due fattori (2FA) per aiutare gli utenti a controllare l'accesso ai propri account Atlas. | MongoDB DBA | | Configura l'autenticazione e l'autorizzazione degli utenti con LDAP. | (Facoltativo) Atlas supporta l'esecuzione dell'autenticazione e dell'autorizzazione degli utenti con Lightweight Directory Access Protocol (LDAP). | MongoDB DBA | | Configura l'accesso unificato. AWS | (Facoltativo) Alcune funzionalità di Atlas, tra cui Atlas Data Lake e la crittografia a riposo mediante la gestione delle chiavi dei clienti, utilizzano i ruoli IAM per l'autenticazione. | MongoDB DBA | | Configura la crittografia a riposo utilizzando. AWS KMS | (Facoltativo) Atlas supporta l'utilizzo di AWS Key Management Service (AWS KMS) per crittografare i motori di archiviazione e i backup dei provider di cloud. | MongoDB DBA | | Configura CSFLE. | (Facoltativo) Atlas supporta la crittografia a [livello di campo (CSFLE) lato client, inclusa la crittografia](https://www.mongodb.com/docs/upcoming/core/csfle/#client-side-field-level-encryption) automatica dei campi. | MongoDB DBA | ### Migrazione dei dati | Operazione | Description | Competenze richieste | | --- | --- | --- | | Avvia la replica di destinazione impostata in MongoDB Atlas. | Avvia la replica di destinazione impostata in MongoDB Atlas. In Atlas Live Migration Service, scegli **Sono pronto per** la migrazione. | MongoDB DBA | | Stabilisci la connessione AWS Glue con MongoDB Atlas. | Usa an Crawler di AWS Glue per connetterti AWS Glue con MongoDB Atlas (database di destinazione). Questo passaggio aiuta a preparare l'ambiente di destinazione per la migrazione. Per ulteriori informazioni, consulta la [documentazione relativa ad AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). | MongoDB DBA | | Stabilisci la connessione AWS Glue con il database o il flusso di origine. | Questo aiuta a preparare l'ambiente di destinazione per la migrazione. | MongoDB DBA | | Imposta la trasformazione dei dati. | Configura la logica di trasformazione per migrare i dati dallo schema strutturato legacy allo schema flessibile di MongoDB. | MongoDB DBA | | Migrare i dati. | Pianifica la migrazione in AWS Glue Studio. | MongoDB DBA | ### Configura l'integrazione operativa | Operazione | Description | Competenze richieste | | --- | --- | --- | | Connect al cluster. | Connect al cluster MongoDB Atlas. | Sviluppatore di app | | Interagisci con i dati. | Interagisci con i dati del cluster. | Sviluppatore di app | | Monitora i cluster. | Monitora i tuoi cluster MongoDB Atlas. | MongoDB DBA | | Backup e ripristino dei dati. | Eseguire il backup e il ripristino dei dati del cluster. | MongoDB DBA | ## Risoluzione dei problemi | Problema | Soluzione | | --- | --- | | Se riscontri problemi | Vedi [Risoluzione dei problemi](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) nel repository MongoDB CloudFormation Atlas Resources. | ## Risorse correlate Tutti i seguenti collegamenti, se non diversamente specificato, portano alle pagine Web della documentazione di MongoDB. **Guida alla migrazione** + [Migrazione a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) on (Guida prescrittiva)AWS **Scoperta e valutazione** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Esempio di dimensionamento con set di dati di esempio Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Esempio di dimensionamento per applicazioni mobili](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Traffico di rete](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Scalabilità automatica del cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modello di dimensionamento Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurazione della sicurezza e della conformità** + [Configurazione delle voci dell'elenco di accesso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configura i ruoli personalizzati del database](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configurazione degli utenti del database](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurare una connessione peering di rete](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Scopri di più sugli endpoint privati in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gestisci le tue opzioni di autenticazione a più fattori](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configura l'autenticazione e l'autorizzazione degli utenti con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Crittografia a riposo con Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Metodi per assumere un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentazione IAM) + [Crittografia a livello di campo lato client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Crittografia automatica](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Controlli di sicurezza MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Centro fiducia MongoDB](https://www.mongodb.com/cloud/trust) + [Configura le funzionalità di sicurezza per i cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configurazione di un nuovo ambiente MongoDB Atlas su **AWS**** + [Provider di cloud e regioni](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gestisci i cluster globali](https://docs.atlas.mongodb.com/global-clusters/) + [Seleziona il livello del cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configura impostazioni aggiuntive](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Inizia con Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configura l'accesso all'interfaccia utente Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migrazione dei dati** + [Migrazione o importazione dei dati](https://www.mongodb.com/docs/atlas/import/) **Cluster di monitoraggio** + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrazione delle operazioni** + [Connect a un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagisci con i tuoi dati](https://docs.atlas.mongodb.com/data-explorer/) + [Monitora i tuoi cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Backup, ripristino e archiviazione dei dati](https://docs.atlas.mongodb.com/backup-restore-cluster/) **GitHub archivio** + [Trasmetti dati a MongoDB Atlas utilizzando AWS Glue](https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue?tab=readme-ov-file#troubleshooting) # Ruoli di transizione per un' PeopleSoft applicazione Oracle su Amazon RDS Custom for Oracle *sampath kathirvel, Amazon Web Services* ## Riepilogo Per eseguire la soluzione [Oracle PeopleSoft](https://www.oracle.com/applications/peoplesoft/) Enterprise Resource Planning (ERP) su Amazon Web Services (AWS), puoi utilizzare [Amazon Relational Database Service (Amazon RDS)](https://aws.amazon.com/rds/) o [Amazon RDS Custom per](https://aws.amazon.com/rds/custom/) Oracle, che supporta applicazioni legacy, personalizzate e in pacchetti che richiedono l'accesso al sistema operativo (OS) e all'ambiente di database sottostanti. Per i fattori chiave da considerare quando si pianifica una migrazione, consulta [le strategie di migrazione del database Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/strategies.html) in AWS Prescriptive Guidance. Questo modello si concentra sui passaggi per eseguire uno switchover di Oracle Data Guard, o transizione di ruolo, per un database di PeopleSoft applicazioni in esecuzione su Amazon RDS Custom come database primario con un database di replica di lettura. Il modello include i passaggi per configurare il failover ad avvio [rapido (FSFO)](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-D26D79F2-0093-4C0E-98CD-224A5C8CBFA4). Durante questo processo, i database nella configurazione di Oracle Data Guard continuano a funzionare nei loro nuovi ruoli. I casi d'uso tipici dello switchover di Oracle Data Guard sono le esercitazioni di disaster recovery (DR), le attività di manutenzione programmata sui database e le patch periodiche [Standby-First](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/upgrading-patching-downgrading-oracle-data-guard-configuration.html#GUID-A5226768-DB6B-4714-BB9A-0A3EF17A01C8) Patch Apply. Per ulteriori informazioni, consulta il post del blog [Ridurre i tempi di inattività delle patch del database in Amazon RDS](https://aws.amazon.com/blogs/database/reduce-database-patching-downtime-in-amazon-rds-custom-for-oracle-using-oracle-data-guard-standby-first-patch-apply/) Custom. ## Prerequisiti e limitazioni **Prerequisiti** + Completamento dell'operazione [Add HA to Oracle PeopleSoft on Amazon RDS Custom utilizzando un modello di replica di lettura](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.html). **Limitazioni** + Limitazioni e configurazioni non supportate per [RDS](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) Custom for Oracle + Limitazioni associate alle repliche di [lettura di Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versioni del prodotto** + Per le versioni del database Oracle supportate da Amazon RDS Custom, consulta [RDS Custom for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.ora) Oracle. + Per le classi di istanze di Oracle Database supportate da Amazon RDS Custom, consulta [Supporto delle classi di istanze DB per RDS Custom for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.instances) Oracle. ## Architecture **Stack tecnologico** + Amazon RDS Custom per Oracle **Architettura Target** Il diagramma seguente mostra un'istanza DB personalizzata di Amazon RDS e una replica di lettura Amazon RDS Custom. Oracle Data Guard fornisce la transizione dei ruoli durante il failover per DR. ![\[Switchover di Oracle Data Guard per un'istanza DB RDS Custom primaria con un database di replica in lettura.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/da3b011c-1668-4de4-9079-0982888a74b4/images/4e2a2f3b-b5bd-44b7-9b5a-13a663ee3be6.png) Per un'architettura rappresentativa che utilizza Oracle PeopleSoft su AWS, consulta [Configurare un' PeopleSoft architettura ad alta disponibilità su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/set-up-a-highly-available-peoplesoft-architecture-on-aws.html). ## Tools (Strumenti) **Servizi AWS** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) è un servizio di database gestito per applicazioni legacy, personalizzate e confezionate che richiedono l'accesso al sistema operativo e all'ambiente di database sottostanti. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ti aiuta a sostituire le credenziali codificate nel codice, comprese le password, con una chiamata API a Secrets Manager per recuperare il segreto a livello di codice. In questo modello, si recuperano le password degli utenti del database da Secrets Manager per `RDS_DATAGUARD` con il nome segreto. `do-not-delete-rds-custom-+<
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY WITH APPLY
-bash-4.2$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_A**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Mon Nov 28 20:55:50 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 59 seconds ago)
DGMGRL>
CDB-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Verifica il ruolo dell'istanza. | Apri la Console di gestione AWS e accedi alla console Amazon RDS. Nella sezione **Replica** del database, nella scheda **Connettività e sicurezza**, verifica il ruolo dell'istanza per il primario e la replica.Il ruolo principale deve corrispondere al database primario di Oracle Data Guard e il ruolo di replica deve corrispondere al database di standby fisico di Oracle Data Guard. | Amministratore cloud, DBA | | Esegui il passaggio. | Per eseguire lo switchover, connettiti a `DGMGRL` dal nodo principale.**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:13:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> switchover to orcl_d;**CDB**
Performing switchover NOW, please wait...
Operation requires a connection to database "orcl_d"
Connecting ...
Connected to "ORCL_D"
Connected as SYSDG.
New primary database "orcl_d" is opening...
Operation requires start up of instance "ORCL" on database "orcl_a"
Starting instance "ORCL"...
Connected to an idle instance.
ORACLE instance started.
Connected to "ORCL_A"
Database mounted.
Database opened.
Connected to "ORCL_A"
Switchover succeeded, new primary is "orcl_d"
DGMGRL>
DGMGRL> switchover to rdscdb_b| DBA | | Verifica la connessione di Oracle Data Guard. | Dopo lo switchover, verifica la connessione Oracle Data Guard dal nodo principale a. `DGMGRL`**Non CDB**
Performing switchover NOW, please wait...
New primary database "rdscdb_b" is opening...
Operation requires start up of instance "RDSCDB" on database "rdscdb_a"
Starting instance "RDSCDB"...
Connected to an idle instance.
ORACLE instance started.
Connected to "RDSCDB_A"
Database mounted.
Database opened.
Connected to "RDSCDB_A"
Switchover succeeded, new primary is "rdscdb_b"
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 60 seconds ago)
DGMGRL>
DGMGRL> show configuration lag;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 44 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | | Verifica il ruolo dell'istanza sulla console Amazon RDS. | **Dopo aver eseguito il cambio di ruolo, la console Amazon RDS mostra i nuovi ruoli nella sezione **Replica** della scheda **Connettività e sicurezza** in Database.** **Potrebbero essere necessari alcuni minuti prima che **lo stato di replica venga** aggiornato da vuoto a Replicante.** | DBA | ### Configurare FSFO | Operazione | Description | Competenze richieste | | --- | --- | --- | | Reimposta lo switchover. | Reimposta lo switchover sul nodo principale. | DBA | | Installa e avvia l'osservatore. | Un processo di osservazione è un componente `DGMGRL` client, in genere eseguito su una macchina diversa dai database primari e di standby. L'installazione di ORACLE HOME per l'observer può essere un'installazione di Oracle Client Administrator oppure è possibile installare Oracle Database Enterprise Edition o Personal Edition. Per ulteriori informazioni sull'installazione dell'observer per la versione del database, vedere [Installazione e avvio dell'](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-11EF3897-8FCA-4A54-B63B-E8C1668AE21B)Observer. Per configurare l'alta disponibilità per il processo di osservazione, potresti voler fare quanto segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.html)Per Oracle 12c Release 2 e versioni successive, puoi implementare fino a tre osservatori. Un osservatore è l'osservatore principale e gli altri sono osservatori di riserva. Quando l'osservatore principale fallisce, uno degli osservatori di riserva assume il ruolo principale. | DBA | | Connect a DGMGRL dall'host dell'osservatore. | L'host dell'osservatore è configurato con `tnsnames.ora` voci per la connettività del database primario e di standby. È possibile abilitare FSFO con la modalità di protezione delle massime prestazioni purché la perdita di dati rientri nella [FastStartFailoverLagLimit](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html)configurazione (valore in secondi). Tuttavia, è necessario utilizzare la modalità di protezione della massima disponibilità per ottenere una perdita di dati pari a zero (RPO=0).**Non CDB**
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 53 seconds ago)
DGMGRL>
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 58 seconds ago)
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 5 seconds ago)
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Modificate il database di standby in modo che diventi la destinazione del failover. | Connect dal nodo primario o dal nodo osservatore a un database in standby. (Sebbene la configurazione possa avere più database in standby, è necessario connettersi a uno solo per volta.)**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:55:09 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 18 seconds ago)
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='orcl_d';**CDB**
Property "faststartfailovertarget" updated
DGMGRL> edit database orcl_d set property FastStartFailoverTarget='orcl_a';
Property "faststartfailovertarget" updated
DGMGRL> show database orcl_a FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_d'
DGMGRL> show database orcl_d FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_a'
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='rdscdb_b';| DBA | | Configurare FastStartFailoverThreshold per la connessione a DGMGRL. | Il valore predefinito è 30 secondi in Oracle 19c e il valore minimo è 6 secondi. Un valore inferiore può potenzialmente ridurre il Recovery Time Objective (RTO) durante il failover. Un valore più alto aiuta a ridurre la possibilità di errori transitori di failover non necessari sul database primario.Il framework di automazione RDS Custom for Oracle monitora lo stato del database ed esegue azioni correttive ogni pochi secondi. Pertanto, si consiglia di impostare un valore superiore FastStartFailoverThreshold a 10 secondi. L'esempio seguente configura il valore di soglia a 35 secondi.**Non CBD o CDB**
Object "orcl_a" was not found
DGMGRL> edit database rdscdb_a set property FastStartFailoverTarget='rdscdb_b';
Property "faststartfailovertarget" updated
DGMGRL> edit database rdscdb_b set property FastStartFailoverTarget='rdscdb_a';
Property "faststartfailovertarget" updated
DGMGRL> show database rdscdb_a FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_b'
DGMGRL> show database rdscdb_b FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_a'
DGMGRL>
DGMGRL> edit configuration set property FastStartFailoverThreshold=35;| DBA | | Abilita FSFO connettendoti a DGMGRL dal nodo primario o osservatore. | Se il database non ha [Flashback Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/rcmrf/FLASHBACK-DATABASE.html#GUID-584AC79A-40C5-45CA-8C63-DED3BE3A4511) abilitato, viene visualizzato il messaggio di avviso. `ORA-16827` Il database flashback opzionale aiuta a ripristinare automaticamente i database primari guasti in un momento precedente al failover se la proprietà di [FastStartFailoverAutoReinstate](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html#GUID-824E97C0-EEB0-4E1B-BD4A-F5AE282CEA28)configurazione è impostata su `TRUE` (che è l'impostazione predefinita).**Non CDB**
Property "faststartfailoverthreshold" updated
DGMGRL> show configuration FastStartFailoverThreshold;
FastStartFailoverThreshold = '35'
DGMGRL>
DGMGRL> enable fast_start failover;**CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL>
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
orcl_d - (*) Physical standby database
Warning: ORA-16819: fast-start failover observer not started
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 29 seconds ago)
DGMGRL>
DGMGRL> enable fast_start failover;| DBA | | Avvia l'osservatore per il monitoraggio FSFO e verifica lo stato. | È possibile avviare l'osservatore prima o dopo aver abilitato FSFO. Se FSFO è già abilitato, l'osservatore inizia immediatamente a monitorare lo stato e le connessioni ai database di standby primari e di destinazione. Se FSFO non è abilitato, l'osservatore inizia il monitoraggio solo dopo l'attivazione di FSFO.All'avvio dell'osservatore, la configurazione del DB principale verrà visualizzata senza messaggi di errore, come evidenziato dal comando precedente. `show configuration`**Non CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 11 seconds ago)
DGMGRL>
DGMGRL> start observer;**CDB**
[W000 2022-12-01T06:16:51.271+00:00] FSFO target standby is orcl_d
Observer 'ip-10-0-1-89' started
[W000 2022-12-01T06:16:51.352+00:00] Observer trace level is set to USER
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 56 seconds ago)
DGMGRL>
DGMGRL> show observer
Configuration - rds_dg
Primary: orcl_a
Active Target: orcl_d
Observer "ip-10-0-1-89" - Master
Host Name: ip-10-0-1-89
Last Ping to Primary: 1 second ago
Last Ping to Target: 1 second ago
DGMGRL>
DGMGRL> start observer;| DBA | | Verifica il failover. | In questo scenario, è possibile eseguire un test di failover arrestando manualmente l'istanza principale. EC2 Prima di arrestare l' EC2 istanza, utilizzate il `tail` comando per monitorare il file di registro dell'osservatore in base alla configurazione. Utilizzato `DGMGRL` per accedere al database in standby `orcl_d` con l'utente `RDS_DATAGUARD` e controllare lo stato di Oracle Data Guard. Dovrebbe mostrare che si `orcl_d` tratta del nuovo database primario.In questo scenario di test di failover, `orcl_d` è il database non CDB.Prima del failover, il database flashback era abilitato. `orcl_a` Dopo che il precedente database primario è tornato online e ha iniziato a funzionare, l'osservatore `MOUNT` lo ripristina in un nuovo database di standby. Il database ripristinato funge da destinazione FSFO per il nuovo database primario. È possibile verificare i dettagli nei log degli osservatori.
Succeeded in opening the observer file "/home/oracle/fsfo_ip-10-0-1-56.dat".
[W000 2023-01-18T07:31:32.589+00:00] FSFO target standby is rdscdb_b
Observer 'ip-10-0-1-56' started
The observer log file is '/home/oracle/observer_ip-10-0-1-56.log'.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 12 seconds ago)
DGMGRL>
DGMGRL> show observer;
Configuration - rds_dg
Primary: rdscdb_a
Active Target: rdscdb_b
Observer "ip-10-0-1-56" - Master
Host Name: ip-10-0-1-56
Last Ping to Primary: 1 second ago
Last Ping to Target: 2 seconds ago
DGMGRL>
DGMGRL> show configurationDi seguito viene mostrato un esempio di output in. `observer.log`
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
Warning: ORA-16824: multiple warnings, including fast-start failover-related warnings, detected for the database
orcl_a - (*) Physical standby database (disabled)
ORA-16661: the standby database needs to be reinstated
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 25 seconds ago)
DGMGRL>
$ tail -f /tmp/observer.log| DBA | ### Configura la connettività tra l'applicazione Oracle Peoplesoft e il database | Operazione | Description | Competenze richieste | | --- | --- | --- | | Creare e avviare il servizio nel database principale. | È possibile evitare modifiche alla configurazione dell'applicazione durante una transizione di ruolo utilizzando una voce TNS che contiene sia gli endpoint del database primario che quelli di standby nella configurazione. È possibile definire due servizi di database basati sui ruoli per supportare entrambi i carichi di lavoro e quelli di sola lettura. read/write Nell'esempio seguente, `orcl_rw` è il read/write servizio attivo nel database primario. `orcl_ro`è il servizio di sola lettura ed è attivo nel database di standby che è stato aperto in modalità di sola lettura.
Unable to connect to database using rds_custom_orcl_a
[W000 2023-01-18T07:50:32.589+00:00] Primary database cannot be reached.
[W000 2023-01-18T07:50:32.589+00:00] Fast-Start Failover threshold has expired.
[W000 2023-01-18T07:50:32.590+00:00] Try to connect to the standby.
[W000 2023-01-18T07:50:32.590+00:00] Making a last connection attempt to primary database before proceeding with Fast-Start Failover.
[W000 2023-01-18T07:50:32.591+00:00] Check if the standby is ready for failover.
[S002 2023-01-18T07:50:32.591+00:00] Fast-Start Failover started...
2023-01-18T07:50:32.591+00:00
Initiating Fast-Start Failover to database "orcl_d"...
[S002 2023-01-18T07:50:32.592+00:00] Initiating Fast-start Failover.
Performing failover NOW, please wait...
Failover succeeded, new primary is "orcl_d"
2023-01-18T07:55:32.101+00:00
[S002 2023-01-18T07:55:32.591+00:00] Fast-Start Failover finished...
[W000 2023-01-18T07:55:32.591+00:00] Failover succeeded. Restart pinging.
[W000 2023-01-18T07:55:32.603+00:00] Primary database has changed to orcl_d.
[W000 2023-01-18T07:55:33.618+00:00] Try to connect to the primary.
[W000 2023-01-18T07:55:33.622+00:00] Try to connect to the primary rds_custom_orcl_d.
[W000 2023-01-18T07:55:33.634+00:00] The standby orcl_a needs to be reinstated
[W000 2023-01-18T07:55:33.654+00:00] Try to connect to the new standby orcl_a.
[W000 2023-01-18T07:55:33.654+00:00] Connection to the primary restored!
[W000 2023-01-18T07:55:35.654+00:00] Disconnecting from database rds_custom_orcl_d.
[W000 2023-01-18T07:55:57.701+00:00] Try to connect to the new standby orcl_a.
ORA-12170: TNS:Connect timeout occurred
SQL> select name,open_mode from v$database;| DBA | | Avvia il servizio nel database di standby. | Per avviare il servizio nel database di standby di sola lettura, utilizzare il codice seguente.
NAME OPEN_MODE
--------- --------------------
ORCL READ WRITE
SQL> exec dbms_service.create_service('orcl_rw','orcl_rw');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.create_service('orcl_ro','orcl_ro');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.start_service('orcl_rw');
PL/SQL procedure successfully completed.
SQL>
SQL> select name,open_mode from v$database;| DBA | | Automatizza l'avvio del servizio al riavvio del DB primario. | Per avviare automaticamente il servizio nel database primario al riavvio, usa il codice seguente.
NAME OPEN_MODE
--------- --------------------
ORCL READ ONLY WITH APPLY
SQL> exec dbms_service.start_service('orcl_ro');
PL/SQL procedure successfully completed.
SQL>
SQL> CREATE OR REPLACE TRIGGER TrgDgServices after startup on database| DBA | | Configura una connessione tra i database read/write e quelli di sola lettura. | È possibile utilizzare il seguente esempio di configurazione dell'applicazione per la connessione in sola lettura. read/write
DECLARE
db_role VARCHAR(30);
db_open_mode VARCHAR(30);
BEGIN
SELECT DATABASE_ROLE, OPEN_MODE INTO db_role, db_open_mode FROM V$DATABASE;
IF db_role = 'PRIMARY' THEN
DBMS_SERV 2 ICE.START_SERVICE('orcl_rw');
END IF;
IF db_role = 'PHYSICAL STANDBY' AND db_open_mode LIKE 'READ ONLY%' THEN
DBMS_SERVICE.START_SERVICE('orcl_ro');
END IF;
END;
/
Trigger created.
SQL>
ORCL_RW = (DESCRIPTION =| DBA | ## Risorse correlate + [Abilitare l'alta disponibilità con Data Guard su Amazon RDS Custom for Oracle](https://d1.awsstatic.com/whitepapers/enabling-high-availability-with-data-guard-on-amazon-rds-custom-for-oracle.pdf) (AWS Technical Guide) + [Configurazione di Amazon RDS come PeopleSoft database Oracle (white paper](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) AWS) + [Guida Oracle Data Guard Broker (documentazione di riferimento](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) Oracle) + [Concetti e amministrazione di Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (documentazione di riferimento Oracle) + [Requisiti di configurazione FAN e FCF specifici per Oracle Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-DFFDAA2B-A889-49AD-AB85-747D73FF0FF5) (documentazione di riferimento Oracle) # Scarica i dati da un cluster Amazon Redshift tra più account su Amazon S3 *Andrew Kamel, Amazon Web Services* ## Riepilogo Quando si testano le applicazioni, è utile disporre dei dati di produzione nell'ambiente di test. L'utilizzo dei dati di produzione può darvi una valutazione più accurata dell'applicazione che state sviluppando. Questo modello estrae i dati da un cluster Amazon Redshift in un ambiente di produzione in un bucket Amazon Simple Storage Service (Amazon S3) in un ambiente di sviluppo su Amazon Web Services ().AWS Il modello illustra la configurazione degli account DEV e PROD, inclusi i seguenti: + Risorse obbligatorie + AWS Identity and Access Management ruoli (IAM) + Modifiche di rete a sottoreti, gruppi di sicurezza e cloud privato virtuale (VPC) per supportare la connessione Amazon Redshift + Una AWS Lambda funzione di esempio con un runtime Python per testare l'architettura Per concedere l'accesso al cluster Amazon Redshift, il pattern utilizza il pattern Gestione dei segreti AWS per memorizzare le credenziali pertinenti. Il vantaggio è avere tutte le informazioni necessarie per connettersi direttamente al cluster Amazon Redshift senza dover sapere dove si trova il cluster Amazon Redshift. Inoltre, puoi [monitorare l'uso del segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html). Il segreto salvato in Secrets Manager include l'host del cluster Amazon Redshift, il nome del database, la porta e le credenziali pertinenti. Per informazioni sulle considerazioni sulla sicurezza quando si utilizza questo modello, consulta la sezione [Best](#unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3-best-practices) practice. ## Prerequisiti e limitazioni **Prerequisiti** + Un [cluster Amazon Redshift in esecuzione nell'account](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) PROD + Un [bucket S3 creato](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) nell'account DEV + [Peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) [tra gli account DEV e PROD, con tabelle di routing adattate di conseguenza](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) + [Nomi host DNS e risoluzione DNS abilitati per entrambi i sistemi peer-to-peer](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) VPCs **Limitazioni** + A seconda della quantità di dati da interrogare, la funzione Lambda potrebbe scadere. Se l'esecuzione richiede più tempo del timeout Lambda massimo (15 minuti), utilizza un approccio asincrono per il codice Lambda. L'esempio di codice per questo pattern utilizza la libreria [psycopg2](https://github.com/psycopg/psycopg2) per Python, che attualmente non supporta l'elaborazione asincrona. + Alcuni non sono disponibili in tutti. Servizi AWS Regioni AWS Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio. ## Architecture Il diagramma seguente mostra l'architettura di destinazione, con gli account DEV e PROD. ![\[Il VPC Lambda nell'account DEV e il VPC Amazon Redshift nell'account PROD.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/fa4d01df-483d-4454-9711-b391ebbe4629.png) Il diagramma mostra il flusso di lavoro seguente: 1. La funzione Lambda nell'account DEV presuppone il ruolo IAM necessario per accedere alle credenziali Amazon Redshift in Secrets Manager nell'account PROD. La funzione Lambda recupera quindi il segreto del cluster Amazon Redshift. 1. La funzione Lambda nell'account DEV utilizza le informazioni per connettersi al cluster Amazon Redshift nell'account PROD tramite il peered. VPCs La funzione Lambda invia quindi un comando unload per interrogare il cluster Amazon Redshift nell'account PROD. 1. Il cluster Amazon Redshift nell'account PROD assume il ruolo IAM pertinente per accedere al bucket S3 nell'account DEV. Il cluster Amazon Redshift scarica i dati richiesti nel bucket S3 nell'account DEV. **Interrogazione di dati da Amazon Redshift** Il diagramma seguente mostra i ruoli utilizzati per recuperare le credenziali di Amazon Redshift e connettersi al cluster Amazon Redshift. Il flusso di lavoro viene avviato dalla funzione Lambda. ![\[Il processo in tre fasi per l'assunzione di ruoli tra account.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/ab25b72c-773c-4d58-9012-4a3755c181ff.png) Il diagramma mostra il flusso di lavoro seguente: 1. L'account `CrossAccount-SM-Read-Role` nell'account DEV presuppone quello `SM-Read-Role` nell'account PROD. 1. Il `SM-Read-Role` ruolo utilizza la policy allegata per recuperare il segreto da Secrets Manager. 1. Le credenziali vengono utilizzate per accedere al cluster Amazon Redshift. **Caricamento di dati su Amazon S3** Il diagramma seguente mostra il processo di lettura-scrittura tra account per l'estrazione dei dati e il loro caricamento su Amazon S3. Il flusso di lavoro viene avviato dalla funzione Lambda. Il pattern [concatena i ruoli IAM in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles). Il comando unload proveniente dal cluster Amazon Redshift presuppone, e `CrossAccount-S3-Write-Role` quindi assume. `S3-Write-Role` Questo concatenamento di ruoli consente ad Amazon Redshift di accedere ad Amazon S3. ![\[I ruoli che ottengono le credenziali, accedono ad Amazon Redshift e caricano dati su Amazon S3.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/d2982fc6-1d12-4f9d-9493-a99ce691d693.png) Il flusso di lavoro include i seguenti passaggi: 1. L'accesso `CrossAccount-SM-Read-Role` all'account DEV presuppone l'accesso `SM-Read-Role` all'account PROD. 1. `SM-Read-Role`recupera le credenziali di Amazon Redshift da Secrets Manager. 1. La funzione Lambda si connette al cluster Amazon Redshift e invia una query. 1. Il cluster Amazon Redshift presuppone il. `CrossAccount-S3-Write-Role` 1. `CrossAccount-S3-Write-Role`Si presuppone che sia presente `S3-Write-Role` nell'account DEV. 1. I risultati della query vengono scaricati nel bucket S3 nell'account DEV. ## Tools (Strumenti) **Servizi AWS** + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. + [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) è un servizio di data warehouse gestito su scala petabyte nel cloud AWS. + Con [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) puoi sostituire le credenziali nel codice,incluse le password, con una chiamata API a Secrets Manager in modo da recuperare il segreto a livello di codice. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati. **Repository di codice** Il codice per questo pattern è disponibile nel repository GitHub [unload-redshift-to-s3-python](https://github.com/aws-samples/unload-redshift-to-s3-python/). ## Best practice **Dichiarazione di non responsabilità in materia di sicurezza** Prima di implementare questa soluzione, prendete in considerazione i seguenti importanti consigli di sicurezza: + Ricorda che collegare gli account di sviluppo e produzione può aumentare l'ambito e ridurre il livello di sicurezza complessivo. Consigliamo di implementare questa soluzione solo temporaneamente, estraendo la parte di dati richiesta e quindi distruggendo immediatamente le risorse distribuite. Per distruggere le risorse, è necessario eliminare la funzione Lambda, rimuovere tutti i ruoli e le policy IAM creati per questa soluzione e revocare qualsiasi accesso alla rete concesso tra gli account. + Consulta i tuoi team di sicurezza e conformità prima di copiare qualsiasi dato dagli ambienti di produzione a quelli di sviluppo. Le informazioni di identificazione personale (PII), le informazioni sanitarie protette (PHI) e altri dati riservati o regolamentati in genere non devono essere copiati in questo modo. Copia solo le informazioni non riservate disponibili al pubblico (ad esempio, dati di stock pubblici provenienti dall'interfaccia di un negozio). Prendi in considerazione la tokenizzazione o l'anonimizzazione dei dati o la generazione di dati di test sintetici, invece di utilizzare i dati di produzione quando possibile. Uno dei [principi di AWS sicurezza](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) è tenere le persone lontane dai dati. In altre parole, gli sviluppatori non devono eseguire operazioni nell'account di produzione. + Limita l'accesso alla funzione Lambda nell'account di sviluppo perché può leggere i dati dal cluster Amazon Redshift nell'ambiente di produzione. + Per evitare di interrompere l'ambiente di produzione, implementa i seguenti consigli: + Utilizzate un account di sviluppo separato e dedicato per le attività di test e sviluppo. + Implementa rigorosi controlli di accesso alla rete e limita il traffico tra gli account solo a quanto necessario. + Monitora e verifica l'accesso all'ambiente di produzione e alle fonti di dati. + Implementa controlli di accesso con privilegi minimi per tutte le risorse e i servizi coinvolti. + Esamina e ruota regolarmente le credenziali, come i Gestione dei segreti AWS segreti e le chiavi di accesso ai ruoli IAM. + Consulta la seguente documentazione sulla sicurezza per i servizi utilizzati in questo articolo: + [AWS Lambda sicurezza](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) + [Sicurezza di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/iam-redshift-user-mgmt.html) + [Sicurezza di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security.html) + [Gestione dei segreti AWS sicurezza](https://docs.aws.amazon.com/secretsmanager/latest/userguide/security.html) + [Best practice sulla sicurezza IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) La sicurezza è una priorità assoluta quando si accede ai dati e alle risorse di produzione. Segui sempre le migliori pratiche, implementa controlli di accesso con privilegi minimi e rivedi e aggiorna regolarmente le tue misure di sicurezza. ## Epiche ### Interroga i dati da Amazon Redshift | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un segreto per il cluster Amazon Redshift. | Per creare il segreto per il cluster Amazon Redshift, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Crea un ruolo per accedere a Secrets Manager. | Per creare il ruolo, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | ### Caricamento dei dati su Amazon S3 | Operazione | Description | Competenze richieste | | --- | --- | --- | | Crea un ruolo per accedere al bucket S3. | Per creare il ruolo per l'accesso al bucket S3, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Crea il ruolo Amazon Redshift. | Per creare il ruolo Amazon Redshift, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | ### Distribuire la funzione Lambda | Operazione | Description | Competenze richieste | | --- | --- | --- | | Distribuire la funzione Lambda. | Per implementare una funzione Lambda nel VPC peerizzato, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | ### Testa l'architettura | Operazione | Description | Competenze richieste | | --- | --- | --- | | Importa le risorse richieste. | Per importare le risorse richieste, esegui i seguenti comandi:
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_rw))
)
ORCL_RO = (DESCRIPTION =
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_ro))
)
import ast| Sviluppatore di app | | Esegui la funzione di gestione Lambda. | La funzione Lambda utilizza AWS Security Token Service (AWS STS) per l'accesso tra account e la gestione temporanea delle credenziali. La funzione utilizza l'operazione AssumeRole API per assumere temporaneamente le autorizzazioni del ruolo IAM. `sm_read_role`Per eseguire la funzione Lambda, usa il seguente codice di esempio:
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
def lambda_handler(event, context):| Sviluppatore di app | | Scoprite il segreto. | Per ottenere il segreto di Amazon Redshift, usa il seguente codice di esempio:
sts_client = boto3.client('sts')
# Secrets Manager Configurations
secret_name = "redshift_creds"
sm_region = "eu-west-1"
sm_read_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/SM-Read-Role"
# S3 Bucket Configurations
s3_bucket_path = "s3://mybucket/"
s3_bucket_region = "eu-west-1"
s3_write_role = "arn:aws:iam::DEV_ACCOUNT_NUMBER:role/S3-Write-Role"
# Redshift Configurations
sql_query = "select * from category"
redshift_db = "dev"
redshift_s3_write_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/CrossAccount-S3-Write-Role"
chained_s3_write_role = "%s,%s" % (redshift_s3_write_role, s3_write_role)
assumed_role_object = sts_client.assume_role(
RoleArn=sm_read_role,
RoleSessionName="CrossAccountRoleAssumption",
ExternalId="YOUR_EXTERNAL_ID",
)
credentials = assumed_role_object['Credentials']
secret_dict = ast.literal_eval(get_secret(credentials, secret_name, sm_region))
execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db)
return {
'statusCode': 200
}
def get_secret(credentials, secret_name, sm_region):| Sviluppatore di app | | Esegui il comando unload. | Per scaricare i dati nel bucket S3, usa il seguente codice di esempio.
# Create a Secrets Manager client
session = boto3.session.Session()
sm_client = session.client(
service_name='secretsmanager',
aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken'],
region_name=sm_region
)
try:
get_secret_value_response = sm_client.get_secret_value(
SecretId=secret_name
)
except ClientError as e:
print(e)
raise e
else:
if 'SecretString' in get_secret_value_response:
return get_secret_value_response['SecretString']
else:
return base64.b64decode(get_secret_value_response['SecretBinary'])
def execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db):| Sviluppatore di app | ### Eliminazione | Operazione | Description | Competenze richieste | | --- | --- | --- | | Elimina la funzione Lambda. | Per evitare di incorrere in costi non pianificati, rimuovi le risorse e la connessione tra gli account DEV e PROD.Per rimuovere la funzione Lambda, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Rimuovi i ruoli e le politiche IAM. | Rimuovi i ruoli e le policy IAM dagli account DEV e PROD.Nell'account DEV, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html)Nell'account PROD, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Eliminare il segreto in Secrets Manager. | Per eliminare il segreto, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Rimuovi le regole del peering e dei gruppi di sicurezza VPC. | Per rimuovere le regole del peering e dei gruppi di sicurezza VPC, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Rimuovi i dati dal bucket S3. | Per rimuovere i dati da Amazon S3, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Pulisci AWS KMS le chiavi. | Se hai creato delle AWS KMS chiavi personalizzate per la crittografia, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | | Controlla ed elimina i CloudWatch log di Amazon. | Per eliminare i CloudWatch log, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingegnere | ## Risorse correlate + [ CloudWatch Documentazione Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Documentazione IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) + [Documentazione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Documentazione Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) + [Documentazione Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) + [Gestione dei segreti AWS documentazione](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [AWS principi di sicurezza](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) ## Informazioni aggiuntive Dopo aver scaricato i dati da Amazon Redshift ad Amazon S3, puoi analizzarli utilizzando Amazon Athena. [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) è un servizio di interrogazione per Big Data utile quando è necessario accedere a grandi volumi di dati. È possibile utilizzare Athena senza dover effettuare il provisioning di server o database. Athena supporta interrogazioni complesse ed è possibile eseguirla su oggetti diversi. Come per la maggior parte Servizi AWS, il vantaggio principale dell'utilizzo di Athena è che offre una grande flessibilità nel modo in cui vengono eseguite le query senza complessità aggiuntiva. Quando usi Athena, puoi interrogare diversi tipi di dati, come CSV e JSON, in Amazon S3 senza modificare il tipo di dati. Puoi interrogare i dati da varie fonti, anche esterne. AWS Athena riduce la complessità perché non è necessario gestire i server. Athena legge i dati direttamente da Amazon S3 senza caricarli o modificarli prima di eseguire la query. # Modelli di migrazione del database per carico di lavoro **Topics** + [IBM](databases-database-migration-patterns-by-workload-ibm-pattern-list.md) + [Microsoft](databases-database-migration-patterns-by-workload-microsoft-pattern-list.md) + [N/D](databases-database-migration-patterns-by-workload-notapplicable-pattern-list.md) + [Open source](databases-database-migration-patterns-by-workload-open-source-pattern-list.md) + [Oracle](databases-database-migration-patterns-by-workload-oracle-pattern-list.md) + [SAP](databases-database-migration-patterns-by-workload-sap-pattern-list.md) # IBM **Topics** + [Esegui la migrazione di un database Db2 da Amazon a EC2 Aurora compatibile con MySQL utilizzando AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Esegui la migrazione di Db2 for LUW ad Amazon EC2 utilizzando la spedizione di log per ridurre i tempi di interruzione](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Esegui la migrazione di Db2 per LUW ad Amazon EC2 con disaster recovery ad alta disponibilità](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Esegui la migrazione da IBM Db2 su Amazon a EC2 Aurora PostgreSQL compatibile con AWS DMS e AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione da IBM WebSphere Application Server ad Apache Tomcat su Amazon EC2](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2.md) + [Trasmetti dati da IBM Db2, SAP, Sybase e altri database a MongoDB Atlas su AWS](stream-data-from-ibm-db2-to-mongodb-atlas.md) # Microsoft **Topics** + [Accelera la scoperta e la migrazione dei carichi di lavoro Microsoft su AWS](accelerate-the-discovery-and-migration-of-microsoft-workloads-to-aws.md) + [Accedi alle tabelle Microsoft SQL Server locali da Microsoft SQL Server su Amazon EC2 utilizzando server collegati](access-on-premises-microsoft-sql-server-tables-from-microsoft-sql-server-on-amazon-ec2-using-linked-servers.md) + [Valuta le prestazioni delle query per la migrazione dei database SQL Server su MongoDB Atlas su AWS](assess-query-performance-for-migrating-sql-server-databases-to-mongodb-atlas-on-aws.md) + [Automatizza le attività del database nell'edizione SQL Server Express in esecuzione su Amazon EC2 utilizzando Task AWS Lambda Scheduler](automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.md) + [Modifica le applicazioni Python e Perl per supportare la migrazione dei database da Microsoft SQL Server a Amazon Aurora PostgreSQL Compatible Edition](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Configurare il routing di sola lettura in un gruppo di disponibilità Always On in SQL Server su AWS](configure-read-only-routing-in-an-always-on-availability-group-in-sql-server-on-aws.md) + [Configurare l'autenticazione Windows per Amazon RDS for Microsoft SQL Server utilizzando AWS Managed Microsoft AD](configure-windows-authentication-for-amazon-rds-using-microsoft-ad.md) + [Crea CloudFormation modelli AWS per attività AWS DMS utilizzando Microsoft Excel e Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Distribuisci istanze di cluster di failover di SQL Server su Amazon e EC2 Amazon FSx utilizzando Terraform](deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.md) + [Esportazione di un database Microsoft SQL Server in Amazon S3 utilizzando AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Esporta tabelle Amazon RDS for SQL Server in un bucket S3 utilizzando AWS DMS](export-amazon-rds-for-sql-server-tables-to-an-s3-bucket-by-using-aws-dms.md) + [SHA1 Implementa l'hashing per i dati PII durante la migrazione da SQL Server a PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Acquisisci e migra istanze EC2 Windows in un account AWS Managed Services](ingest-and-migrate-ec2-windows-instances-into-an-aws-managed-services-account.md) + [Configura un cluster di failover di Microsoft SQL Server su Amazon EC2 utilizzando FSx per Windows File Server](microsoft-sql-failover-cluster-on-amazon-ec2.md) + [Esegui la migrazione di una coda di messaggistica da Microsoft Azure Service Bus ad Amazon SQS](migrate-a-messaging-queue-from-microsoft-azure-service-bus-to-amazon-sqs.md) + [Esegui la migrazione di un database Microsoft SQL Server da Amazon EC2 ad Amazon DocumentDB utilizzando AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Esegui la migrazione di un database Microsoft SQL Server su Aurora MySQL utilizzando AWS DMS e AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un'applicazione.NET da Microsoft Azure App Service ad AWS Elastic Beanstalk](migrate-a-net-application-from-microsoft-azure-app-service-to-aws-elastic-beanstalk.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server utilizzando server collegati](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server utilizzando metodi di backup e ripristino nativi](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon Redshift utilizzando AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon Redshift utilizzando gli agenti di estrazione dati AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Esegui la migrazione di un database Microsoft SQL Server locale a Microsoft SQL Server su Amazon EC2 con Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Esegui la migrazione dei dati da Microsoft Azure Blob ad Amazon S3 utilizzando Rclone](migrate-data-from-microsoft-azure-blob-to-amazon-s3-by-using-rclone.md) + [Esegui la migrazione di applicazioni ospitate da IIS su Amazon utilizzando appcmd.exe EC2](migrate-iis-hosted-applications-to-amazon-ec2-by-using-appcmd.md) + [Esegui la migrazione del gruppo di disponibilità Microsoft SQL Server Always On utilizzando AWS Application Migration Service](migrate-microsoft-sql-server-always-on-group-using-mgn.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon EC2 utilizzando Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrare un database relazionale su MongoDB Atlas su AWS](migrate-relational-database-to-mongodb-atlas.md) + [Esegui la migrazione di SQL Server su AWS utilizzando gruppi di disponibilità distribuiti](migrate-sql-server-to-aws-using-distributed-availability-groups.md) + [Migrazione dei certificati SSL di Windows su un Application Load Balancer utilizzando ACM](migrate-windows-ssl-certificates-to-an-application-load-balancer-using-acm.md) + [Rehosting dei carichi di lavoro locali nel cloud AWS: lista di controllo per la migrazione](rehost-on-premises-workloads-in-the-aws-cloud-migration-checklist.md) + [Risolvi gli errori di connessione dopo la migrazione di Microsoft SQL Server al cloud AWS](resolve-connection-errors-after-migrating-microsoft-sql-server-to-the-aws-cloud.md) + [Invia notifiche per un'istanza di database Amazon RDS for SQL Server utilizzando un server SMTP locale e Database Mail](send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.md) + [Configura una CI/CD pipeline per la migrazione del database utilizzando Terraform](set-up-ci-cd-pipeline-for-db-migration-with-terraform.md) + [Configura un'infrastruttura Multi-AZ per SQL Server Always On FCI utilizzando Amazon FSx](set-up-multi-az-infrastructure-for-a-sql-server-always-on-fci-by-using-amazon-fsx.md) # N/D **Topics** + [Creare un processo di approvazione per le richieste del firewall durante una migrazione di rehosting a AWS](create-an-approval-process-for-firewall-requests-during-a-rehost-migration-to-aws.md) + [Crittografa un'istanza database Amazon RDS for PostgreSQL esistente](encrypt-an-existing-amazon-rds-for-postgresql-db-instance.md) + [Stima dei costi di storage per una tabella Amazon DynamoDB](estimate-storage-costs-for-an-amazon-dynamodb-table.md) + [Implementa il disaster recovery tra regioni con AWS DMS e Amazon Aurora](implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.md) # Open source **Topics** + [Genera automaticamente un modello PynamoDB e funzioni CRUD per Amazon DynamoDB utilizzando un'applicazione Python](automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.md) + [Connect utilizzando un tunnel SSH in pGAdmin](connect-by-using-an-ssh-tunnel-in-pgadmin.md) + [Crea utenti e ruoli delle applicazioni in Aurora, compatibile con PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Abilita connessioni crittografate per le istanze DB PostgreSQL in Amazon RDS](enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL con e utilizzando e AWS SCT AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Esegui la migrazione di un database MariaDB locale su Amazon RDS for MariaDB utilizzando strumenti nativi](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Esegui la migrazione di un database MySQL locale su Amazon EC2](migrate-an-on-premises-mysql-database-to-amazon-ec2.md) + [Esegui la migrazione di un database MySQL locale su Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Esegui la migrazione di un database MySQL locale su Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Esegui la migrazione di un database PostgreSQL locale su Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Esegui la migrazione di un database Couchbase Server su Amazon EC2](migrate-couchbase-server-ec2.md) + [Esegui la migrazione da IBM WebSphere Application Server ad Apache Tomcat su Amazon EC2 con Auto Scaling](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2-with-auto-scaling.md) + [Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for Oracle utilizzando AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.md) + [Esegui la migrazione da PostgreSQL su Amazon RDS per PostgreSQL utilizzando EC2 pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Esegui la migrazione di applicazioni Java locali su AWS utilizzando AWS App2Container](migrate-on-premises-java-applications-to-aws-using-aws-app2container.md) + [Esegui la migrazione dei database MySQL locali su Aurora MySQL utilizzando Percona, Amazon EFS e Amazon S3 XtraBackup](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Esegui la migrazione di tabelle esterne Oracle verso Amazon Aurora, compatibile con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Esegui la migrazione di funzioni e procedure Oracle con più di 100 argomenti a PostgreSQL](migrate-oracle-functions-and-procedures-that-have-more-than-100-arguments-to-postgresql.md) + [Esegui la migrazione dei carichi di lavoro Redis su Redis Enterprise Cloud su AWS](migrate-redis-workloads-to-redis-enterprise-cloud-on-aws.md) + [Monitora Amazon Aurora per le istanze senza crittografia](monitor-amazon-aurora-for-instances-without-encryption.md) + [Riavvia automaticamente l'AWS Replication Agent senza disabilitarlo SELinux dopo il riavvio di un server di origine RHEL](restart-the-aws-replication-agent-automatically-without-disabling-selinux-after-rebooting-a-rhel-source-server.md) + [Pianifica i lavori per Amazon RDS for PostgreSQL e Aurora PostgreSQL utilizzando Lambda e Secrets Manager](schedule-jobs-for-amazon-rds-for-postgresql-and-aurora-postgresql-by-using-lambda-and-secrets-manager.md) + [Trasporta i database PostgreSQL tra due istanze DB Amazon RDS utilizzando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Scarica i dati da un cluster Amazon Redshift tra più account su Amazon S3](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md) # Oracle **Topics** + [Aggiungi HA a Oracle PeopleSoft su Amazon RDS Custom utilizzando una replica di lettura](add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.md) + [Convertire le query JSON Oracle in SQL del database PostgreSQL](convert-json-oracle-queries-into-postgresql-database-sql.md) + [Converti VARCHAR2 (1) il tipo di dati per Oracle in tipo di dati booleano per Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Emula Oracle DR utilizzando un database globale Aurora compatibile con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Emula gli array PL/SQL associativi Oracle in Amazon Aurora PostgreSQL e Amazon RDS per PostgreSQL](emulate-oracle-plsql-associative-arrays-in-aurora-and-rds-postgresql.md) + [Stima le dimensioni del motore Amazon RDS per un database Oracle utilizzando i report AWR](estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.md) + [Gestisci blocchi anonimi nelle istruzioni SQL dinamiche in Aurora PostgreSQL](handle-anonymous-blocks-in-dynamic-sql-statements-in-aurora-postgresql.md) + [Migrazione incrementale da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL utilizzando Oracle SQL Developer e AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Carica i file BLOB in formato TEXT utilizzando la codifica dei file in Aurora, compatibile con PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL in modalità SSL utilizzando AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migrazione di un database Amazon RDS for Oracle su Account AWS un altro database Regione AWS e AWS DMS utilizzo per la replica continua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Esegui la migrazione di un database Oracle locale su Amazon EC2 utilizzando Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Esegui la migrazione di un database Oracle locale ad Amazon OpenSearch Service utilizzando Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for MySQL utilizzando AWS DMS e AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle utilizzando l'importazione diretta di Oracle Data Pump tramite un collegamento al database](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle utilizzando Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for PostgreSQL utilizzando un bystander Oracle e AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Esegui la migrazione di un database Oracle locale a Oracle su Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Esegui la migrazione di un database Oracle da Amazon EC2 ad Amazon RDS for MariaDB utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle da Amazon EC2 ad Amazon RDS for Oracle utilizzando AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Esegui la migrazione di un database Oracle ad Amazon DynamoDB utilizzando AWS DMS](migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.md) + [Esegui la migrazione di un database Oracle ad Amazon RDS for Oracle utilizzando gli adattatori flat file GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Esegui la migrazione di un database Oracle ad Amazon Redshift utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle ad Aurora PostgreSQL utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle JD Edwards EnterpriseOne su AWS utilizzando Oracle Data Pump e AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Esegui la migrazione di una tabella partizionata Oracle su PostgreSQL utilizzando AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Esegui la migrazione di un PeopleSoft database Oracle su AWS utilizzando AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Esegui la migrazione dei dati da un database Oracle locale ad Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for PostgreSQL utilizzando viste materializzate e AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for PostgreSQL utilizzando AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Esegui la migrazione da Oracle Database ad Amazon RDS for PostgreSQL utilizzando Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Esegui la migrazione da Oracle su Amazon EC2 ad Amazon RDS for MySQL utilizzando AWS DMS e AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione da Oracle WebLogic ad Apache Tomcat (ToMee) su Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md) + [Migrazione di indici basati su funzioni da Oracle a PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrazione delle applicazioni legacy da Oracle Pro\$1C a ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Esegui la migrazione dei valori Oracle CLOB su singole righe in PostgreSQL su AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Esegui la migrazione dei codici di errore del database Oracle a un database compatibile con Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migrazione delle funzioni native di Oracle su PostgreSQL utilizzando le estensioni](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Esegui la migrazione PeopleSoft da Oracle ad Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Esegui la migrazione della funzionalità Oracle ROWID a PostgreSQL su AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrazione dei pacchetti pragma Oracle SERIALLY\$1REUSABLE in PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migra le colonne virtuali generate da Oracle a PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Monitora GoldenGate i log di Oracle utilizzando Amazon CloudWatch](monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.md) + [Analizza le dipendenze degli oggetti per le migrazioni parziali del database da Oracle a PostgreSQL](multilevel-object-analysis-for-database-migration-from-oracle-to-postgresql.md) + [Ripiattaforma Oracle Database Enterprise Edition alla Standard Edition 2 su Amazon RDS per Oracle](replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.md) + [Configurare un' HA/DR architettura per Oracle E-Business Suite su Amazon RDS Custom con un database di standby attivo](set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database.md) + [Configura la funzionalità Oracle UTL\$1FILE su Aurora, compatibile con PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Ruoli di transizione per un' PeopleSoft applicazione Oracle su Amazon RDS Custom for Oracle](transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.md) + [Convalida gli oggetti del database dopo la migrazione da Oracle ad Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md) # SAP **Topics** + [Esegui automaticamente il backup dei database SAP HANA utilizzando Systems Manager e EventBridge](automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.md) + [Esegui la migrazione da SAP ASE ad Amazon RDS per SQL Server utilizzando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Esegui la migrazione di SAP ASE su Amazon Aurora, compatibile EC2 con PostgreSQL utilizzando AWS SCT e AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Esegui la migrazione da SAP HANA ad AWS utilizzando SAP HSR con lo stesso nome host](migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.md) + [Configura il disaster recovery per SAP su IBM Db2 su AWS](set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.md) # Altri modelli **Topics** + [Accedi a un database Amazon Neptune da un container Amazon EKS](access-amazon-neptune-database-from-amazon-eks-container.md) + [Accedi, esegui query e unisciti a tabelle Amazon DynamoDB utilizzando Athena](access-query-and-join-amazon-dynamodb-tables-using-athena.md) + [Consenti alle EC2 istanze l'accesso in scrittura ai bucket S3 negli account AMS](allow-ec2-instances-write-access-to-s3-buckets-in-ams-accounts.md) + [Analizza e visualizza dati JSON annidati con Amazon Athena e Amazon Quick Sight](analyze-and-visualize-nested-json-data-with-amazon-athena-and-amazon-quicksight.md) + [Automatizza i backup per le istanze DB di Amazon RDS for PostgreSQL utilizzando AWS Batch](automate-backups-for-amazon-rds-for-postgresql-db-instances-by-using-aws-batch.md) + [Archivia automaticamente gli elementi su Amazon S3 utilizzando DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Automatically remediate unencrypted Amazon RDS DB instances and clusters](automatically-remediate-unencrypted-amazon-rds-db-instances-and-clusters.md) + [Arresta e avvia automaticamente un'istanza database Amazon RDS utilizzando AWS Systems Manager Maintenance Windows](automatically-stop-and-start-an-amazon-rds-db-instance-using-aws-systems-manager-maintenance-windows.md) + [Crea una AWS landing zone che includa MongoDB Atlas](build-aws-landing-zone-that-includes-mongodb-atlas.md) + [Crea programmi COBOL Db2 usando e Modernizzazione del mainframe AWS AWS CodeBuild](build-cobol-db2-programs-mainframe-modernization-codebuild.md) + [Crea una rete dati aziendale con Amazon DataZone e AWS CDK AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Modifica le applicazioni Python e Perl per supportare la migrazione dei database da Microsoft SQL Server a Amazon Aurora PostgreSQL Compatible Edition](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Converti e decomprimi i dati EBCDIC in ASCII su AWS usando Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Convertire la funzionalità temporale Teradata NORMALIZE in Amazon Redshift SQL](convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql.md) + [Convertire la funzionalità Teradata RESET WHEN in Amazon Redshift SQL](convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.md) + [Converti VARCHAR2 (1) il tipo di dati per Oracle in tipo di dati booleano per Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Crea utenti e ruoli delle applicazioni in Aurora, compatibile con PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Crea CloudFormation modelli AWS per attività AWS DMS utilizzando Microsoft Excel e Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Distribuisci i record DynamoDB ad Amazon S3 utilizzando Kinesis Data Streams e Firehose con AWS CDK](deliver-dynamodb-records-to-amazon-s3-using-kinesis-data-streams-and-amazon-data-firehose-with-aws-cdk.md) + [Implementa un cluster Cassandra su Amazon EC2 con dati statici privati IPs per evitare il ribilanciamento](deploy-a-cassandra-cluster-on-amazon-ec2-with-private-static-ips-to-avoid-rebalancing.md) + [Implementa un cluster CockroachDB in Amazon EKS utilizzando Terraform](deploy-cockroachdb-on-eks-using-terraform.md) + [Sviluppa assistenti avanzati basati sull'intelligenza artificiale generativa utilizzando RAG e suggerimenti ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md) + [Emula Oracle DR utilizzando un database globale Aurora compatibile con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Abilita l'archiviazione dei DB2 log direttamente su Amazon S3 in un database IBM Db2](enable-db2-logarchive-directly-to-amazon-s3-in-ibm-db2-database.md) + [Abilita la crittografia trasparente dei dati in Amazon RDS for SQL Server](enable-transparent-data-encryption-in-amazon-rds-for-sql-server.md) + [Esportazione di un database Microsoft SQL Server in Amazon S3 utilizzando AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [SHA1 Implementa l'hashing per i dati PII durante la migrazione da SQL Server a PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Migrazione incrementale da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL utilizzando Oracle SQL Developer e AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Carica i file BLOB in formato TEXT utilizzando la codifica dei file in Aurora, compatibile con PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Gestisci le credenziali con AWS Secrets Manager](manage-credentials-using-aws-secrets-manager.md) + [Esegui la migrazione di un database Db2 da Amazon a EC2 Aurora compatibile con MySQL utilizzando AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Esegui la migrazione di un database Microsoft SQL Server da Amazon EC2 ad Amazon DocumentDB utilizzando AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Esegui la migrazione di un database Microsoft SQL Server su Aurora MySQL utilizzando AWS DMS e AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL in modalità SSL utilizzando AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL con e utilizzando e AWS SCT AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Esegui la migrazione di un'istanza database Amazon RDS su un altro VPC o account](migrate-an-amazon-rds-db-instance-to-another-vpc-or-account.md) + [Migrazione di un database Amazon RDS for Oracle su Account AWS un altro database Regione AWS e AWS DMS utilizzo per la replica continua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Esegui la migrazione di un cluster Amazon Redshift in una regione AWS in Cina](migrate-an-amazon-redshift-cluster-to-an-aws-region-in-china.md) + [Esegui la migrazione di un database MariaDB locale su Amazon RDS for MariaDB utilizzando strumenti nativi](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server utilizzando server collegati](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon RDS for SQL Server utilizzando metodi di backup e ripristino nativi](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon Redshift utilizzando AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon Redshift utilizzando gli agenti di estrazione dati AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Esegui la migrazione di un database Microsoft SQL Server locale a Microsoft SQL Server su Amazon EC2 con Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Esegui la migrazione di un database MySQL locale su Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Esegui la migrazione di un database MySQL locale su Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Esegui la migrazione di un database Oracle locale su Amazon EC2 utilizzando Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Esegui la migrazione di un database Oracle locale ad Amazon OpenSearch Service utilizzando Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for MySQL utilizzando AWS DMS e AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle utilizzando l'importazione diretta di Oracle Data Pump tramite un collegamento al database](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for Oracle utilizzando Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Esegui la migrazione di un database Oracle locale ad Amazon RDS for PostgreSQL utilizzando un bystander Oracle e AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Esegui la migrazione di un database Oracle locale a Oracle su Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Esegui la migrazione di un database PostgreSQL locale su Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Esegui la migrazione di un database ThoughtSpot Falcon locale su Amazon Redshift](migrate-an-on-premises-thoughtspot-falcon-database-to-amazon-redshift.md) + [Esegui la migrazione di un database Oracle da Amazon EC2 ad Amazon RDS for MariaDB utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle da Amazon EC2 ad Amazon RDS for Oracle utilizzando AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Esegui la migrazione di un database Oracle ad Amazon RDS for Oracle utilizzando gli adattatori flat file GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Esegui la migrazione di un database Oracle ad Amazon Redshift utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle ad Aurora PostgreSQL utilizzando AWS DMS e AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione di un database Oracle JD Edwards EnterpriseOne su AWS utilizzando Oracle Data Pump e AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Esegui la migrazione di una tabella partizionata Oracle su PostgreSQL utilizzando AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Esegui la migrazione di un PeopleSoft database Oracle su AWS utilizzando AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Esegui la migrazione di un database Couchbase Server su Amazon EC2](migrate-couchbase-server-ec2.md) + [Esegui la migrazione dei dati da un database Oracle locale ad Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migrare i dati verso il Cloud AWS utilizzando Starburst](migrate-data-to-the-aws-cloud-by-using-starburst.md) + [Esegui la migrazione di Db2 for LUW ad Amazon EC2 utilizzando la spedizione di log per ridurre i tempi di interruzione](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Esegui la migrazione di Db2 per LUW ad Amazon EC2 con disaster recovery ad alta disponibilità](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Esegui la migrazione da Amazon RDS for Oracle ad Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migrazione da Couchbase Server a Couchbase Capella su AWS](migrate-from-couchbase-server-to-couchbase-capella-on-aws.md) + [Esegui la migrazione da IBM Db2 su Amazon a EC2 Aurora PostgreSQL compatibile con AWS DMS e AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for PostgreSQL utilizzando viste materializzate e AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Esegui la migrazione da Oracle 8i o 9i ad Amazon RDS for PostgreSQL utilizzando AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Esegui la migrazione da Oracle Database ad Amazon RDS for PostgreSQL utilizzando Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Esegui la migrazione da Oracle su Amazon EC2 ad Amazon RDS for MySQL utilizzando AWS DMS e AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Esegui la migrazione da PostgreSQL su Amazon RDS per PostgreSQL utilizzando EC2 pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Esegui la migrazione da SAP ASE ad Amazon RDS per SQL Server utilizzando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migrazione di indici basati su funzioni da Oracle a PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrazione delle applicazioni legacy da Oracle Pro\$1C a ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Esegui la migrazione di un database Microsoft SQL Server locale su Amazon EC2 utilizzando Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Esegui la migrazione dei carichi di lavoro Cloudera locali a Cloudera Data Platform su AWS](migrate-on-premises-cloudera-workloads-to-cloudera-data-platform-on-aws.md) + [Esegui la migrazione dei database MySQL locali su Aurora MySQL utilizzando Percona, Amazon EFS e Amazon S3 XtraBackup](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Esegui la migrazione di Oracle Business Intelligence 12c al cloud AWS dai server locali](migrate-oracle-business-intelligence-12c-to-the-aws-cloud-from-on-premises-servers.md) + [Esegui la migrazione dei valori Oracle CLOB su singole righe in PostgreSQL su AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Esegui la migrazione dei codici di errore del database Oracle a un database compatibile con Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Esegui la migrazione di tabelle esterne Oracle verso Amazon Aurora, compatibile con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migrazione delle funzioni native di Oracle su PostgreSQL utilizzando le estensioni](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Esegui la migrazione PeopleSoft da Oracle ad Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Esegui la migrazione della funzionalità Oracle ROWID a PostgreSQL su AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrazione dei pacchetti pragma Oracle SERIALLY\$1REUSABLE in PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Esegui la migrazione di SAP ASE su Amazon Aurora, compatibile EC2 con PostgreSQL utilizzando AWS SCT e AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migra le colonne virtuali generate da Oracle a PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Imposta uno spazio dati minimo praticabile per condividere i dati tra le organizzazioni](minimum-viable-data-space-share-data-organizations.md) + [Monitora ElastiCache i cluster Amazon per la crittografia a riposo](monitor-amazon-elasticache-clusters-for-at-rest-encryption.md) + [Interroga le tabelle Amazon DynamoDB con SQL utilizzando Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md) + [Proteggi e semplifica l'accesso degli utenti in un database federativo Db2 su AWS utilizzando contesti affidabili](secure-and-streamline-user-access-in-a-db2-federation-database-on-aws-by-using-trusted-contexts.md) + [Configura un' PeopleSoft architettura ad alta disponibilità su AWS](set-up-a-highly-available-peoplesoft-architecture-on-aws.md) + [Configura la funzionalità Oracle UTL\$1FILE su Aurora, compatibile con PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Semplifica le implementazioni di PostgreSQL su Amazon EKS utilizzando PGO](streamline-postgresql-deployments-amazon-eks-pgo.md) + [Trasferisci z/OS dati Db2 su larga scala su Amazon S3 in file CSV](transfer-large-scale-db2-z-os-data-to-amazon-s3-in-csv-files.md) + [Trasporta i database PostgreSQL tra due istanze DB Amazon RDS utilizzando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Convalida gli oggetti del database dopo la migrazione da Oracle ad Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md)
conn_string = "dbname='%s' port='%s' user='%s' password='%s' host='%s'" \
% (redshift_db,
secret_dict["port"],
secret_dict["username"],
secret_dict["password"],
secret_dict["host"])
con = psycopg2.connect(conn_string)
unload_command = "UNLOAD ('{}') TO '{}' IAM_ROLE '{}' DELIMITER '|' REGION '{}';" \
.format(sql_query,
s3_bucket_path + str(datetime.datetime.now()) + ".csv",
chained_s3_write_role,
s3_bucket_region)
# Opening a cursor and run query
cur = con.cursor()
cur.execute(unload_command)
print(cur.fetchone())
cur.close()
con.close()