Dagelijkse PostgreSQL-taken automatiseren met Jenkins

Deze blog is een korte presentatie over Jenkins en laat je zien hoe je deze tool kunt gebruiken om te helpen bij een aantal van je dagelijkse PostgreSQL-beheer- en beheertaken.

Over Jenkins

Jenkins is een open source software voor automatisering. Het is ontwikkeld in Java en is een van de meest populaire tools voor Continuous Integration (CI) en Continuous Delivery (CD).

In 2010, na de overname van Sun Microsystems door Oracle, had "Hudson"-software een geschil met de open source-gemeenschap. Dit geschil werd de basis voor de lancering van het Jenkins-project.

Tegenwoordig zijn "Hudson" (openbare Eclipse-licentie) en "Jenkins" (MIT-licentie) twee actieve en onafhankelijke projecten met een zeer vergelijkbaar doel.

Jenkins heeft duizenden plug-ins die u kunt gebruiken om de ontwikkelingsfase te versnellen door middel van automatisering voor de gehele ontwikkelingslevenscyclus; bouwen, documenteren, testen, verpakken, faseren en implementeren.

Wat doet Jenkins?

Hoewel het belangrijkste gebruik van Jenkins Continuous Integration (CI) en Continuous Delivery (CD) zou kunnen zijn, heeft deze open source een reeks functionaliteiten en kan het worden gebruikt zonder enige verplichting of afhankelijkheid van CI of CD, dus presenteert Jenkins enkele interessante functionaliteiten aan verkennen:

• Periode banen plannen (in plaats van de traditionele crontab te gebruiken) )
• Bewaking van taken, de bijbehorende logboeken en activiteiten met een overzichtelijke weergave (omdat ze een optie voor groepering hebben)
• Onderhoud van banen zou gemakkelijk kunnen worden gedaan; ervan uitgaande dat Jenkins er een aantal opties voor heeft
• Installatie en planning van software-installatie (met behulp van Puppet) in dezelfde host of in een andere.
• Rapporten publiceren en e-mailmeldingen verzenden

PostgreSQL-taken uitvoeren in Jenkins

Er zijn drie algemene taken die een PostgreSQL-ontwikkelaar of databasebeheerder dagelijks moet uitvoeren:

1. Planning en uitvoering van PostgreSQL-scripts
2. Een PostgreSQL-proces uitvoeren dat uit drie of meer scripts bestaat
3. Continuous Integration (CI) voor PL/pgSQL-ontwikkelingen

Voor de uitvoering van deze voorbeelden wordt aangenomen dat Jenkins en PostgreSQL (tenminste versie 9.5) servers zijn geïnstalleerd en correct werken.

Planning en uitvoering van een PostgreSQL-script

In de meeste gevallen de implementatie van dagelijkse (of periodieke) PostgreSQL-scripts voor het uitvoeren van een gebruikelijke taak zoals...

• Genereren van back-ups
• Test het terugzetten van een back-up
• Uitvoering van een zoekopdracht voor rapportagedoeleinden
• Logbestanden opschonen en archiveren
• Een PL/pgSQL-procedure aanroepen om tabellen te wissen

t is gedefinieerd op crontab :

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 de crontab is niet de beste gebruiksvriendelijke tool om dit soort planning te beheren, het kan op Jenkins worden gedaan met de volgende voordelen...

• Zeer gebruiksvriendelijke interface om hun voortgang en huidige status te volgen
• De logboeken zijn onmiddellijk beschikbaar en er is geen speciale toestemming voor nodig om ze te openen
• De taak kan in plaats daarvan handmatig worden uitgevoerd op Jenkins om een ​​planning te hebben
• Voor sommige taken is het niet nodig om gebruikers en wachtwoorden in platte tekstbestanden te definiëren, aangezien Jenkins dit op een veilige manier doet
• De taken kunnen worden gedefinieerd als een API-uitvoering

Het zou dus een goede oplossing kunnen zijn om de taken met betrekking tot PostgreSQL-taken naar Jenkins te migreren in plaats van crontab.

Aan de andere kant hebben de meeste databasebeheerders en ontwikkelaars sterke vaardigheden in scripttalen en het zou voor hen gemakkelijk zijn om kleine interfaces te ontwikkelen om met deze scripts om te gaan om de geautomatiseerde processen te implementeren met als doel hun taken te verbeteren. Maar onthoud dat Jenkins waarschijnlijk al een reeks functies heeft om dit te doen en deze functionaliteiten kunnen het leven van ontwikkelaars die ervoor kiezen om ze te gebruiken gemakkelijk maken.

