Automatisierung täglicher PostgreSQL-Aufgaben mit Jenkins

Dieser Blog ist eine kurze Präsentation über Jenkins und zeigt Ihnen, wie Sie dieses Tool verwenden können, um einige Ihrer täglichen PostgreSQL-Administrations- und Verwaltungsaufgaben zu unterstützen.

Über Jenkins

Jenkins ist eine Open-Source-Software für die Automatisierung. Es wurde in Java entwickelt und ist eines der beliebtesten Tools für Continuous Integration (CI) und Continuous Delivery (CD).

2010, nach der Übernahme von Sun Microsystems durch Oracle, lag die „Hudson“-Software im Streit mit ihrer Open-Source-Community. Dieser Streit wurde zur Grundlage für den Start des Jenkins-Projekts.

Heutzutage sind „Hudson“ (Eclipse Public License) und „Jenkins“ (MIT-Lizenz) zwei aktive und unabhängige Projekte mit sehr ähnlichem Zweck.

Jenkins verfügt über Tausende von Plugins, die Sie verwenden können, um die Entwicklungsphase durch Automatisierung für den gesamten Entwicklungslebenszyklus zu beschleunigen; Erstellen, Dokumentieren, Testen, Paketieren, Bereitstellen und Bereitstellen.

Was macht Jenkins?

Obwohl die Hauptverwendung von Jenkins Continuous Integration (CI) und Continuous Delivery (CD) sein könnte, hat diese Open Source eine Reihe von Funktionalitäten und kann ohne Verpflichtung oder Abhängigkeit von CI oder CD verwendet werden, daher bietet Jenkins einige interessante Funktionalitäten an erkunden:

• Terminjobs planen (anstatt das traditionelle crontab zu verwenden )
• Überwachung von Jobs, ihren Protokollen und Aktivitäten durch eine übersichtliche Ansicht (da sie eine Option zur Gruppierung haben)
• Die Aufrechterhaltung von Arbeitsplätzen könnte leicht durchgeführt werden; vorausgesetzt, Jenkins hat eine Reihe von Optionen dafür
• Einrichten und Planen der Softwareinstallation (mithilfe von Puppet) auf demselben Host oder auf einem anderen.
• Veröffentlichen von Berichten und Senden von E-Mail-Benachrichtigungen

PostgreSQL-Aufgaben in Jenkins ausführen

Es gibt drei allgemeine Aufgaben, die ein PostgreSQL-Entwickler oder Datenbankadministrator täglich erledigen muss:

1. Planung und Ausführung von PostgreSQL-Skripten
2. Ausführen eines PostgreSQL-Prozesses, der aus drei oder mehr Skripten besteht
3. Kontinuierliche Integration (CI) für PL/pgSQL-Entwicklungen

Für die Ausführung dieser Beispiele wird davon ausgegangen, dass Jenkins- und PostgreSQL-Server (mindestens Version 9.5) installiert sind und ordnungsgemäß funktionieren.

Planung und Ausführung eines PostgreSQL-Skripts

In den meisten Fällen die Implementierung von täglichen (oder periodischen) PostgreSQL-Skripten zur Ausführung einer üblichen Aufgabe wie ...

• Erstellung von Backups
• Testen Sie die Wiederherstellung einer Sicherung
• Ausführung einer Abfrage zu Berichtszwecken
• Protokolldateien bereinigen und archivieren
• Aufrufen einer PL/pgSQL-Prozedur zum Löschen von Tabellen

t ist auf crontab definiert :

0 5,17 * * * /filesystem/scripts/archive_logs.sh
0 2 * * * /db/scripts/db_backup.sh
0 6 * * * /db/data/scripts/backup_client_tables.sh
0 4 * * * /db/scripts/Test_db_restore.sh
*/10 * * * * /db/scripts/monitor.sh
0 4 * * * /db/data/scripts/queries.sh
0 4 * * * /db/scripts/data_extraction.sh
0 5 * * * /db/scripts/data_import.sh
0 */4 * * * /db/data/scripts/report.sh

Als crontab ist nicht das beste benutzerfreundliche Tool, um diese Art der Planung zu verwalten, es kann auf Jenkins mit den folgenden Vorteilen durchgeführt werden ...

• Sehr benutzerfreundliche Oberfläche, um ihren Fortschritt und aktuellen Status zu überwachen
• Die Protokolle sind sofort verfügbar und es ist keine besondere Berechtigung erforderlich, um darauf zuzugreifen
• Der Job könnte stattdessen manuell auf Jenkins ausgeführt werden, um eine Planung zu haben
• Für einige Jobs müssen Benutzer und Passwörter nicht in Klartextdateien definiert werden, wie es Jenkins auf sichere Weise tut
• Die Jobs könnten als API-Ausführung definiert werden

