Einrichten der pgAudit-Erweiterung Überprüfen von Datenbankobjekten Benutzer oder Datenbanken von der Audit-Protokollierung ausschließen Referenz für die Parameter der pgAudit-Erweiterung

Verwenden von pgAudit zur Protokollierung der Datenbankaktivität

Finanzinstitute, Behörden und viele Branchen müssen Audit-Protokolle aufbewahren, um die gesetzlichen Bestimmungen zu erfüllen. Durch die Verwendung der PostgreSQL-Audit-Erweiterung (pgAudit) mit Ihrem DB-Cluster von Aurora PostgreSQL können Sie die detaillierten Datensätze erfassen, die normalerweise von Prüfern oder zur Erfüllung gesetzlicher Bestimmungen benötigt werden. Sie können beispielsweise die pgAudit-Erweiterung einrichten, um Änderungen an bestimmten Datenbanken und Tabellen nachzuverfolgen, den Benutzer zu erfassen, der die Änderung vorgenommen hat, und viele andere Details.

Die pgAudit-Erweiterung baut auf der Funktionalität der nativen PostgreSQL-Protokollierungsinfrastruktur auf, indem sie die Protokollmeldungen um Details erweitert. Mit anderen Worten, Sie verwenden für die Anzeige Ihres Audit-Protokolls den gleichen Ansatz wie für die Anzeige von Protokollmeldungen. Weitere Informationen zur PostgreSQL-Protokollierung finden Sie unter Datenbank-Protokolldateien von Aurora PostgreSQL.

Die pgAudit-Erweiterung redigiert sensible Daten wie Klartext-Passwörter aus den Protokollen. Wenn Ihr DB-Cluster von Aurora PostgreSQL so konfiguriert ist, dass Data Manipulation Language (DML)-Anweisungen protokolliert werden, wie in Aktivieren der Abfrageprotokollierung für Ihren DB-Cluster von Aurora PostgreSQL beschrieben, können Sie das Klartext-Passwortproblem mithilfe der PostgreSQL-Audit-Erweiterung vermeiden.

Sie können das Auditing für Ihre Datenbank-Instances mit einem hohen Grad an Spezifität konfigurieren. Sie können alle Datenbanken und alle Benutzer überprüfen. Sie können auch festlegen, dass nur bestimmte Datenbanken, Benutzer und andere Objekte überprüft werden. Bestimmte Benutzer und Datenbanken können Sie auch explizit von der Prüfung ausschließen. Weitere Informationen finden Sie unter Benutzer oder Datenbanken von der Audit-Protokollierung ausschließen.

Angesichts der Menge an Details, die erfasst werden können, empfehlen wir, dass Sie bei Verwendung von pgAudit Ihren Speicherverbrauch überwachen.

Die pgAudit-Erweiterung wird von allen verfügbaren Aurora-PostgreSQL-Versionen unterstützt. Eine Liste der pgAudit-Versionen, die von Aurora PostgreSQL unterstützt werden, finden Sie unter Versionen der Erweiterungen für Amazon Aurora PostgreSQL in den Versionshinweisen für Aurora PostgreSQL.

Themen

Einrichten der pgAudit-Erweiterung
Überprüfen von Datenbankobjekten
Benutzer oder Datenbanken von der Audit-Protokollierung ausschließen
Referenz für die pgAudit-Erweiterung

Einrichten der pgAudit-Erweiterung

Wenn Sie die pgAudit-Erweiterung auf einrichten möchten, fügen Sie zunächst pgAudit zu den gemeinsam genutzten Bibliotheken in der benutzerdefinierten DB-Cluster-Parametergruppe für Ihren DB-Cluster von Aurora PostgreSQL hinzu. Weitere Informationen über das Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe finden Sie unter Arbeiten mit Parametergruppen. Als Nächstes installieren Sie die pgAudit-Erweiterung. Abschließend geben Sie die Datenbanken und Objekte an, die Sie überprüfen möchten. Die Schritte in diesem Abschnitt veranschaulichen die Vorgehensweise. Sie können die AWS Management Console oder die AWS CLI verwenden.

Sie müssen über Berechtigungen als rds_superuser-Rolle verfügen, um alle diese Aufgaben ausführen zu können.

Bei den folgenden Schritten wird davon ausgegangen, dass Ihr DB-Cluster von Aurora PostgreSQL einer benutzerdefinierten DB-Cluster -Parametergruppe zugeordnet ist.