Om de uitvoering van het script te definiëren, is het dus nodig om een ​​nieuwe taak aan te maken door de optie "Nieuw item" te selecteren.

Kies daarna, na het een naam te hebben gegeven, het type "FreeStyle projects" en klik op OK.

Om het maken van deze nieuwe taak te voltooien, moet in de sectie "Build" de optie "Script uitvoeren" worden geselecteerd en in het opdrachtregelvak het pad en de parametrering van het script dat zal worden uitgevoerd:

Voor dit soort taken is het raadzaam om scriptmachtigingen te verifiëren, omdat de uitvoering in ieder geval voor de groep waartoe het bestand behoort en voor iedereen moet zijn ingesteld.

In dit voorbeeld is het script query.sh heeft lees- en uitvoerrechten voor iedereen, lees- en uitvoerrechten voor de groep en lees-schrijf- en uitvoerrechten voor de gebruiker:

[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$ 

Dit script heeft een zeer eenvoudige set instructies, in feite alleen oproepen naar het hulpprogramma psql om query's uit te voeren:

#!/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

Een PostgreSQL-proces uitvoeren dat bestaat uit drie of meer scripts

In dit voorbeeld zal ik beschrijven wat je nodig hebt om drie verschillende scripts uit te voeren om gevoelige gegevens te verbergen en daarvoor zullen we de onderstaande stappen volgen...

• Gegevens importeren uit bestanden
• Bereid gegevens voor om te maskeren
• Back-up van database met gemaskeerde gegevens

Om deze nieuwe taak te definiëren, moet u dus de optie "Nieuw item" selecteren op de hoofdpagina van Jenkins en vervolgens, na het toewijzen van een naam, de optie "Pijpleiding" kiezen:

Nadat de taak is opgeslagen in de sectie "Pijpleiding", op het tabblad "Geavanceerde projectopties", moet het veld "Definitie" worden ingesteld op "Pijpleidingscript", zoals hieronder weergegeven:

Zoals ik aan het begin van het hoofdstuk al zei, het gebruikte Groovy-script bestaat uit drie fasen, het betekent drie verschillende delen (fasen), zoals weergegeven in het volgende script:

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 is een Java-syntaxis-compatibele objectgeoriënteerde programmeertaal voor het Java-platform. Het is zowel een statische als dynamische taal met functies die vergelijkbaar zijn met die van Python, Ruby, Perl en Smalltalk.

Het is gemakkelijk te begrijpen omdat dit soort script is gebaseerd op een paar uitspraken...

Podium

Betekent de 3 processen die worden uitgevoerd:"Gegevens importeren uit bestanden", "Gegevens voorbereiden om te worden gemaskeerd"

en "Back-up van database met gemaskeerde gegevens".

Stap

Een "stap" (vaak een "bouwstap" genoemd) is een enkele taak die deel uitmaakt van een reeks. Elke fase kan uit meerdere stappen bestaan. In dit voorbeeld heeft de eerste fase twee stappen.

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'

De gegevens worden geïmporteerd uit twee verschillende bronnen.

In het vorige voorbeeld is het belangrijk op te merken dat er aan het begin en met een globaal bereik twee variabelen zijn gedefinieerd:

dir_live1
dir_live2

De scripts die in deze drie stappen worden gebruikt, noemen de psql , pg_restore en pg_dump hulpprogramma's.

Zodra de taak is gedefinieerd, is het tijd om deze uit te voeren en daarvoor hoeft u alleen maar op de optie "Build Now" te klikken:

Nadat de build is gestart, is het mogelijk om de voortgang te controleren.

De Pipeline Stage View-plug-in bevat een uitgebreide visualisatie van de bouwgeschiedenis van Pipeline op de indexpagina van een stroomproject onder Stage View. Deze weergave wordt gemaakt zodra de taken zijn voltooid en elke taak wordt weergegeven door een kolom van links naar rechts en het is mogelijk om de verstreken tijd voor de serval-uitvoeringen te bekijken en te vergelijken (bekend als een Build in Jenkins).

Zodra de uitvoering (ook wel een Build genoemd) is voltooid, is het mogelijk om aanvullende details te krijgen door op de voltooide thread (rood vak) te klikken.

en vervolgens in de optie "Console-uitvoer".

De vorige weergaven zijn uiterst nuttig omdat ze een idee geven van de looptijd die vereist is voor elke fase.

Pipelines, ook wel workflow genoemd, is een plug-in waarmee de levenscyclus van een applicatie kan worden gedefinieerd en het is een functionaliteit die wordt gebruikt in Jenkins voor continue levering (CD). in gedachten.

Dit voorbeeld is bedoeld om gevoelige gegevens te verbergen, maar er zijn zeker dagelijks vele andere voorbeelden van PostgreSQL-databasebeheerder die kunnen worden uitgevoerd op een pijplijntaak.

Pipeline is beschikbaar op Jenkins sinds versie 2.0 en het is een ongelooflijke oplossing!

Continue integratie (CI) voor PL/pgSQL-ontwikkelingen

De continue integratie voor de database-ontwikkeling is niet zo eenvoudig als in andere programmeertalen vanwege de gegevens die verloren kunnen gaan, dus het is niet eenvoudig om de database onder broncontrole te houden en deze op een speciale server te implementeren, vooral als er scripts zijn die DDL (Data Definition Language) en DML (Data Manipulation Language)-instructies bevatten. Dit komt omdat dit soort uitspraken de huidige staat van de database wijzigen en in tegenstelling tot andere programmeertalen is er geen broncode om te compileren.

Aan de andere kant zijn er een reeks database-statements waarvoor het mogelijk is de continue integratie zoals voor andere programmeertalen.

In dit voorbeeld is het alleen gebaseerd op de ontwikkeling van procedures en het illustreert de activering van een reeks tests (geschreven in Python) door Jenkins zodra PostgreSQL-scripts, waarop de code van de volgende functies is opgeslagen, zijn vastgelegd in een coderepository.

Deze functies zijn eenvoudig en de inhoud ervan heeft slechts een paar logica of een zoekopdracht in PLpg/SQL of plperlu taal als de functie 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 functies die hier worden gepresenteerd, zijn niet van elkaar afhankelijk, en dan is er geen prioriteit bij de ontwikkeling of de inzet ervan. Bovendien, aangezien het vooruit zal worden geverifieerd, is er geen afhankelijkheid van hun validaties.

Dus om een ​​set validatiescripts uit te voeren zodra een commit is uitgevoerd in een coderepository, moet er een build-taak (nieuw item) worden gemaakt in Jenkins:

Deze nieuwe build-taak moet worden gemaakt als een "Freestyle" -project en in de sectie "Broncoderepository" moet de repository-URL en zijn inloggegevens (oranje vak) worden gedefinieerd:

In de sectie "Build Triggers" moet de optie "GitHub hook trigger for GITScm polling" worden aangevinkt:

Ten slotte moet in de sectie "Build" de optie "Execute Shell" worden geselecteerd en in het opdrachtvenster de scripts die de ontwikkelde functies valideren:

Het doel is om één validatiescript te hebben voor elke ontwikkelde functie.

Dit Python-script heeft een eenvoudige set instructies die deze procedures aanroepen vanuit een database met een aantal vooraf gedefinieerde verwachte resultaten:

#!/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()

Dit script test de gepresenteerde PLpg/SQL of plperlu functies en het wordt uitgevoerd na elke commit in de coderepository om regressies op de ontwikkelingen te voorkomen.

Zodra deze taakopbouw is uitgevoerd, kunnen de loguitvoeringen worden geverifieerd.

Deze optie geeft de uiteindelijke status weer:SUCCESS of FAILURE, de werkruimte, de uitgevoerde bestanden/script, de aangemaakte tijdelijke bestanden en de foutmeldingen (voor de mislukte)!

Conclusie

Samengevat staat Jenkins bekend als een geweldige tool voor Continuous Integration (CI) en Continuous Delivery (CD), maar het kan voor verschillende functionaliteiten worden gebruikt, zoals,

• Taken plannen
• Uitvoering van scripts
• Bewaking van processen

Voor al deze doeleinden kan bij elke uitvoering (Build on Jenkins-vocabulaire) de logs en de verstreken tijd worden geanalyseerd.

Vanwege een groot aantal beschikbare plug-ins kunnen sommige ontwikkelingen met een specifiek doel worden vermeden, waarschijnlijk is er een plug-in die precies doet wat u zoekt, het is gewoon een kwestie van zoeken in het updatecentrum of Jenkins beheren>> Plug-ins binnen beheren de webapplicatie.