Bei ShareThis schaffen wir uns nicht gerne zusätzliche Arbeit. Die Verwaltung von Terabytes und Petabytes an Daten in Echtzeit ist schon schwer genug. Daher suchen wir aggressiv nach Möglichkeiten, schneller und effizienter zu arbeiten. Das bedeutet, verschiedene Technologien zu evaluieren und so viel wie möglich zu automatisieren. Dazu gehört auch, dass wir Prototypen schnell erstellen und Dinge mit so wenig Code wie möglich zum Laufen bringen.

Vor kurzem wollte ich ausprobieren. Askaban um Jobabläufe schnell und einfach zu planen. Ich wollte jedoch nicht viel Zeit damit verbringen, das System während des Tests auf und ab zu bringen, und ich wollte alle Änderungen im Auge behalten, damit ich das System nach Belieben aufbauen und zerstören kann. Das klang nach einer guten Zeit, um meine Docker Hut und Gebrauch docker-compose. Es erlaubte mir auch, die Bash-Curl aufzuräumen.

Der erste Schritt war, eine Dockerdatei zu erhalten, die eine Einzelknotenanwendung einrichtet. Dies würde es mir ermöglichen, einen ersten Eindruck von der Bedienung des Systems zu bekommen:

from java:7


COPY azkaban-solo-server-2.5.0.tar.gz /azkaban-solo-server-2.5.0.tar.gz
RUN tar -xf /azkaban-solo-server-2.5.0.tar.gz
RUN apt-get update
RUN apt-get install zip
ADD flows /azkaban-solo-2.5.0/flows
ADD run.sh /
ADD jq /usr/bin/jq


CMD /azkaban-solo-2.5.0/bin/azkaban-solo-start.sh

Dann könnte Docker-Compose verwendet werden, um das Ganze zur Sprache zu bringen. Als solches habe ich eine dc-solo.yml-Datei geschrieben:

azkaban:
  build: solo/.
  ports:
        - 8081:8081

Jetzt kann ich es:

$> docker-compose -f dc-solo.yml build
$> docker-compose -f dc-solo.yml up

Askaban läuft! Ich spielte mit der Benutzeroberfläche und erkannte, dass wir, wenn das funktionieren würde, Abläufe in Github gespeichert und automatisch geladen haben müssten. Dies führte mich zum zweiten Teil des Prozesses, der darin bestand, damit zu spielen, wie man Ströme von Github nach Askaban bekommt. Um dies zu tun, fing ich an, ihre API's mit Curl zu hacken (ich würde dies nie für ein abgeschlossenes Projekt empfehlen, aber für eine schnelle Iteration, das funktioniert). Ich habe auch ein schönes Json-Tool kennengelernt: " jq".

Zuerst schreiben wir eine Funktion, die ein Session-Token in einer Variablen namens FCRED speichert:

#

getSession simply creates a session with default credentials.

#

getSession () {
  CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  während [ $? -ne 0 []
  tun
        1 Schlaf
        CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  erledigt
  FCRED=echo $CRED | jq '."session.id"' | sed s/\"//g
}

Dann lassen Sie uns ein Projekt in Askaban erstellen:

#

createProject creates a project in Azkaban

#

$1 The name of the project.

$2 The description of the project.

#

createProject () {
  RESP=curl -k -X POST --data "session.id=$FCRED&name=${1}&description=$2" $PROD/manager?action=create
}

Sie können eine Zip-Datei mit Ihrem Flow in Ihr Projekt hochladen:

uploadZip () {
  RESP=curl -k -H "Content-Type: multipart/mixed" -X POST --form "session.id=$1" --form "ajax=upload" --form "file=@$2;type=application/zip" --form "project=$3" $PROD/manager
  PROJECTID=echo $RESP | jq '.projectId' | sed s/\"//g
}

Planen Sie es sogar:

schedule () {
  RESP=curl -k "localhost:8081/schedule?ajax=scheduleFlow&session.id=$1&projectName=$2&flow=$3&projectId=$4&scheduleTime=$5&scheduleDate=$6&is_recurring=on&period=$7"
  echo "Terminplanung: $?"
  echo $RESP
  echo $RESP | jq '...'.
}

Am Ende habe ich nur noch durch den Verzeichnisbaum iteriert, die Verzeichnisse mit den Azkaban-Jobdateien gezippt und hochgeladen.

#

uploadFlow will zip up the contents of each project directory and upload the flow.

#

$1 The name of the project which corresponds to a directory.

#

uploadFlow () {
  proj=$1
  rm $proj.zip
  zip $proj.zip $proj/*
  uploadZip $FCRED $proj.zip $proj
}

#

Main Script

#

getSession
for dir in ls -d */; do
  proj=${dir%%/}
  desc="cat ${dir}description.txt"
  createProject $proj "$desc" erstellen
  uploadFlow $proj.
erledigt;

Das ist nicht das Ende. Diese azkabanischen Ströme erweisen sich als nützlich auf MVP-Basis, und ich habe begonnen, das Docker-Compose-Rezept so zu erweitern, dass wir unterstützt werden durch Amazon's RDS. Siehst du, wie ich mir die Arbeit erspare, indem ich die DB nicht implementiere? Ich liebe die Cloud!!!! Hier ist mein Multi-Node Docker-Compose: (meine funktionierende dc-full.yml für das Staging auf einer lokalen Umgebung. Für die Verwendung von RDS ersetze ich das Dockerbild durch ein echtes Netzwerkbild.)

mysql:
  image: mysql
  environment:
        - MYSQLROOTPASSWORD=root
        - MYSQLDATABASE=azkaban
        - MYSQLUSER=azkaban
        - MYSQL_PASSWORD=azkaban
  volumes:
        - /mnt/mysql/azkaban:/var/lib/mysql
executor:
  build: exec/.
  links:
        - mysql
  ports:
        - 12321
web:
  build: web/.
  links:
        - mysql
        - executor
  ports:
        - 8081:8081

Das war's für den Moment. Wir werden sehen, ob sich das auf ShareThis bewährt und dann weiter daran arbeiten. Eines Tages könnte es alle unsere automatisierten Pipelines ausführen. Wenn Sie gerne schnell iterieren und Prozesse hassen, die die Entwicklungszeit verstopfen, dann bitte schließen Sie sich uns an!