So richten Sie die pgAudit-Erweiterung ein

Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.
Wählen Sie im Navigationsbereich Ihre Writer-Instance des DB-Clusters von Aurora PostgreSQL aus.
Öffnen Sie die Registerkarte Configuration (Konfiguration) für Ihre Writer-Instance des DB-Clusters von Aurora PostgreSQL. Suchen Sie in den Instance-Details den Link Parameter group (Parametergruppe).
Wählen Sie den Link aus, um die benutzerdefinierten Parameter zu öffnen, die Ihrem DB-Cluster von Aurora PostgreSQL zugeordnet sind.
Geben Sie in das Suchfeld Parameters (Parameter) shared_pre ein, um den shared_preload_libraries-Parameter zu finden.
Wählen Sie Edit parameters (Parameter bearbeiten) aus, um auf die Eigenschaftswerte zuzugreifen.
Fügen Sie pgaudit der Liste im Feld Values (Werte) hinzu. Verwenden Sie ein Komma, um Elemente in der Werteliste zu trennen.
Starten Sie die Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL neu, damit Ihre Änderung des shared_preload_libraries-Parameters wirksam wird.
Wenn die Instance verfügbar ist, stellen Sie sicher, dass pgAudit initialisiert wurde. Stellen Sie über psql eine Verbindung mit der Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL her und führen Sie den folgenden Befehl aus.
```
SHOW shared_preload_libraries;
shared_preload_libraries 
--------------------------
rdsutils,pgaudit
(1 row) 
```
Wenn pgAudit initialisiert ist, können Sie jetzt die Erweiterung erstellen. Sie müssen die Erweiterung nach dem Initialisieren der Bibliothek erstellen, da die pgaudit-Erweiterung Ereignisauslöser für die Überwachung von Data Definition Language (DDL)-Anweisungen installiert.
```
CREATE EXTENSION pgaudit;
```
Schließen Sie die psql-Sitzung.
```
labdb=> \q
```
Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.
Suchen Sie den pgaudit.log-Parameter in der Liste und legen Sie den entsprechenden Wert für Ihren Anwendungsfall fest. Wenn Sie beispielsweise den pgaudit.log-Parameter auf write festlegen, wie in der folgenden Abbildung gezeigt, werden Einfügungen, Aktualisierungen, Löschungen und einige andere Typänderungen im Protokoll erfasst.

Sie können auch einen der folgenden Werte für den pgaudit.log-Parameter auswählen.
- „none“: Dies ist der Standardwert. Es werden keine Datenbankänderungen protokolliert.
- „all“: Es wird alles protokolliert (Lesen, Schreiben, Funktion, Rolle, DDL, Verschiedenes).
- „ddl“: Protokolliert alle Data Definition Language (DDL)-Anweisungen, die nicht in der ROLE-Klasse enthalten sind.
- „function“: Protokolliert Funktionsaufrufe und DO-Blöcke.
- „misc“: Protokolliert verschiedene Befehle wie DISCARD, FETCH, CHECKPOINT, VACUUM und SET.
- „read“: Protokolliert SELECT und COPY, wenn die Quelle eine Beziehung (z. B. eine Tabelle) oder eine Abfrage ist.
- „role“: Protokolliert Anweisungen in Bezug auf Rollen und Berechtigungen wie GRANT, REVOKE, CREATE ROLE, ALTER ROLE und DROP ROLE.
- „write“: Protokolliert INSERT, UPDATE, DELETE, TRUNCATE und COPY, wenn das Ziel eine Beziehung (Tabelle) ist.
Wählen Sie Änderungen speichern aus.
Öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.
Wählen Sie aus der Liste der Datenbanken Ihre Writer-Instance des DB-Clusters von Aurora PostgreSQL und dann im Menü „Actions“ (Aktionen) die Option Reboot (Neustart) aus.

So richten Sie pgAudit ein

Um pgAudit mit der einzurichtenAWS CLI, rufen Sie die -modify-db-parameter-groupOperation auf, um die Audit-Protokollparameter in Ihrer benutzerdefinierten Parametergruppe zu ändern, wie im folgenden Verfahren gezeigt.

Verwenden Sie den folgenden AWS CLI-Befehl, um dem shared_preload_libraries-Parameter pgaudit hinzuzufügen.