Daher könnte es eine gute Lösung sein, die Jobs im Zusammenhang mit PostgreSQL-Aufgaben nach Jenkins anstelle von crontab zu migrieren.

Andererseits verfügen die meisten Datenbankadministratoren und -entwickler über starke Kenntnisse in Skriptsprachen, und es wäre für sie einfach, kleine Schnittstellen zu entwickeln, um mit diesen Skripten umzugehen, um die automatisierten Prozesse mit dem Ziel zu implementieren, ihre Aufgaben zu verbessern. Denken Sie jedoch daran, dass Jenkins höchstwahrscheinlich bereits über eine Reihe von Funktionen verfügt, und diese Funktionen können Entwicklern, die sich dafür entscheiden, sie zu verwenden, das Leben erleichtern.

Um die Ausführung des Skripts zu definieren, muss daher ein neuer Job erstellt werden, indem die Option „Neues Element“ ausgewählt wird.

Wählen Sie dann nach der Benennung den Typ „FreeStyle-Projekte“ und klicken Sie auf OK.

Um die Erstellung dieses neuen Jobs abzuschließen, muss im Abschnitt „Build“ die Option „Execute script“ ausgewählt werden und im Befehlszeilenfeld der Pfad und die Parametrisierung des auszuführenden Skripts:

Für diese Art von Job ist es ratsam, die Skriptberechtigungen zu überprüfen, da mindestens die Ausführung für die Gruppe, zu der die Datei gehört, und für alle festgelegt werden muss.

In diesem Beispiel das Skript query.sh hat Lese- und Ausführungsberechtigungen für alle, Lese- und Ausführungsberechtigungen für die Gruppe und Lese-, Schreib- und Ausführungsberechtigungen für den Benutzer:

[email protected]:~/db/scripts$ ls -l query.sh
-rwxr-xr-x 1 slonik slonik 365 May 11 20:01 query.sh
[email protected]:~/db/scripts$ 

Dieses Skript hat einen sehr einfachen Satz von Anweisungen, im Grunde nur Aufrufe des Dienstprogramms psql, um Abfragen auszuführen:

#!/bin/bash

/usr/lib/postgresql/10/bin/psql -U report -d db_deploy -c "select * from appl" > /home/slonik/db/scripts/appl.dat
 
/usr/lib/postgresql/10/bin/psql -U report -d db_deploy -c "select * from appl_users" > /home/slonik/db/scripts/appl_user.dat
 
/usr/lib/postgresql/10/bin/psql -U report -d db_deploy -c "select * from appl_rights" > /home/slonik/db/scripts/appl_rights.dat

Ausführen eines PostgreSQL-Prozesses, der aus drei oder mehr Skripten besteht

In diesem Beispiel beschreibe ich, was Sie brauchen, um drei verschiedene Skripte auszuführen, um sensible Daten zu verbergen, und dafür werden wir die folgenden Schritte befolgen ...

• Daten aus Dateien importieren
• Zu maskierende Daten vorbereiten
• Backup der Datenbank mit maskierten Daten

Um diesen neuen Job zu definieren, muss also auf der Jenkins-Hauptseite die Option „New Item“ ausgewählt werden und nach der Namensvergabe muss die Option „Pipeline“ ausgewählt werden:

Sobald der Job im Abschnitt „Pipeline“ gespeichert ist, muss auf der Registerkarte „Erweiterte Projektoptionen“ das Feld „Definition“ auf „Pipeline-Skript“ gesetzt werden, wie unten gezeigt:

Wie ich am Anfang des Kapitels erwähnt habe, besteht das verwendete Groovy-Skript aus drei Stufen, dh drei verschiedenen Teilen (Stufen), wie im folgenden Skript dargestellt:

def dir_live1='/data/ftp/server1'
def dir_live2='/data/ftp/server2'