aws rds modify-db-parameter-group \
   --db-parameter-group-name custom-param-group-name \
   --parameters "ParameterName=shared_preload_libraries,ParameterValue=pgaudit,ApplyMethod=pending-reboot" \
   --region aws-region

Verwenden Sie den folgendenAWS CLI Befehl, um die Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL neu zu starten, sodass die pgaudit-Bibliothek initialisiert wird.
```
aws rds reboot-db-instance \
    --db-instance-identifier writer-instance \
    --region aws-region
```
Wenn die Instance verfügbar ist, können Sie überprüfen, ob pgaudit initialisiert wurde. Stellen Sie über psql eine Verbindung mit der Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL her und führen Sie den folgenden Befehl aus.
```
SHOW shared_preload_libraries;
shared_preload_libraries 
--------------------------
rdsutils,pgaudit
(1 row) 
```
Wenn pgAudit initialisiert ist, können Sie jetzt die Erweiterung erstellen.
```
CREATE EXTENSION pgaudit;
```
Schließen Sie die psql-Sitzung, damit Sie die AWS CLI verwenden können.
```
labdb=> \q
```
Verwenden Sie den folgenden AWS CLI-Befehl, um die Anweisungsklassen anzugeben, die von der Sitzungsüberwachungsprotokollierung erfasst werden sollen. Im Beispiel wird der pgaudit.log-Parameter auf write festgelegt, wodurch Einfügungen, Aktualisierungen und Löschungen im Protokoll erfasst werden.
```
aws rds modify-db-parameter-group \
   --db-parameter-group-name custom-param-group-name \
   --parameters "ParameterName=pgaudit.log,ParameterValue=write,ApplyMethod=pending-reboot" \
   --region aws-region
```
Sie können auch einen der folgenden Werte für den pgaudit.log-Parameter auswählen.
- „none“: Dies ist der Standardwert. Es werden keine Datenbankänderungen protokolliert.
- „all“: Es wird alles protokolliert (Lesen, Schreiben, Funktion, Rolle, DDL, Verschiedenes).
- „ddl“: Protokolliert alle Data Definition Language (DDL)-Anweisungen, die nicht in der ROLE-Klasse enthalten sind.
- „function“: Protokolliert Funktionsaufrufe und DO-Blöcke.
- „misc“: Protokolliert verschiedene Befehle wie DISCARD, FETCH, CHECKPOINT, VACUUM und SET.
- „read“: Protokolliert SELECT und COPY, wenn die Quelle eine Beziehung (z. B. eine Tabelle) oder eine Abfrage ist.
- „role“: Protokolliert Anweisungen in Bezug auf Rollen und Berechtigungen wie GRANT, REVOKE, CREATE ROLE, ALTER ROLE und DROP ROLE.
- „write“: Protokolliert INSERT, UPDATE, DELETE, TRUNCATE und COPY, wenn das Ziel eine Beziehung (Tabelle) ist.
Starten Sie die Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL mit dem folgenden AWS CLI-Befehl neu.
```
aws rds reboot-db-instance \
    --db-instance-identifier writer-instance \
    --region aws-region
```

Überprüfen von Datenbankobjekten

Wenn pgAudit auf Ihrem DB-Cluster von Aurora PostgreSQL eingerichtet und für Ihre Anforderungen konfiguriert ist, werden detailliertere Informationen im PostgreSQL-Protokoll erfasst. Während die PostgreSQL-Standardprotokollierungskonfiguration beispielsweise das Datum und die Uhrzeit angibt, zu der eine Änderung in einer Datenbanktabelle vorgenommen wurde, kann der Protokolleintrag mit der pgAudit-Erweiterung das Schema, den Benutzer, der die Änderung vorgenommen hat, und andere Details enthalten, je nachdem, wie die Erweiterungsparameter konfiguriert sind. Sie können das Auditing einrichten, um Änderungen wie folgt zu verfolgen.

Für jede Sitzung, nach Benutzer. Auf der Sitzungsebene können Sie den vollständig qualifizierten Befehlstext erfassen.
Für jedes Objekt, nach Benutzer und nach Datenbank.

Die Objektüberwachungsfunktion wird aktiviert, wenn Sie die rds_pgaudit-Rolle in Ihrem System erstellen und diese Rolle dann dem pgaudit.role-Parameter in Ihrer benutzerdefinierten Parametergruppe hinzufügen. Standardmäßig ist der pgaudit.role-Parameter nicht festgelegt und der einzig zulässige Wert ist rds_pgaudit. Bei den folgenden Schritten wird davon ausgegangen, dass pgaudit initialisiert wurde und Sie die pgaudit-Erweiterung gemäß den Schritten unter Einrichten der pgAudit-Erweiterung erstellt haben.

Bild der PostgreSQL-Protokolldatei nach dem Einrichten von pgAudit.

Wie in diesem Beispiel gezeigt, enthält die Zeile „LOG: AUDIT: SESSION“ unter anderem Informationen über die Tabelle und deren Schema.

So richten Sie die Objektüberwachung ein

Stellen Sie über psql eine Verbindung mit der Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL her.


psql --host=your-instance-name.aws-region.rds.amazonaws.com --port=5432 --username=postgrespostgres --password --dbname=labdb

Erstellen Sie mithilfe des folgenden Befehls eine Datenbankrolle mit dem Namen rds_pgaudit.
```
labdb=> CREATE ROLE rds_pgaudit;
CREATE ROLE
labdb=> 
```
Schließen Sie die psql-Sitzung.
```
labdb=> \q
```
Verwenden Sie in den nächsten Schritten die AWS CLI, um die Audit-Protokollparameter in Ihrer benutzerdefinierten Parametergruppe zu ändern.

Verwenden Sie den folgenden AWS CLI-Befehl, um den pgaudit.role-Parameter auf rds_pgaudit festzulegen. Standardmäßig ist dieser Parameter leer und der einzig zulässige Wert ist rds_pgaudit.


aws rds modify-db-parameter-group \
   --db-parameter-group-name custom-param-group-name \
   --parameters "ParameterName=pgaudit.role,ParameterValue=rds_pgaudit,ApplyMethod=pending-reboot" \
   --region aws-region

Starten Sie die Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL mit dem folgenden AWS CLI-Befehl neu, damit Ihre Änderungen der Parameter wirksam werden.
```
aws rds reboot-db-instance \
    --db-instance-identifier writer-instance \
    --region aws-region
```
Führen Sie den folgenden Befehl aus, um zu bestätigen, dass pgaudit.role auf rds_pgaudit festgelegt ist.
```
SHOW pgaudit.role;
pgaudit.role 
------------------
rds_pgaudit 
```

Um die pgAudit-Protokollierung zu testen, können Sie mehrere Beispielbefehle ausführen, die Sie überprüfen möchten. Sie könnten beispielsweise die folgenden Befehle ausführen.


CREATE TABLE t1 (id int);
GRANT SELECT ON t1 TO rds_pgaudit;
SELECT * FROM t1;
id 
----
(0 rows)

Die Datenbankprotokolle sollten dann einen Eintrag ähnlich dem folgenden enthalten.


...
2017-06-12 19:09:49 UTC:...:rds_test@postgres:[11701]:LOG: AUDIT:
OBJECT,1,1,READ,SELECT,TABLE,public.t1,select * from t1;
...

Weitere Informationen zur Anzeige der Protokolle finden Sie unter Überwachen von Amazon Aurora-Protokolldateien.

Weitere Informationen zur pgAudit-Erweiterung finden Sie unter pgAudit auf GitHub.

Benutzer oder Datenbanken von der Audit-Protokollierung ausschließen

Wie unter Datenbank-Protokolldateien von Aurora PostgreSQL beschrieben, verbrauchen PostgreSQL-Protokolle Speicherplatz. Die Verwendung der pgAudit-Erweiterung erhöht die in Ihren Protokollen gesammelte Datenmenge je nach den von Ihnen verfolgten Änderungen in unterschiedlichem Maße. Möglicherweise müssen Sie nicht jeden Benutzer oder jede Datenbank in Ihrem DB-Cluster von Aurora PostgreSQL überwachen.

Sie können Benutzer und Datenbanken von der Prüfung ausschließen, um die Auswirkungen auf Ihren Speicher zu minimieren und die unnötige Erfassung von Audit-Datensätzen zu vermeiden. Sie können die Protokollierung auch innerhalb einer bestimmten Sitzung ändern. In den nachstehenden Beispielen wird die Vorgehensweise dazu veranschaulicht.

Anmerkung