pipeline{
    agent any
    stages
    {
      stage('Import data from files'){
          steps{
              echo "Import data from ${dir_live1} ..."
              sh script :"/home/slonik/db/scripts/import_data_from_files.sh ${dir_live1}"
              echo "Import data from $dir_live2 ..."
              sh script :"/home/slonik/db/scripts/import_data_from_files.sh ${dir_live2}"
          }
      }
      stage('Prepare data to be masked'){
          steps{
              echo "Purge data ..."
              sh script :"/home/slonik/db/scripts/purge_data.sh"
              echo "Mask data ..."
              sh script :"/home/slonik/db/scripts/mask_data.sh"
          }
      }
     stage('Backup of database with data masked'){
          steps{
              echo "Backup database after masking ..."
              sh script :"/home/slonik/db/scripts/backup_db.sh"
          }
      } 
        
    }
}

Groovy ist eine Java-syntaxkompatible objektorientierte Programmiersprache für die Java-Plattform. Es ist sowohl eine statische als auch eine dynamische Sprache mit ähnlichen Funktionen wie Python, Ruby, Perl und Smalltalk.

Es ist leicht zu verstehen, da diese Art von Skript auf einigen wenigen Anweisungen basiert …

Bühne

Bezeichnet die 3 Prozesse, die ausgeführt werden:„Daten aus Dateien importieren“, „Zu maskierende Daten vorbereiten“

und „Backup der Datenbank mit maskierten Daten“.

Schritt

Ein „Schritt“ (häufig als „Build-Schritt“ bezeichnet) ist eine einzelne Aufgabe, die Teil einer Sequenz ist. Jede Stufe könnte aus mehreren Schritten bestehen. In diesem Beispiel hat die erste Stufe zwei Schritte.

sh script :"/home/slonik/db/scripts/import_data_from_files.sh '/data/ftp/server1'

sh script :"/home/slonik/db/scripts/import_data_from_files.sh '/data/ftp/server2'

Die Daten werden aus zwei unterschiedlichen Quellen importiert.

Im vorherigen Beispiel ist es wichtig zu beachten, dass am Anfang zwei Variablen mit globalem Geltungsbereich definiert sind:

dir_live1
dir_live2

Die in diesen drei Schritten verwendeten Skripte rufen psql auf , pg_restore und pg_dump Dienstprogramme.

Sobald der Job definiert ist, ist es an der Zeit, ihn auszuführen, und dafür muss nur die Option „Jetzt erstellen“ angeklickt werden:

Nachdem der Build gestartet wurde, ist es möglich, seinen Fortschritt zu überprüfen.

Das Plug-in „Pipeline-Stage-Ansicht“ enthält eine erweiterte Visualisierung des Pipeline-Build-Verlaufs auf der Indexseite eines Flow-Projekts unter „Stage-Ansicht“. Diese Ansicht wird erstellt, sobald die Aufgaben abgeschlossen sind, und jede Aufgabe wird durch eine Spalte von links nach rechts dargestellt, und es ist möglich, die verstrichene Zeit für die verschiedenen Ausführungen anzuzeigen und zu vergleichen (bekannt als Build in Jenkins).

Sobald die Ausführung (auch Build genannt) abgeschlossen ist, können Sie zusätzliche Details abrufen, indem Sie auf den fertigen Thread (rotes Kästchen) klicken.

und dann in der Option „Konsolenausgabe“.

Die vorherigen Ansichten sind äußerst nützlich, da sie eine Wahrnehmung der für jede Stufe erforderlichen Laufzeit ermöglichen.

Pipelines, auch bekannt als Workflow, ist ein Plug-in, das die Definition des Anwendungslebenszyklus ermöglicht, und es ist eine Funktion, die in Jenkins für Continuous Delivery (CD) verwendet wird. Dieses Plug-in wurde mit den Anforderungen für eine flexible, erweiterbare und skriptbasierte CD-Workflow-Funktion entwickelt im Hinterkopf.

Dieses Beispiel dient dazu, vertrauliche Daten zu verbergen, aber es gibt sicherlich viele andere Beispiele für PostgreSQL-Datenbankadministratoren, die täglich in einem Pipeline-Job ausgeführt werden können.

Pipeline ist seit Version 2.0 auf Jenkins verfügbar und es ist eine unglaubliche Lösung!

Kontinuierliche Integration (CI) für PL/pgSQL-Entwicklungen

Die kontinuierliche Integration für die Datenbankentwicklung ist aufgrund der möglichen Datenverluste nicht so einfach wie in anderen Programmiersprachen, sodass es nicht einfach ist, die Datenbank in der Quellcodeverwaltung zu halten und sie auf einem dedizierten Server bereitzustellen, insbesondere wenn Skripte vorhanden sind die DDL- (Data Definition Language) und DML- (Data Manipulation Language) Anweisungen enthalten. Dies liegt daran, dass diese Art von Anweisungen den aktuellen Zustand der Datenbank ändern und im Gegensatz zu anderen Programmiersprachen kein Quellcode kompiliert werden muss.