Parametereinstellungen auf Sitzungsebene haben Vorrang vor den Einstellungen in der benutzerdefinierten DB-Cluster-Parametergruppe der Writer-Instance des DB-Clusters von Aurora PostgreSQL. Wenn Sie nicht möchten, dass Datenbankbenutzer Ihre Konfigurationseinstellungen für die Audit-Protokollierung umgehen, müssen Sie ihre Berechtigungen ändern.

Angenommen, Ihr DB-Cluster von Aurora PostgreSQL ist so konfiguriert, dass derselbe Aktivitätsgrad für alle Benutzer und Datenbanken überprüft wird. Sie entscheiden dann, dass Sie den Benutzer myuser nicht überprüfen möchten. Sie können das Auditing für myuser mit dem folgenden SQL-Befehl deaktivieren.


ALTER USER myuser SET pgaudit.log TO 'NONE';

Anschließend können Sie die folgende Abfrage verwenden, um die Spalte user_specific_settings auf pgaudit.log zu überprüfen und zu bestätigen, dass der Parameter auf NONE festgelegt ist.


SELECT
    usename AS user_name,
    useconfig AS user_specific_settings
FROM
    pg_user
WHERE
    usename = 'myuser';

Die Ausgabe sollte folgendermaßen aussehen.


 user_name | user_specific_settings
-----------+------------------------
 myuser    | {pgaudit.log=NONE}
(1 row)

Sie können die Protokollierung für einen bestimmten Benutzer während seiner Datenbanksitzung mit dem folgenden Befehl deaktivieren.


ALTER USER myuser IN DATABASE mydatabase SET pgaudit.log TO 'none';

Verwenden Sie die folgende Abfrage, um die Einstellungsspalte für eine bestimmte Benutzer- und Datenbankkombination auf pgaudit.log zu überprüfen.


SELECT
    usename AS "user_name",
    datname AS "database_name",
    pg_catalog.array_to_string(setconfig, E'\n') AS "settings"
FROM
    pg_catalog.pg_db_role_setting s
    LEFT JOIN pg_catalog.pg_database d ON d.oid = setdatabase
    LEFT JOIN pg_catalog.pg_user r ON r.usesysid = setrole
WHERE
    usename = 'myuser'
    AND datname = 'mydatabase'
ORDER BY
    1,
    2;

Die Ausgabe entspricht weitgehend der folgenden.


  user_name | database_name |     settings
-----------+---------------+------------------
 myuser    | mydatabase    | pgaudit.log=none
(1 row)

Nachdem Sie das Auditing für myuser deaktiviert haben, entscheiden Sie, dass Sie Änderungen an mydatabase nicht verfolgen möchten. Sie können das Auditing für diese spezifische Datenbank mit dem folgenden Befehl deaktivieren.


ALTER DATABASE mydatabase SET pgaudit.log to 'NONE';

Verwenden Sie dann die folgende Abfrage, um die Spalte database_specific_settings zu überprüfen und zu bestätigen, dass pgaudit.log auf NONE festgelegt ist.


SELECT
a.datname AS database_name,
b.setconfig AS database_specific_settings
FROM
pg_database a
FULL JOIN pg_db_role_setting b ON a.oid = b.setdatabase
WHERE
a.datname = 'mydatabase';

Die Ausgabe sollte folgendermaßen aussehen.


 database_name | database_specific_settings
---------------+----------------------------
 mydatabase    | {pgaudit.log=NONE}
(1 row)

Verwenden Sie den folgenden Befehl, um die Einstellungen wieder auf die Standardeinstellung für myuser festzulegen:


ALTER USER myuser RESET pgaudit.log;

Verwenden Sie den folgenden Befehl, um die Einstellungen wieder auf die Standardeinstellung für eine Datenbank festzulegen.


ALTER DATABASE mydatabase RESET pgaudit.log;

Verwenden Sie den folgenden Befehl, um Benutzer und Datenbank wieder auf die Standardeinstellung festzulegen.


ALTER USER myuser IN DATABASE mydatabase RESET pgaudit.log;

Sie können auch bestimmte Ereignisse im Protokoll erfassen, indem Sie pgaudit.log auf einen der anderen zulässigen Werte für den pgaudit.log-Parameter festlegen. Weitere Informationen finden Sie unter Liste der zulässigen Einstellungen für den pgaudit.log-Parameter.


ALTER USER myuser SET pgaudit.log TO 'read';
ALTER DATABASE mydatabase SET pgaudit.log TO 'function';
ALTER USER myuser IN DATABASE mydatabase SET pgaudit.log TO 'read,function'

Referenz für die pgAudit-Erweiterung

Sie können den gewünschten Detaillierungsgrad für Ihr Audit-Protokoll angeben, indem Sie einen oder mehrere der in diesem Abschnitt aufgeführten Parameter ändern.

Steuern des pgAudit-Verhaltens

Sie können die Audit-Protokollierung steuern, indem Sie einen oder mehrere der in der folgenden Tabelle aufgeführten Parameter ändern.

Parameter	Beschreibung
`pgaudit.log`	Gibt die Anweisungsklassen an, die durch die Sitzungs-Audit-Protokollierung erfasst werden. Zulässige Werte sind „ddl“, „function“, „misc“, „read“, „role“, „write“, „none“, „all“. Weitere Informationen finden Sie unter Liste der zulässigen Einstellungen für den pgaudit.log-Parameter.
`pgaudit.log_catalog`	Wenn diese Option aktiviert ist (auf 1 festgelegt), werden Anweisungen zum Audit-Trail hinzugefügt, wenn sich alle Beziehungen in einer Anweisung in pg_catalog befinden.
`pgaudit.log_level`	Gibt die Protokollstufe an, die für Protokolleinträge verwendet werden soll. Zulässige Werte: „debug5“, „debug4“, „debug3“, „debug2“, „debug1“, „info“, „notice“, „warning“, „log“
`pgaudit.log_parameter`	Wenn diese Option aktiviert ist (auf 1 festgelegt), werden die mit der Anweisung übergebenen Parameter im Audit-Protokoll erfasst.
`pgaudit.log_relation`	Wenn diese Option aktiviert ist (auf 1 festgelegt), erstellt das Audit-Protokoll für die Sitzung einen separaten Protokolleintrag für jede Beziehung (TABLE, VIEW usw.), auf die in einer SELECT- oder DML-Anweisung verwiesen wird.
`pgaudit.log_statement_once`	Gibt an, ob die Protokollierung den Anweisungstext und die Parameter mit dem ersten Protokolleintrag für eine Kombination aus Anweisung/Unteranweisung oder bei jedem Eintrag enthält.
`pgaudit.role`	Gibt die Hauptrolle an, die für die Objektüberwachungsprotokollierung verwendet werden soll. Der einzig zulässige Eintrag ist `rds_pgaudit`.

Liste der zulässigen Einstellungen für den `pgaudit.log`-Parameter

Wert	Beschreibung
none	Dies ist die Standardeinstellung. Es werden keine Datenbankänderungen protokolliert.
all	Protokolliert alles (Lesen, Schreiben, Funktion, Rolle, DDL, Verschiedenes).
ddl	Protokolliert alle Data Definition Language (DDL)-Anweisungen, die nicht in der `ROLE`-Klasse enthalten sind.
function	Protokolliert Funktionsaufrufe und `DO`-Blöcke.
misc	Protokolliert verschiedene Befehle wie `DISCARD`, `FETCH`, `CHECKPOINT`, `VACUUM` und `SET`.
read	Protokolliert `SELECT` und `COPY`, wenn die Quelle eine Beziehung (z. B. eine Tabelle) oder eine Abfrage ist.
role	Protokolliert Anweisungen in Bezug auf Rollen und Berechtigungen wie `REVOKE`, `CREATE ROLE`, `ALTER ROLE` und `DROP ROLE`.
write	Protokolliert `INSERT`, `UPDATE`, `DELETE`, `TRUNCATE` und `COPY`, wenn das Ziel eine Beziehung (Tabelle) ist.

Um mehrere Ereignistypen mit der Sitzungsüberwachung zu protokollieren, verwenden Sie eine kommagetrennte Liste. Um alle Ereignistypen zu protokollieren, legen Sie pgaudit.log auf ALL fest. Starten Sie Ihre DB-Instance neu, um die Änderungen zu übernehmen.

Mit der Objektüberwachung können Sie die Überwachungsprotokollierung verfeinern, um mit bestimmten Beziehungen zu arbeiten. Sie können z. B. angeben, dass Sie eine Audit-Protokollierung für READ-Vorgänge in einer oder mehreren Tabellen wünschen.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Planen der Wartung mit der Erweiterung pg_cron

Verwenden von pglogical, um Daten zu synchronisieren