Andererseits gibt es eine Reihe von Datenbankanweisungen, für die eine kontinuierliche Integration wie für andere Programmiersprachen möglich ist.

Dieses Beispiel basiert nur auf der Entwicklung von Prozeduren und veranschaulicht das Auslösen einer Reihe von Tests (geschrieben in Python) durch Jenkins, sobald PostgreSQL-Skripte, auf denen der Code der folgenden Funktionen gespeichert ist, in einem Code-Repository festgeschrieben werden.

Diese Funktionen sind einfach und ihr Inhalt hat nur wenig Logik oder eine Abfrage in PLpg/SQL oder plperlu Sprache als Funktion f_IsValidEmail :

CREATE OR REPLACE FUNCTION f_IsValidEmail(email text) RETURNS bool
LANGUAGE plperlu
AS $$
use Email::Address;
my @addresses = Email::Address->parse($_[0]);
return scalar(@addresses) > 0 ? 1 : 0;
$$;

Alle hier vorgestellten Funktionen sind nicht voneinander abhängig und somit gibt es weder in ihrer Entwicklung noch in ihrem Einsatz Vorrang. Da dies im Voraus überprüft wird, besteht keine Abhängigkeit von deren Validierungen.

Um also einen Satz von Validierungsskripten auszuführen, sobald ein Commit in einem Code-Repository ausgeführt wird, muss ein Build-Job (neues Element) in Jenkins erstellt werden:

Dieser neue Build-Job sollte als „Freestyle“-Projekt erstellt werden und im Abschnitt „Quellcode-Repository“ müssen die Repository-URL und ihre Anmeldeinformationen (oranges Kästchen) definiert werden:

Im Abschnitt „Build Triggers“ muss die Option „GitHub Hook Trigger for GITScm polling“ aktiviert werden:

Schließlich muss im Abschnitt „Build“ die Option „Execute Shell“ ausgewählt werden und im Befehlsfeld die Skripte, die die Validierung der entwickelten Funktionen durchführen:

Der Zweck ist, ein Validierungsskript für jede entwickelte Funktion zu haben.

Dieses Python-Skript hat einen einfachen Satz von Anweisungen, die diese Prozeduren aus einer Datenbank mit einigen vordefinierten erwarteten Ergebnissen aufrufen:

#!/usr/bin/python
import psycopg2

con = psycopg2.connect(database="db_deploy", user="postgres", password="postgres10", host="localhost", port="5432")
cur = con.cursor() 

email_list = { '[email protected]' : True,
                       'tintinmail.com'   :  False,
                       '[email protected]'   : False,
                       'director#mail.com': False,
                       '[email protected]'   : True
                     }
result_msg= "f_IsValidEmail -> OK"

for key in email_list:
  cur.callproc('f_IsValidEmail', (key,))
  row = cur.fetchone()
  if email_list[key]!=row[0]:
    result_msg= "f_IsValidEmail -> Nok"

print result_msg

cur.close()
con.close()

Dieses Skript testet das vorgestellte PLpg/SQL oder plperlu Funktionen und wird nach jedem Commit im Code-Repository ausgeführt, um Rückschritte auf die Entwicklungen zu vermeiden.

Sobald dieser Jobaufbau ausgeführt wurde, konnten die Protokollausführungen verifiziert werden.

Diese Option zeigt den endgültigen Status:ERFOLG oder FEHLSCHLAG, den Arbeitsbereich, die ausgeführten Dateien/Skripts, die erstellten temporären Dateien und die Fehlermeldungen (für die Fehler)!

Schlussfolgerung

Zusammenfassend ist Jenkins als großartiges Tool für Continuous Integration (CI) und Continuous Delivery (CD) bekannt, es kann jedoch für verschiedene Funktionalitäten wie verwendet werden

• Aufgaben planen
• Ausführung von Skripten
• Überwachungsprozesse

Für all diese Zwecke können bei jeder Ausführung (Bauen Sie auf dem Jenkins-Vokabular auf) die Protokolle und die verstrichene Zeit analysiert werden.

Aufgrund einer großen Anzahl verfügbarer Plugins könnte es einige Entwicklungen mit einem bestimmten Ziel vermeiden, wahrscheinlich gibt es ein Plugin, das genau das tut, wonach Sie suchen, es ist nur eine Frage der Suche im Update-Center oder Manage Jenkins>>Manage Plugins inside die Webanwendung.