Kapitel 4. Erste Schritte in der Cloud
Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com
In den beiden vorangegangenen Kapiteln haben wir dir die Grundlagen der Genomik und der Computertechnologie näher gebracht. Damit wollten wir sicherstellen, dass du in beiden Bereichen über ein ausreichendes Grundwissen verfügst, unabhängig davon, ob du eher von der einen oder der anderen Seite kommst - oder vielleicht sogar aus einem ganz anderen Bereich; in diesem Fall: Willkommen! Und bleib dran.
Uns ist klar, dass sich die ersten beiden Kapitel sehr passiv angefühlt haben, da es keine praktischen Übungen gab. Jetzt kommt die gute Nachricht: Du wirst endlich selbst Hand anlegen können. In diesem Kapitel geht es darum, dich mit den GCP-Diensten vertraut zu machen, die wir in diesem Buch verwenden. Zuerst zeigen wir dir, wie du ein GCP-Konto erstellst und einfache Befehle in der Google Cloud Shell ausführst. Danach zeigen wir dir, wie du deine eigene VM in der Cloud einrichtest, Docker zum Laufen bringst und die Umgebung einrichtest, die du in Kapitel 5 zur Durchführung von GATK-Analysen verwenden wirst. Zum Schluss zeigen wir dir, wie du IGV für den Zugriff auf Daten in Google Cloud Storage konfigurierst. Wenn du das alles eingerichtet hast, kannst du mit der eigentlichen Genomik beginnen.
Einrichten deines Google Cloud-Kontos und deines ersten Projekts
Du kannst dich für ein Konto bei GCP anmelden, indem du zu https://cloud.google.com navigierst und den Eingabeaufforderungen folgst. Wir gehen hier absichtlich nicht so sehr ins Detail, weil sich die Schnittstelle für die Kontoeinrichtung immer wieder ändert. Im Großen und Ganzen geht es darum, ein neues Google Cloud-Konto einzurichten, ein Abrechnungskonto einzurichten, das kostenlose Testguthaben zu akzeptieren (wenn du dazu berechtigt bist) und ein neues Projekt zu erstellen, das mit deinem Abrechnungskonto verknüpft ist.
Wenn du noch keine Google-Identität hast, kannst du eine mit deinem normalen E-Mail-Konto erstellen; du musst kein Gmail-Konto verwenden. Wenn deine Einrichtung G Suite nutzt, kann es sein, dass deine Arbeits-E-Mail bereits mit einer Google-Identität verknüpft ist, auch wenn der Domainname nicht gmail.com lautet.
Nachdem du dich angemeldet hast, rufst du die GCP-Konsole auf, die eine webbasierte grafische Oberfläche zur Verwaltung von Cloud-Ressourcen bietet. Auf die meisten Funktionen der Konsole kannst du auch über eine reine Befehlszeilenschnittstelle zugreifen. Im Laufe des Buches zeigen wir dir, wie du einige Dinge über die Weboberfläche und andere über die Befehlszeile erledigst, je nachdem, was unserer Meinung nach am bequemsten und/oder typisch ist.
Ein Projekt erstellen
Beginnen wir mit der Erstellung deines ersten Projekts, das du brauchst, um deine Arbeit zu organisieren, die Abrechnung einzurichten und Zugang zu den GCP-Diensten zu erhalten. Gehe in der Konsole auf die Seite "Ressourcen verwalten" und wähle dann oben auf der Seite Projekt erstellen. Wie in Abbildung 4-1 dargestellt, musst du deinem Projekt einen Namen geben, der im gesamten GCP eindeutig sein muss. Du kannst auch eine Organisation auswählen, wenn deine Google-Identität mit einer solchen verknüpft ist (was normalerweise der Fall ist, wenn du ein institutionelles/arbeitsbezogenes G Suite-Konto hast), aber wenn du dein Konto gerade erst erstellt hast, ist das im Moment vielleicht noch nicht der Fall. Wenn du eine Organisation ausgewählt hast, werden neue Projekte standardmäßig mit dieser Organisation verknüpft, was eine zentrale Verwaltung der Projekte ermöglicht. In dieser Anleitung gehen wir davon aus, dass du dein Konto zum ersten Mal einrichtest und noch keine Organisation mit ihm verknüpft ist.
Abbildung 4-1. Erstellen eines neuen Projekts.
Überprüfe dein Abrechnungskonto und aktiviere kostenlose Credits
Wenn du dich wie im vorigen Abschnitt beschrieben angemeldet und deine kostenlose Testversion aktiviert hast, hat das System im Rahmen der Kontoerstellung bereits Rechnungsdaten für dich hinterlegt. Du kannst deine Rechnungsdaten unter im Abschnitt Rechnungsstellung der Konsole überprüfen, den du auch jederzeit über das Menü in der Seitenleiste aufrufen kannst.
Wenn du für das Programm für kostenlose Gutschriften in Frage kommst, zeigt eines der Felder auf der Übersichtsseite für die Abrechnung die Anzahl der Gutschriften und die Tage an, die du noch ausgeben kannst. Wenn auf deiner Seite eine blaue Schaltfläche "Upgrade" angezeigt wird, wie in Abbildung 4-2 dargestellt, hat deine Testphase noch nicht begonnen und du musst sie aktivieren, um die Vorteile des Programms zu nutzen. Es kann auch sein, dass du oben in deinem Browserfenster ein Banner mit der Aufschrift "Kostenloser Teststatus" und einer blauen Schaltfläche "Aktivieren" siehst. Jemand bei GCP arbeitet hart daran, dich nicht umsonst gehen zu lassen, also klicke auf eine dieser Schaltflächen, um den Prozess zu starten und deine kostenlosen Credits zu erhalten.
Abbildung 4-2. Das Panel in der Abrechnungskonsole, das die Verfügbarkeit von kostenlosen Testguthaben zusammenfasst.
Auf der Übersichtsseite für die Abrechnung findest du Zusammenfassungen darüber, wie viel Geld (oder Guthaben) du bisher ausgegeben hast, sowie einige grundlegende Prognosen. Dabei ist es wichtig zu verstehen, dass das System dir die Kosten nicht in Echtzeit anzeigt: Es gibt eine gewisse Verzögerung zwischen dem Zeitpunkt, an dem du kostenpflichtige Ressourcen nutzt, und der Aktualisierung der Kosten auf deiner Abrechnungsseite.
Viele Menschen, die in die Cloud wechseln, berichten, dass es einer der schwierigsten Teile des Prozesses ist, den Überblick über ihre Ausgaben zu behalten. Es ist auch der Teil, der sie am meisten beunruhigt, weil es sehr leicht sein kann, in der Cloud schnell große Summen auszugeben, wenn man nicht aufpasst. Eine Funktion von GCP, die wir in dieser Hinsicht besonders nützlich finden, ist die Einstellung "Budgets & Alerts", wie in Abbildung 4-3 dargestellt. Hier kannst du E-Mail-Benachrichtigungen einstellen, die dich (oder die Person, die in deinem Konto für die Rechnungsstellung zuständig ist) benachrichtigen, wenn du bestimmte Ausgabengrenzen überschreitest. Das bedeutet zwar nicht, dass du keine neue Arbeit beginnen kannst, die den Schwellenwert überschreiten würde, aber du weißt dann zumindest, wo du stehst.
Abbildung 4-3. Verwaltung von Budget und Alarmschwellen.
Um auf die Funktion für Rechnungsbenachrichtigungen zuzugreifen, wähle im Hauptmenü der GCP-Konsole, wähle Rechnungsstellung, wähle das soeben erstellte Rechnungskonto und suche dann nach der Option Budgets und Benachrichtigungen. Nachdem du sie ausgewählt hast, kannst du mit dem Formular Budget erstellen (siehe Abbildung 4-3) ein neues Budget einrichten. Du kannst mehrere Budgets erstellen und mehrere Auslöser für verschiedene Prozentsätze des Budgets festlegen, wenn du Warnungen haben möchtest, wenn du dich deinem Budgetbetrag näherst. Aber wie bereits erwähnt, handelt es sich dabei nur um einen Benachrichtigungsdienst, der dich nicht vor zusätzlichen Kosten schützt.
Ausführen grundlegender Befehle in der Google Cloud Shell
Nachdem du dein Konto erstellt, die Abrechnung eingerichtet und dein Projekt angelegt hast, musst du dich im nächsten Schritt bei deiner ersten VM anmelden. Für unsere Übungen hier verwenden wir die Google Cloud Shell, die keine Konfiguration erfordert und völlig kostenlos ist, obwohl sie einige wichtige Einschränkungen hat, auf die wir gleich eingehen werden.
Anmeldung bei der Cloud Shell VM
Um eine sichere Verbindung zu einer Cloud Shell VM über das SSH-Protokoll herzustellen, klickst du in der oberen rechten Ecke der Konsole auf das Terminal-Symbol:
Dadurch wird ein neues Panel unten auf der Konsole gestartet; wenn du willst, kannst du das Terminal auch in einem eigenen Fenster ausklappen. Damit erhältst du Shell-Zugriff auf deine eigene Debian-basierte Linux-VM, die mit bescheidenen Ressourcen ausgestattet ist, darunter 5 GB freie Speicherung (gemountet unter $HOME) auf einer persistenten Festplatte. Einige grundlegende Pakete sind bereits vorinstalliert und einsatzbereit, darunter das Google Cloud SDK (auch bekannt als gcloud), das eine Reihe von kommandozeilenbasierten Tools für die Interaktion mit GCP-Diensten bietet. Wir werden es in ein paar Minuten benutzen, um einige grundlegende Datenverwaltungsbefehle auszuprobieren. In der Zwischenzeit kannst du dich auf dieser Debian-VM umsehen und schauen, welche Tools installiert sind.
Hinweis
Beachte, dass wöchentliche Nutzungsquoten die Zeit begrenzen, die du mit der Cloud Shell verbringen kannst; derzeit sind es 50 Stunden pro Woche. Außerdem kann es passieren, dass der Inhalt des Datenträgers, der dir die kostenlose Speicherung ermöglicht, gelöscht wird, wenn du ihn nicht regelmäßig nutzt (innerhalb von 120 Tagen, Stand jetzt).
Wenn du dich zum ersten Mal in der Cloud Shell anmeldest, wirst du aufgefordert, eine Projekt-ID mit Hilfe des oben erwähnten Dienstprogramms gcloud anzugeben:
Welcome to Cloud Shell! Type "help" to get started. To set your Cloud Platform project in this session use “gcloud config set project [PROJECT_ID]”
Du kannst deine Projekt-ID auf der Startseite der Konsole finden, wie in Abbildung 4-4 dargestellt.
Abbildung 4-4. Position der Projekt-ID in der GCP-Konsole.
Wenn du deine Projekt-ID hast, führe den folgenden Befehl in der Cloud Shell aus und ersetze die hier angegebene durch deine eigene Projekt-ID:
genomics_book@cloudshell:~$ gcloud config set project ferrous-layout-260200 Updated property [core/project]. genomics_book@cloudshell:~ (ferrous-layout-260200)$
Beachte, dass deine Eingabeaufforderung jetzt deine Projekt-ID enthält. Sie ist ziemlich lang, deshalb werden wir auf nur das letzte Zeichen in der Eingabeaufforderung - in diesem Fall das Dollarzeichen ($) - anzeigen, wenn wir die Ausführung von Befehlen demonstrieren. Wenn wir zum Beispiel den Inhalt des Arbeitsverzeichnisses mit dem Befehl ls auflisten, sieht es so aus:
$ ls README-cloudshell.txt
Und, hey, es gibt hier schon etwas: eine README-Datei, die, wie der Name schon sagt, wirklich will, dass du sie liest. Das kannst du tun, indem du den Befehl cat ausführst:
$ cat README-cloudshell.txt
Daraufhin wird eine Willkommensnachricht angezeigt, in der einige Nutzungshinweise und Empfehlungen für die Inanspruchnahme von Hilfe zusammengefasst sind. Damit bist du bereit, die Cloud Shell zu nutzen, um mit den grundlegenden GCP-Diensten zu interagieren. Legen wir los!
gsutil für den Zugriff und die Verwaltung von Dateien verwenden
Da wir nun Zugang zu dieser extrem einfach zu startenden und kostenlosen (wenn auch recht begrenzten) VM haben, wollen wir sie unter nutzen, um zu sehen, ob wir auf das Beispiel-Datenpaket zugreifen können, das diesem Buch beiliegt. Das Datenpaket befindet sich in Google Cloud Storage (GCS), einer Art Objektspeicher (d. h. er wird zum Speichern von Dateien verwendet) mit Speichereinheiten, die Buckets genannt werden. Du kannst den Inhalt der GCS-Buckets über den Speicher-Browser der GCP-Konsole einsehen und grundlegende Verwaltungsaufgaben durchführen, aber die Schnittstelle ist recht begrenzt. Der leistungsfähigere Ansatz ist die Verwendung des Tools gcloud, gsutil (Google Storage Utilities) über die Befehlszeile zu verwenden. Du kannst über den GCS-Pfad auf die Buckets zugreifen, d.h. über ihren Namen mit dem Präfix gs://.
Der Pfad für den Bucket der öffentlichen Speicherung für dieses Buch lautet beispielsweise gs://genomics-in-the-cloud. Du kannst den Inhalt des Buckets auflisten, indem du den folgenden Befehl in deiner Cloud-Shell eingibst:
$ gsutil ls gs://genomics-in-the-cloud gs://genomics-in-the-cloud/hello.txt gs://genomics-in-the-cloud/v1/
Es sollte eine Datei namens hello.txt geben. Verwenden wir die gsutil Version des Unix-Befehls cat, mit dem wir den Inhalt von Textdateien lesen können, um zu sehen, was die Datei hello.txt enthält:
$ gsutil cat gs://genomics-in-the-cloud/hello.txt HELLO, DEAR READER!
Du kannst auch versuchen, die Datei auf deine Speicherung zu kopieren:
$ gsutil cp gs://genomics-in-the-cloud/hello.txt . Copying gs://genomics-in-the-cloud/hello.txt... / [1 files][ 20.0 B/ 20.0 B] Operation completed over 1 objects/20.0 B.
Wenn du den Inhalt deines Arbeitsverzeichnisses auflistest, indem du wieder ls verwendest, solltest du jetzt eine lokale Kopie der Datei hello.txt haben:
$ ls hello.txt README-cloudshell.txt
Während wir mit gsutil spielen, können wir mit etwas tun, das später nützlich sein wird: Erstelle einen eigenen Speicherbereich, damit du Ausgaben in GCS speichern kannst. Du musst my-bucket in dem hier gezeigten Befehl ersetzen, weil die Bucket-Namen im gesamten GCS eindeutig sein müssen:
$ gsutil mb gs://my-bucket
Wenn du den Bucket-Namen nicht geändert hast oder einen Namen ausprobiert hast, der bereits von jemand anderem verwendet wurde, kann es sein, dass du folgende Fehlermeldung erhältst:
Creating gs://my-bucket/... ServiceException: 409 Bucket my-bucket already exists.
Wenn das der Fall ist, probiere einfach etwas anderes aus, das mit größerer Wahrscheinlichkeit einzigartig ist. Du wirst wissen, dass es funktioniert hat, wenn du die Creating name... in der Ausgabe siehst und zur Eingabeaufforderung zurückkommst, ohne dass sich gsutil weiter beschwert. Wenn das erledigt ist, erstellst du eine Umgebungsvariable, die als Alias für deinen Bucket-Namen dient. Auf diese Weise sparst du dir die Tipparbeit und kannst nachfolgende Befehle kopieren und einfügen, ohne jedes Mal den Bucket-Namen ersetzen zu müssen:
$ export BUCKET="gs://my-bucket"
Du kannst den Befehl echo für deine neue Variable ausführen, um zu überprüfen, ob dein Bucket-Name richtig gespeichert wurde:
$ echo $BUCKET gs://my-bucket
Jetzt machen wir dich mit der Verwendung von gsutil vertraut. Zuerst kopierst du die Datei hello.txt in deinen neuen Bucket. Du kannst beides direkt vom ursprünglichen Bucket aus tun:
$ gsutil cp gs://genomics-in-the-cloud/hello.txt $BUCKET/
Oder du kannst es von deiner lokalen Kopie aus tun, zum Beispiel wenn du Änderungen vorgenommen hast, die du speichern möchtest:
$ gsutil cp hello.txt $BUCKET/
Als weiteres Beispiel für die grundlegende Dateiverwaltung kannst du entscheiden, dass die Datei in einem eigenen Verzeichnis in deinem Bucket gespeichert werden soll:
$ gsutil cp $BUCKET/hello.txt $BUCKET/my-directory/
Wie du sehen kannst, sind die gsutil Befehle so eingerichtet, dass sie ihren ursprünglichen Unix-Pendants so ähnlich wie möglich sind. So kannst du zum Beispiel auch -r verwenden, um die Befehle cp und mv rekursiv auf Verzeichnisse anzuwenden. Für große Dateiübertragungen kannst du einige Cloud-spezifische Optimierungen verwenden, um den Prozess zu beschleunigen, wie z. B. die Option gsutil -m, die Dateiübertragungen parallelisiert. Praktischerweise informiert dich das System in der Regel in der Terminalausgabe, wenn du solche Optimierungen nutzen kannst, sodass du nicht erst die Dokumentation auswendig lernen musst, bevor du loslegst.
Abbildung 4-5. Browser der GCP-Konsole zur Speicherung.
Dies öffnet ein relativ einfaches Konfigurationsformular. Das Wichtigste ist, dass du einen guten Namen auswählst, denn der Name, den du wählst, muss in der gesamten Google Cloud eindeutig sein - sei also kreativ! Wenn du einen Namen wählst, der bereits verwendet wird, weist dich das System darauf hin, wenn du im Konfigurationsformular auf Weiter klickst, wie in Abbildung 4-6 gezeigt.
Abbildung 4-6. Benenne deinen Eimer.
Wenn du einen eindeutigen Namen hast, lässt dich das System zum nächsten Schritt übergehen, indem es die Menüoptionen erweitert. Hier kannst du den Speicherort und die Zugriffskontrollen für deinen Bucket anpassen, aber für den Moment kannst du auch einfach die Standardeinstellungen akzeptieren und auf Erstellen klicken. Damit kehrst du zur Liste der Buckets zurück, die jetzt auch deinen neu erstellten Bucket enthalten sollte. Du kannst auf den Namen des Buckets klicken, um seinen Inhalt zu sehen - aber natürlich ist er noch leer, sodass die Ansicht nicht besonders aufregend ist, wie in Abbildung 4-7 zu sehen ist.
Die Benutzeroberfläche bietet ein paar grundlegende Verwaltungsoptionen wie das Löschen von Buckets und Dateien sowie das Hochladen von Dateien und Ordnern. Du kannst sogar Dateien und Ordner von deinem lokalen Rechner per Drag & Drop in das Fenster mit den Bucket-Inhalten ziehen. Das ist zwar verblüffend einfach (probier es ruhig aus), aber du wirst es bei deiner Arbeit in der Genomik wahrscheinlich nicht sehr oft tun. In der Praxis wirst du wahrscheinlich eher das gsutil Kommandozeilenprogramm verwenden. Einer der Vorteile des Kommandozeilenpfads ist, dass du die Befehle als Skript speichern kannst, damit du sie nachweisen und bei Bedarf wiederholen kannst.
Abbildung 4-7. Anzeigen des Inhalts deines Buckets.
Ein Docker-Image abrufen und den Container hochfahren
Cloud Shell ist das Geschenk, das immer wieder macht: Die Docker-Anwendung (die wir in Kapitel 3 vorgestellt haben) ist bereits vorinstalliert, du kannst also auch damit loslegen! Wir werden einen einfachen Ubuntu-Container verwenden, um die grundlegenden Funktionen von Docker zu veranschaulichen. Es gibt zwar ein Docker-Image für GATK, das wir in den nächsten Kapiteln größtenteils verwenden werden, aber wir werden es hier nicht verwenden, weil es ziemlich groß ist und es eine Weile dauert, bis es in Gang kommt. Aufgrund der geringen CPU- und Speicherressourcen, die dieser freien VM zugewiesen sind, können wir in der freien Cloud Shell keine realistischen Analysen damit durchführen.
Hinweis
Um zu lernen, wie man Docker-Container in diesem Zusammenhang verwendet, solltest du als Erstes... nun ja, die Online-Dokumentation von Docker meiden! Ganz im Ernst. Nicht, weil sie schlecht ist, sondern weil die meisten dieser Dokumente hauptsächlich für Leute geschrieben sind, die Webanwendungen in der Cloud betreiben wollen. Wenn es das ist, was du tun willst, dann wünsche ich dir viel Glück, aber du liest das falsche Buch. Was wir hier anbieten, sind maßgeschneiderte Anleitungen, in denen du lernst, wie du Docker nutzen kannst, um Forschungssoftware in Containern zu betreiben.
Wie bereits erwähnt, verwenden wir ein sehr allgemeines Beispiel: ein Image, das das Betriebssystem Ubuntu Linux enthält. Es ist ein offizielles Image, das als Teil der Kernbibliothek in einem öffentlichen Container-Image-Repository, Docker Hub, zur Verfügung gestellt wird, sodass wir nur seinen Namen angeben müssen. Du wirst später sehen, dass den von der Community bereitgestellten Images der Benutzername oder der Name der Organisation vorangestellt wird, die den Beitrag geleistet hat. Während du dich noch in deinem Cloud Shell-Terminal befindest (es spielt keine Rolle, wo sich dein Arbeitsverzeichnis befindet), führst du den folgenden Befehl aus, um das Ubuntu-Image aus der Docker Hub-Bibliothek der offiziellen (zertifizierten) Images abzurufen:
$ docker pull ubuntu Using default tag: latest latest: Pulling from library/ubuntu 7413c47ba209: Pull complete 0fe7e7cbb2e8: Pull complete 1d425c982345: Pull complete 344da5c95cec: Pull complete Digest: sha256:d91842ef309155b85a9e5c59566719308fab816b40d376809c39cf1cf4de3c6a Status: Downloaded newer image for ubuntu:latest docker.io/library/ubuntu:latest
Der Befehl pull holt das Image ab und speichert es in deiner VM. Die Version des Container-Images wird durch die Kennzeichnung tag (die vom Ersteller des Images beliebig vergeben werden kann) und durch den Hash sha256 (der auf dem Inhalt des Images basiert) angegeben. Standardmäßig gibt uns das System die letzte verfügbare Version, da wir kein bestimmtes Tag angegeben haben; in einer späteren Übung wirst du sehen, wie du eine bestimmte Version anhand ihres Tags abfragen kannst. Beachte, dass Container-Images in der Regel aus mehreren modularen Slices bestehen, die separat abgerufen werden. Sie sind so organisiert, dass das System beim nächsten Abruf einer Version des Images alle Slices überspringt, die im Vergleich zu der bereits vorhandenen Version unverändert sind.
Starten wir nun den Container. Es gibt drei Hauptoptionen, um ihn zu starten, aber das Tückische daran ist, dass es normalerweise nur einen korrekten Weg gibt, um es so zu machen , wie es der Autor beabsichtigt hat, und es ist schwierig zu wissen, welcher das ist, wenn die Dokumentation es nicht angibt (was soooo oft der Fall ist). Verwirrt? Gehen wir die Fälle durch, um das Ganze etwas konkreter zu machen, und du wirst sehen, warum wir dir diese momentane Frustration und das Rätselraten zumuten - um dir später möglichen Ärger zu ersparen.
- Erste Option
-
$ docker run ubuntu
- Ergebnis
-
Eine kurze Pause, dann kommt deine Eingabeaufforderung zurück. Keine Ausgabe. Was ist passiert? Docker hat den Container tatsächlich hochgefahren, aber der Container war nicht so konfiguriert, dass er unter diesen Bedingungen irgendetwas tun konnte, also zuckte er zusammen und fuhr wieder herunter.
- Zweite Option
-
Führe es mit einem angehängten Befehl aus:
$ docker run ubuntu echo "Hello World!" Hello World!
- Ergebnis
-
Er antwortete wie gewünscht mit einem Echo auf
Hello World!und schloss sich dann wieder. OK, jetzt wissen wir also, dass wir dem Container Befehle übergeben können, und wenn es ein Befehl ist, der von etwas darin erkannt wird, wird er ausgeführt. Wenn alle Befehle ausgeführt wurden, wird der Container wieder geschlossen. Ein bisschen faul, aber vernünftig. - Dritte Option
-
Führe es interaktiv aus, indem du die Option
-itverwendest:$ docker run -it ubuntu /bin/bash root@d84c079d0623:/#
- Ergebnis
-
Aha! Eine neue Eingabeaufforderung (in diesem Fall Bash)! Allerdings mit einem anderen Shell-Symbol:
#statt$. Das bedeutet, dass der Container läuft und du dich in ihm befindest. Du kannst jetzt alle Befehle ausführen, die du normalerweise auf einem Ubuntu-System verwenden würdest, einschließlich der Installation neuer Pakete, wenn du möchtest. Versuche, ein paar Unix-Befehle wielsoderls -laauszuführen, um zu sehen, was der Container alles kann. Später im Buch, vor allem in Kapitel 12, gehen wir auf einige der Auswirkungen ein, einschließlich praktischer Anleitungen, wie du ein von dir angepasstes Image verpacken und weiterverteilen kannst, um deine eigene Analyse auf reproduzierbare Weise zu teilen.
Wenn du mit dem Herumstöbern fertig bist, gibst du exit in die Eingabeaufforderung ein (oder drücke Strg+D), um die Shell zu beenden. Da es sich hierbei um den Hauptprozess des Containers handelt, führt das Beenden dazu, dass der Container heruntergefahren wird und zur Cloud Shell selbst zurückkehrt. Das bedeutet, dass der Container und alle Befehle, die gerade laufen, beendet werden.
Falls du neugierig bist: Ja, es ist möglich, den Container zu verlassen, ohne ihn zu schließen; das nennt man Abkoppeln. Dazu drückst du Strg+P+Q, anstatt den Befehl exit zu verwenden. Du kannst dann jederzeit in den Container zurückkehren - vorausgesetzt, du kannst ihn identifizieren. Standardmäßig weist Docker deinem Container einen universell eindeutigen Bezeichner (UUID) und einen zufälligen, für Menschen lesbaren Namen zu (der oft etwas albern klingt). Du kannst docker ps ausführen, um die aktuell laufenden Container aufzulisten, oder docker ps -a, um die Container aufzulisten, die erstellt wurden. Es wird eine Liste von Containern angezeigt, die nach ihren Container-IDs geordnet ist und etwa so aussehen sollte:
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES c2b4f8a0c7a6 ubuntu "/bin/bash" 5 minutes ago Up 5 minutes vigorous_rosalind 9336068da866 ubuntu "echo ’Hello World!’" 8 minutes ago Exited (0) 8 minutes ago objective_curie
Wir sehen, dass zwei Einträge den letzten beiden Aufrufen von Docker entsprechen, jeder mit einer eindeutigen Kennung, der CONTAINER ID. Wir sehen, dass der Container mit der ID c2b4f8a0c7a6, der gerade läuft, vigorous_rosalind heißt und den Status Up 5 minutes hat. Du kannst erkennen, dass der andere Container, objective_curie, nicht läuft, weil sein Status Exited (0) 8 minutes ago ist. Die Namen, die wir hier sehen, wurden nach dem Zufallsprinzip vergeben (Wir schwören! Wie hoch sind die Chancen?), daher sind sie zugegebenermaßen nicht sehr aussagekräftig. Wenn du mehrere Container gleichzeitig laufen hast, kann das etwas verwirrend sein. Du brauchst also eine bessere Möglichkeit, sie zu identifizieren. Die gute Nachricht ist, dass du ihnen einen aussagekräftigen Namen geben kannst, indem du --name=meaningful_name direkt nach docker run in deinem ersten Befehl einfügst und den meaningful_name durch den Namen ersetzt, den du dem Container geben willst.
Um den Container zu betreten, rufe einfach docker attach c2b4f8a0c7a6 (und ersetze dabei deine Container-ID), drücke die Eingabetaste und du findest dich unter wieder am Steuer wieder (deine Tastatur könnte mit Return statt Enter beschriftet sein). Du kannst einen zweiten Befehlsreiter in der Cloud Shell öffnen, wenn du neben der Arbeit im Container auch Befehle außerhalb des Containers ausführen möchtest. Beachte, dass du mehrere Container gleichzeitig auf einer einzigen VM laufen lassen kannst - das ist einer der großen Vorteile des Containersystems - aber sie konkurrieren um die CPU- und Speicherressourcen der VM, die in Cloud Shell eher minimal sind. Später in diesem Kapitel zeigen wir dir, wie du VMs mit leistungsfähigeren Funktionen aufsetzen kannst.
Einhängen eines Volumes für den Zugriff auf das Dateisystem aus dem Container
Nachdem du die vorherige Übung abgeschlossen hast, bist du jetzt in der Lage, eine Instanz eines beliebigen Container-Images aus einem öffentlichen Repository abzurufen und auszuführen. Viele häufig verwendete Bioinformatik-Tools, darunter auch GATK, sind in Docker-Containern vorinstalliert. Wenn du weißt, wie du sie aus einem Docker-Container heraus nutzen kannst, musst du dich nicht mehr um das richtige Betriebssystem oder die richtige Softwareumgebung kümmern. Es gibt jedoch noch einen Trick, den wir dir zeigen müssen, damit das auch wirklich funktioniert: wie du aus dem Container heraus auf das Dateisystem deines Computers zugreifen kannst, indem du ein Volume einhängst.
Was bedeutet der letzte Teil? Wenn du dich innerhalb des Containers befindest, kannst du standardmäßig nicht auf Daten zugreifen, die sich auf dem Dateisystem außerhalb des Containers befinden. Der Container ist eine geschlossene Box. Es gibt zwar Möglichkeiten, Dinge zwischen dem Container und deinem Dateisystem hin und her zu kopieren, aber das wird sehr schnell mühsam. Wir gehen also den einfacheren Weg, indem wir ein Verzeichnis außerhalb des Containers so verknüpfen, dass es so aussieht, als wäre es innerhalb des Containers. Mit anderen Worten: Wir stechen ein Loch in die Containerwand, wie in Abbildung 4-8 gezeigt.
Abbildung 4-8. Einbinden eines Verzeichnisses von deiner Google Cloud Shell VM in einen Docker-Container: Der in diesem Kapitel verwendete Ubuntu-Container (links); der in Kapitel 5 vorgestellte GATK-Container (rechts).
Als Beispiel erstellen wir ein neues Verzeichnis namens book im Home-Verzeichnis unserer Cloud Shell VM und legen darin die Datei hello.txt von vorhin ab:
$ mkdir book $ mv hello.txt book/ $ ls book hello.txt
Diesmal führen wir den Befehl aus, um unseren Ubuntu-Container zu starten, indem wir das Argument -v verwenden (wobei v für Volume steht), mit dem wir einen Dateisystem-Speicherort und einen Einhängepunkt innerhalb des Containers angeben können:
$ docker run -v ~/book:/home/book -it ubuntu /bin/bash
Der Teil -v ~/book_data:/home/book des Befehls verknüpft den von dir angegebenen Ort mit dem Verzeichnis /home/book innerhalb des Docker-Containers. Der /home Teil des Pfades ist ein Verzeichnis, das bereits im Container existiert, während der book Teil ein beliebiger Name sein kann, den du ihm gibst. Jetzt kann auf alles, was sich im Verzeichnis book auf deinem Dateisystem befindet, aus dem Verzeichnis /home/book des Docker-Containers zugegriffen werden:
# ls home/book hello.txt
Hier verwenden wir denselben Namen für den Einhängepunkt wie für den eigentlichen Speicherort, weil es so intuitiver ist, aber du kannst auch einen anderen Namen verwenden. Wenn du deinem Einhängepunkt den Namen eines Verzeichnisses oder einer Datei gibst, das/die bereits mit diesem Pfad im Container existiert, wird der bestehende Pfad "zerquetscht", d. h. er ist nicht mehr zugänglich, solange das Volume eingehängt ist.
Es gibt noch ein paar andere Docker-Tricks, die du kennen solltest, aber für den Moment reicht das als Demonstration der Kernfunktionen von Docker, die du in Kapitel 5 verwenden wirst. Wir gehen auf die Details der anspruchsvolleren Optionen ein, sobald wir auf sie stoßen.
Einrichten deiner eigenen benutzerdefinierten VM
Nachdem du nun erfolgreich einige grundlegende Dateiverwaltungsbefehle ausgeführt und den Umgang mit Docker-Containern erlernt hast, ist es an der Zeit, zu größeren und besseren Dingen überzugehen. Die Google Cloud Shell-Umgebung eignet sich hervorragend für den schnellen Einstieg in leichte Programmier- und Ausführungsaufgaben, aber die für die Cloud Shell bereitgestellte VM ist wirklich unterdimensioniert und reicht definitiv nicht aus, wenn es darum geht, echte GATK-Analysen in Kapitel 5 durchzuführen.
In diesem Abschnitt zeigen wir dir, wie du deine eigene VM in der Cloud (manchmal auch Instanz genannt) mit Googles Compute Engine Service einrichtest, mit dem du VMs jeder Größe auswählen, konfigurieren und betreiben kannst.
Erstellen und Konfigurieren deiner VM-Instanz
Gehe zunächst zur Compute Engine oder rufe die Seite über das Seitenmenü auf der linken Seite auf, wie in Abbildung 4-9 dargestellt.
Abbildung 4-9. Das Menü Compute Engine zeigt den Menüpunkt VM-Instanzen.
Klicke auf den Link VM-Instanzen in diesem Menü, um eine Übersicht der laufenden Images zu erhalten. Wenn es sich um ein neues Konto handelt, gibt es noch keine laufenden Images. Oben findest du die Option "Instanz erstellen". Klicke darauf und lass uns durch den Prozess gehen, um eine neue VM mit genau den Ressourcen zu erstellen, die du brauchst.
Als nächstes klickst du in der oberen Menüleiste auf Instanz erstellen, wie in Abbildung 4-10 dargestellt. Daraufhin wird ein Konfigurationsformular angezeigt, wie in Abbildung 4-11 dargestellt.
Abbildung 4-10. Erstelle eine VM-Instanz.
Abbildung 4-11. Das Konfigurationsfenster der VM-Instanz.
Befolge die Schritt-für-Schritt-Anleitung in den folgenden Unterabschnitten, um die VM zu konfigurieren. Es gibt eine Vielzahl von Optionen und der Prozess kann ziemlich verwirrend sein, wenn du dich mit der Terminologie nicht auskennst. Deshalb haben wir den einfachsten Weg durch das Konfigurationsformular aufgezeigt, mit dem du alle Befehlsübungen in den ersten Kapiteln dieses Buches ausführen kannst. Achte bitte darauf, dass du genau die gleichen Einstellungen wie hier gezeigt verwendest, es sei denn, du weißt wirklich, was du tust.
Benenne deine VM
Gib deiner VM einen Namen, zum Beispiel genomics-book, wie in Abbildung 4-12 gezeigt. Dieser muss innerhalb deines Projekts eindeutig sein, aber im Gegensatz zu Bucket-Namen muss er nicht GCP-weit eindeutig sein. Manche Leute verwenden gerne ihren Benutzernamen, damit andere, die Zugriff auf das Projekt haben, sofort erkennen können, wer die Ressource erstellt hat.
Abbildung 4-12. Benenne deine VM-Instanz.
Wähle eine Region (wichtig!) und eine Zone (nicht so wichtig)
Es gibt verschiedene physische Standorte für die Cloud. Wie die meisten kommerziellen Cloud-Provider unterhält auch GCP Rechenzentren in vielen Teilen der Welt und bietet dir die Möglichkeit, den gewünschten Standort auszuwählen. Regionen sind die oberste geografische Unterscheidung mit Namen, die einigermaßen aussagekräftig sind (wie us-west2, das sich auf eine Einrichtung in Los Angeles bezieht). Jede Region ist weiter in zwei oder mehr Zonen unterteilt, die mit einzelnen Buchstaben bezeichnet werden (a, b, c, usw.), die separaten Rechenzentren mit eigener physischer Infrastruktur (Strom, Netzwerk, usw.) entsprechen, auch wenn sie in manchen Fällen dasselbe Gebäude nutzen.
Dieses System von Regionen und Zonen spielt eine wichtige Rolle bei der Begrenzung der Auswirkungen von lokalen Problemen wie Stromausfällen, und alle großen Cloud-Provider verwenden eine Version dieser Strategie. Mehr zu diesem Thema erfährst du in diesem unterhaltsamen Blogbeitrag von Kyle Galbraith, in dem er beschreibt, wie Cloud-Regionen und -Zonen (in seinem Fall bei AWS) im Falle einer Zombie-Apokalypse eine wichtige Rolle spielen könnten.
Hinweis
Die Möglichkeit, bestimmte Regionen und Zonen für deine Projekte auszuwählen, ist zunehmend hilfreich, wenn es darum geht, gesetzliche Beschränkungen für die Speicherung von Daten über menschliche Probanden einzuhalten, denn so kannst du einen konformen Standort für alle Speicher- und Rechenressourcen festlegen. Einige Teile der Welt sind jedoch noch nicht gut durch Cloud-Dienste abgedeckt oder werden von den verschiedenen Cloud-Providern unterschiedlich abgedeckt, so dass du bei der Auswahl eines Anbieters die verfügbaren Rechenzentren berücksichtigen musst.
Um eine Region für dein Projekt auszuwählen, kannst du die vollständige Liste der verfügbaren Google Cloud-Regionen und -Zonen konsultieren und eine Entscheidung aufgrund der geografischen Nähe treffen. Alternativ kannst du auch ein Online-Dienstprogramm wie http://www.gcping.com verwenden, das misst, wie nah du den einzelnen Rechenzentren in Bezug auf die Netzwerkreaktionszeit tatsächlich bist . Wenn wir diesen Test zum Beispiel von der Kleinstadt Sunderland im Westen von Massachusetts aus durchführen (Ergebnisse in Tabelle 4-1), stellen wir fest, dass es 38 Millisekunden dauert, um eine Antwort von der Region us-east4 in Nord-Virginia (698 km entfernt) zu erhalten, während die Region northamerica-northeast1 in Montreal (441 km entfernt) 41 Millisekunden benötigt. Das zeigt uns, dass die geografische Nähe nicht direkt mit der Nähe der Netzwerkregion korreliert. Ein noch auffälligeres Beispiel ist, dass wir der Region europe-west2 in London (5.353 km entfernt) mit einer Antwortzeit von 102 Millisekunden ein ganzes Stück "näher" sind als der Region us-west2 in Los Angeles (4.697 km entfernt), die eine Antwortzeit von 180 Millisekunden hat.
| Region | Standort | Entfernung (km) | Antwort (ms) |
|---|---|---|---|
| us-ost4 | Nord Virginia, US | 698 | 38 |
| nordamerika-nordost1 | Montreal | 441 | 41 |
| europa-west2 | London | 5,353 | 102 |
| us-west2 | Los Angeles | 4,697 | 180 |
Das bringt uns zurück zu unserer VM-Konfiguration. Für die Region wählen wir us-east4 (Nord-Virginia), weil sie demjenigen von uns, der am wenigsten reist (Geraldine), am nächsten liegt, und für die Zone wählen wir zufällig us-east4-a. Du musst sicherstellen, dass du deine Region auf der Grundlage der vorangegangenen Diskussion auswählst, sowohl zu deinem eigenen Vorteil (es wird schneller sein) als auch um zu vermeiden, dass das eine Rechenzentrum in Virginia in dem unwahrscheinlichen Fall, dass alle 60.000 registrierten Nutzer der GATK-Software gleichzeitig mit diesen Übungen beginnen, überlastet wird - obwohl das eine Möglichkeit ist, die gepriesene "Elastizität" der Cloud zu testen.
Wähle einen Maschinentyp
Hier kannst du die Ressourcen der VM konfigurieren, die du starten willst. Du kannst sowohl den Arbeitsspeicher als auch die CPUs steuern. Für einige Instanztypen (verfügbar unter Anpassen) kannst du sogar VMs mit Grafikprozessoren auswählen, die zur Beschleunigung bestimmter Programme verwendet werden. Der Haken an der Sache ist, dass die von dir gewählte Einstellung bestimmt, wie viel du pro Sekunde Betriebszeit der VM in Rechnung gestellt bekommst. Auf der rechten Seite siehst du, wie sich die stündlichen und monatlichen Kosten ändern, wenn du den Maschinentyp änderst. Beachte auch, dass die Kosten für die Zeit berechnet werden, in der die VM online ist, und nicht für die Zeit, in der du sie tatsächlich nutzt. Wir behandeln später Strategien zur Kostenbegrenzung, aber behalte das im Hinterkopf!
Hier wählst du n1-standard-2 aus. Das ist eine ziemlich einfache Maschine, die nicht viel kosten wird, wie in Abbildung 4-13 gezeigt.
Abbildung 4-13. Auswählen eines Maschinentyps.
Einen Container angeben? (nein)
Wir werden das nicht ausfüllen. Das ist nützlich, wenn du ein ganz bestimmtes Setup mit einem benutzerdefinierten Container-Image verwenden willst, das du vorher ausgewählt oder selbst erstellt hast. Wir hätten auch einen Container für dich vorkonfigurieren können und einen Teil der nächsten Schritte überspringen können. Aber dann hättest du nicht die Möglichkeit zu lernen, wie du diese Dinge selbst tun kannst, oder? Also lassen wir diese Option erst einmal außen vor.
Anpassen der Boot-Diskette
Wie der Maschinentyp ist auch dies eine sehr nützliche Einstellung. Hier kannst du zwei Dinge festlegen: das Betriebssystem, das du verwenden möchtest, und die Menge an Speicherplatz, die du benötigst. Ersteres ist besonders wichtig, wenn du einen bestimmten Typ und eine bestimmte Version des Betriebssystems verwenden musst. Letzteres ist natürlich wichtig, wenn du nicht willst, dass dir der Speicherplatz auf halbem Weg zu deiner Analyse ausgeht.
Standardmäßig bietet das System ein bestimmtes Linux-Betriebssystem mit nur 10 GB Festplattenspeicher an, wie in Abbildung 4-14 zu sehen ist. Wir werden ein größeres Boot brauchen.
Abbildung 4-14. Auswahl einer Boot-Diskettengröße und eines Images.
Um das Einstellungsmenü dafür aufzurufen, klicke auf Ändern. Daraufhin öffnet sich ein neuer Bildschirm mit einem Menü mit vordefinierten Optionen. Du kannst auch deine eigenen Bilder erstellen oder weitere Bilder im Google Cloud Marketplace finden.
Für unsere Zwecke bevorzugen wir Ubuntu 18.04 LTS, die aktuellste Version der Ubuntu-Langzeitversion, die wir gerade schreiben. Sie ist zwar nicht so brandaktuell wie Ubuntu 19.04, aber das LTS steht für Long-Term-Support und garantiert, dass sie fünf Jahre lang nach der Veröffentlichung auf Sicherheitslücken und Paket-Updates gewartet wird. In diesem Ubuntu-Image ist bereits eine Menge von dem installiert, was wir brauchen, darunter verschiedene Standard-Linux-Tools und die GCP-SDK-Befehlszeilen-Tools, auf die wir uns sehr stark verlassen werden.
Wähle Ubuntu im Menü Betriebssystem und dann Ubuntu 18.04 LTS im Menü Version, wie in Abbildung 4-15 gezeigt.
Abbildung 4-15. Auswählen eines Basisbildes.
Unten im Formular kannst du die Größe der Boot-Festplatte ändern, um mehr Platz zu schaffen. Wie in Abbildung 4-16 zu sehen ist, wählst du 100 GB statt der standardmäßigen 10 GB (die Daten, mit denen wir arbeiten werden, können leicht eine Menge Platz beanspruchen). Je nach Größe deines Datensatzes und deinen Bedürfnissen kannst du den Wert noch ein wenig erhöhen. Auch wenn du den Speicherplatz nach dem Start der VM nicht mehr ändern kannst, hast du die Möglichkeit, der laufenden Instanz nach dem Start Blockspeicher hinzuzufügen - sozusagen das Äquivalent zum Einstecken eines USB-Sticks. Wenn dir also der Speicherplatz ausgeht, bist du nicht völlig aufgeschmissen.
Abbildung 4-16. Einstellen der Größe der Boot-Diskette.
Nachdem du all dies getan hast, klickst du auf Auswählen; dadurch wird der Bildschirm geschlossen und du kehrst zum Formular für die Instanzerstellung zurück, wo der Abschnitt "Boot-Disk" dem Screenshot in Abbildung 4-17 entsprechen sollte.
Abbildung 4-17. Die aktualisierte Auswahl der Boot-Diskette.
Klicke am Ende des Formulars auf Erstellen. Daraufhin wird die Seite mit der Liste der Compute Engine VM-Instanzen angezeigt, darunter auch deine neu erstellte VM-Instanz. Während die Instanz erstellt und hochgefahren wird, siehst du ein sich drehendes Symbol vor ihrem Namen. Wenn sie läuft und einsatzbereit ist, erscheint ein grüner Kreis mit einem Häkchen, wie in Abbildung 4-18 zu sehen ist.
Abbildung 4-18. Anzeigen des VM-Status.
Anmeldung bei deiner VM mit SSH
Es gibt mehrere Möglichkeiten, wie du auf die VM zugreifen kannst, nachdem sie gelaufen ist, die du in der GCP-Dokumentation nachlesen kannst. Wir zeigen dir den einfachsten Weg, indem wir die Google Cloud-Konsole und das integrierte SSH-Terminal verwenden. Es ist kaum zu überbieten: Sobald du ein grünes Häkchen in der Google Cloud-Konsole siehst, kannst du einfach auf die SSH-Option klicken, um ein Dropdown-Menü zu öffnen, wie in Abbildung 4-19 dargestellt. Wähle die Option "In einem Browserfenster öffnen" und ein paar Sekunden später solltest du sehen, dass ein SSH-Terminal zu dieser VM geöffnet ist.
Abbildung 4-19. Optionen für die SSH-Verbindung mit deiner VM.
Dadurch öffnet sich ein neues Fenster mit einem Terminal, in dem du Befehle aus der VM-Instanz heraus ausführen kannst (siehe Abbildung 4-20). Es kann eine Minute dauern, bis die Verbindung hergestellt ist.
Abbildung 4-20. Terminal der VM-Instanz.
Sieh dich ruhig um und lerne deine brandneue VM kennen; du wirst in den nächsten Kapiteln viel Zeit mit ihr verbringen (aber auf eine gute Art und Weise).
Überprüfe deine Authentifizierung
Wahrscheinlich juckt es dich in den Fingern, etwas Interessantes auszuführen, aber wir wollen zunächst sicherstellen, dass deine Zugangsdaten richtig eingerichtet sind, damit du die GCP-Befehlszeilentools nutzen kannst, die auf dem von uns gewählten Image vorinstalliert sind. Führe im SSH-Terminal den folgenden Befehl aus:
$ gcloud init Welcome! This command will take you through the configuration of gcloud. Your current configuration has been set to: [default] You can skip diagnostics next time by using the following flag: gcloud init --skip-diagnostics Network diagnostic detects and fixes local network connection issues. Checking network connection...done. Reachability Check passed. Network diagnostic passed (1/1 checks passed). Choose the account you would like to use to perform operations for this configuration: [1] XXXXXXXXXXX-compute@developer.gserviceaccount.com [2] Log in with a new account Please enter your numeric choice:
Die Zeile, die mit [1] beginnt, zeigt dir, dass du bei GCP standardmäßig unter einem Dienstkonto angemeldet bist: Die Domain lautet @developer.gserviceaccount.com. Für die Ausführung von Tools innerhalb deiner VM ist das in Ordnung, aber wenn du Ressourcen verwalten möchtest, einschließlich des Kopierens von Dateien in GCS-Buckets, musst du das unter einem Konto mit den entsprechenden Rechten tun. Es ist möglich, diesem Dienstkonto alle Berechtigungen zu erteilen, die du für diese Übungen brauchst, aber das würde uns ein bisschen weiter in die Eingeweide der GCP-Kontoverwaltung führen, als uns lieb ist - wir wollen, dass du so schnell wie möglich mit der Genomik arbeitest! Stattdessen verwenden wir einfach das ursprüngliche Konto, mit dem du das Projekt zu Beginn dieses Kapitels erstellt hast, da es bereits über diese Rechte als Projektbesitzer verfügt.
Um dich mit diesem Konto anzumelden, drücke bei der Eingabeaufforderung die Taste 2. Dies löst eine Interaktion mit dem Programm aus; GCP warnt dich, dass die Verwendung deiner persönlichen Anmeldedaten auf einer VM ein Sicherheitsrisiko darstellt, denn wenn du jemand anderem Zugang zur VM gibst, kann er deine Anmeldedaten verwenden:
You are running on a Google Compute Engine virtual machine. It is recommended that you use service accounts for authentication. You can run: $ gcloud config set account `ACCOUNT` to switch accounts if necessary. Your credentials may be visible to others with access to this virtual machine. Are you sure you want to authenticate with your personal account? Do you want to continue (Y/n)?
Die Lösung: Gib den Zugang zu deiner persönlichen VM nicht frei.1
Wenn du "Y" für "Ja" eingibst, gibt dir das Programm einen Link:
Go to the following link in your browser: https://accounts.google.com/o/oauth2/auth?redirect_uri=<...> Enter verification code:
Wenn du auf den Link klickst oder ihn kopierst und in deinen Browser einfügst, wird eine Google-Anmeldeseite angezeigt. Melde dich mit demselben Konto an, das du auch für das GCP verwendet hast, um deinen Authentifizierungscode zu erhalten, und kopiere ihn dann und füge ihn in dein Terminalfenster ein. Das Dienstprogramm gcloud bestätigt deine Login-Identität und fordert dich auf, aus der Liste der Projekte, auf die du Zugriff hast, die gewünschte Projekt-ID auszuwählen. Außerdem hast du die Möglichkeit, deine bevorzugte Rechen- und Speicherzone festzulegen, die mit derjenigen übereinstimmen sollte, die du bei der Erstellung der VM festgelegt hast. Wenn du in der Liste der Projekt-IDs nicht das siehst, was du erwartest, kannst du immer die Ressourcenverwaltungsseite in der GCP-Konsole überprüfen.
Kopieren der Buchmaterialien auf dein VM
In den nächsten Kapiteln wirst du echte GATK-Befehle und -Workflows auf deiner VM ausführen, weshalb du die Beispieldaten, den Quellcode und einige Softwarepakete abrufen musst. Wir haben das meiste davon an einem einzigen Ort gebündelt: in einem Cloud Storage Bucket namens genomics-in-the-cloud. Der einzige Teil, der separat ist, ist der Quellcode, den wir auf GitHub bereitstellen.
Als Erstes kopierst du das Datenpaket aus dem Bucket auf deine VM. Dazu verwendest du gsutil, das GCP-Dienstprogramm für die Speicherung, das wir bereits in der Cloud Shell dieses Kapitels verwendet haben. Erstelle im Terminalfenster deiner VM ein neues Verzeichnis namens bookund führe dann den Befehl gsutil aus, um das Buchdatenpaket in den Speicherplatz deiner VM zu kopieren:
$ mkdir ~/book $ gsutil -m cp -r gs://genomics-in-the-cloud/v1/* ~/book/
Dabei werden etwa 10 GB an Daten in die Speicherung deiner VM kopiert, was einige Minuten dauern kann, selbst wenn du unter -m parallele Downloads aktiviert hast. Wie du später sehen wirst, ist es möglich, einige Analysebefehle direkt auf Dateien in der Cloud Speicherung auszuführen, ohne sie vorher zu kopieren, aber wir wollen die Dinge am Anfang so einfach wie möglich halten.
Unter kannst du den Quellcode aus dem öffentlichen Repository auf GitHub abrufen. Wir stellen den Code dort zur Verfügung, weil es sich um eine beliebte Plattform für die gemeinsame Nutzung von Code unter Versionskontrolle handelt und wir uns verpflichtet haben, den Code, den wir in diesem Buch verwenden, langfristig zu pflegen. Um eine Kopie auf deiner VM zu erhalten, wechsle zunächst mit cd in das neu erstellte Buchverzeichnis und benutze dann den Befehl git clone, um den Inhalt des Repositorys zu kopieren:
$ cd ~/book $ git clone https://github.com/broadinstitute/genomics-in-the-cloud.git code
Dadurch wird ein Verzeichnis(~book/code) erstellt, das den gesamten Beispielcode enthält, den wir in diesem Buch verwenden. Außerdem wird es als aktives Git-Repository eingerichtet, sodass du die neuesten Änderungen abrufen kannst, indem du den Befehl git pull im Code-Verzeichnis wie folgt ausführst:
$ cd ~/book/code $ git pull
Damit solltest du jetzt die neueste und beste Version des Buchcodes haben. Um herauszufinden, was sich seit der ursprünglichen Veröffentlichung geändert hat, sieh dir die README-Textdatei im Code-Verzeichnis an.
Installation von Docker auf deiner VM
Da du mit Docker auf deiner VM arbeiten wirst, müssen wir sicherstellen, dass du es ausführen kannst. Wenn du einfach den Befehl docker im Terminal ausführst, bekommst du eine Fehlermeldung, weil Docker nicht auf der VM vorinstalliert ist:
$ docker Command 'docker' not found, but can be installed with: snap install docker # version 18.09.9, or apt install docker.io See 'snap info docker' for additional versions.
Die Fehlermeldung weist hilfreich darauf hin, wie man das Problem mit einem vorinstallierten Paket namens snap beheben kann. Wir werden jedoch eine etwas andere Art der Installation von Docker verwenden: Wir werden ein Skript von der Docker-Website herunterladen und ausführen, das den Installationsprozess weitgehend automatisiert. Auf diese Weise weißt du, was du tun musst, wenn du Docker irgendwo installieren musst, wo es keine integrierte Paketmanager-Option gibt.
Führe den folgenden Befehl aus, um Docker auf der VM zu installieren:
$ curl -sSL https://get.docker.com/ | sh
# Executing docker install script, commit: f45d7c11389849ff46a6b4d94e0dd1ffebca
32c1 + sudo -E sh -c apt-get update -qq >/dev/null
...
Client: Docker Engine - Community
Version: 19.03.5
...
If you would like to use Docker as a non-root user, you should now consider
adding your user to the "docker" group with something like:
sudo usermod -aG docker genomics_book
Remember that you will have to log out and back in for this to take effect!
WARNING: Adding a user to the "docker" group will grant the ability to run
containers which can be used to obtain root privileges on the
docker host.
Refer to https://docs.docker.com/engine/security/security/#docker-daemon-
attack-surface for more information.
Das kann eine Weile dauern, also lass uns die Zeit nutzen, um den Befehl etwas genauer zu untersuchen. Zunächst verwenden wir ein praktisches kleines Dienstprogramm namens curl (kurz für Client-URL), um das Installationsskript von der von uns angegebenen URL der Docker-Website herunterzuladen, mit einigen Befehlsparametern (-sSL), die das Programm anweisen, allen Umleitungslinks zu folgen und die Ausgabe als Datei zu speichern. Dann verwenden wir das Pipe-Zeichen (|), um diese Ausgabedatei an einen zweiten Befehl zu übergeben, sh, der bedeutet: "Führe das Skript aus, das wir dir gerade gegeben haben." Die erste Zeile der Ausgabe verrät dir, was das Skript macht: Executing docker install script (der Kürze halber haben wir Teile der vorangegangenen Ausgabe weggelassen).
Wenn es fertig ist, fordert dich das Skript auf, den Befehl usermod auszuführen, um dir die Möglichkeit zu geben, Docker-Befehle auszuführen, ohne jedes Mal sudo zu verwenden. Der Aufruf von sudo docker kann dazu führen, dass die Ausgabedateien im Besitz von root sind, was es schwierig macht, sie später zu verwalten oder auf sie zuzugreifen, daher ist es sehr wichtig, diesen Schritt auszuführen:
$ sudo usermod -aG docker $USER
Dies führt zu keiner Ausgabe; wir werden in einer Minute testen, ob es richtig funktioniert hat. Zuerst musst du dich jedoch von deiner VM abmelden und dann wieder anmelden. Dadurch wird das System deine Unix-Gruppenmitgliedschaft neu bewerten, was notwendig ist, damit die Änderung, die du gerade vorgenommen hast, wirksam wird. Tippe einfach exit (oder drücke Strg+D) in die Eingabeaufforderung:
$ exit
Dadurch wird das Terminalfenster zu deiner VM geschlossen. Gehe zurück zur GCP-Konsole, suche deine VM in der Liste der Compute Engine-Instanzen und klicke auf SSH, um dich wieder einzuloggen. Es kommt dir wahrscheinlich so vor, als müsstest du viele Hürden überwinden, aber halte durch, denn jetzt kommen wir zum guten Teil.
Einrichten des GATK Container-Images
Wenn du wieder in deiner VM bist, teste deine Docker-Installation, indem du den GATK-Container ziehst, den wir im nächsten Kapitel verwenden:
$ docker pull us.gcr.io/broad-gatk/gatk:4.1.3.0 4.1.3.0: Pulling from us.gcr.io/broad-gatk/gatk ae79f2514705: Pull complete 5ad56d5fc149: Pull complete 170e558760e8: Pull complete 395460e233f5: Pull complete 6f01dc62e444: Pull complete b48fdadebab0: Pull complete 16fb14f5f7c9: Pull complete Digest: sha256:e37193b61536cf21a2e1bcbdb71eac3d50dcb4917f4d7362b09f8d07e7c2ae50 Status: Downloaded newer image for us.gcr.io/broad-gatk/gatk:4.1.3.0 us.gcr.io/broad-gatk/gatk:4.1.3.0
Zur Erinnerung: Das letzte Wort nach dem Containernamen ist das Versions-Tag, das du ändern kannst, um eine andere Version als die hier angegebene zu erhalten. Wenn du die Version änderst, funktionieren einige Befehle möglicherweise nicht mehr. Wir können nicht garantieren, dass alle Codebeispiele mit der Zukunft kompatibel sind, vor allem bei den neueren Tools, von denen einige noch in der Entwicklung sind. Wie bereits erwähnt, findest du aktualisierte Materialien im GitHub-Repository dieses Buches.
Das Container-Image der GATK ist ziemlich groß, daher kann der Download eine Weile dauern. Die gute Nachricht ist, dass Docker beim nächsten Mal, wenn du ein GATK-Image abrufen musst (z. B. um eine neue Version zu erhalten), nur die Komponenten abruft, die aktualisiert wurden, sodass es schneller geht.
Hinweis
In diesem Fall ziehen wir das GATK-Image aus dem Google Container Repository (GCR), weil sich das GCR im gleichen Netzwerk befindet wie die VM, auf der wir arbeiten. Das ist also schneller als das Ziehen aus Docker Hub. Wenn du jedoch auf einer anderen Plattform arbeitest, kann es schneller gehen, wenn du das Image aus dem GATK-Repository auf Docker Hub ziehst. Dazu änderst du den us.gcr.io/broad-gatk Teil des Image-Pfads in nur broadinstitute.
Erinnerst du dich an die Anweisungen, die du weiter oben in diesem Kapitel befolgt hast, um einen Container mit einem gemounteten Ordner zu erstellen? Das wirst du jetzt wieder verwenden, um das Verzeichnis book für den GATK-Container zugänglich zu machen:
$ docker run -v ~/book:/home/book -it us.gcr.io/broad-gatk/gatk:4.1.3.0 /bin/bash
Du solltest jetzt in der Lage sein, das Verzeichnis book, das du in deiner VM eingerichtet hast, im Container zu durchsuchen. Es befindet sich unter /home/book. Um zu überprüfen, ob GATK wie erwartet funktioniert, kannst du den Befehl gatk in der Kommandozeile deines laufenden Containers ausführen. Wenn alles richtig funktioniert, solltest du eine Textausgabe sehen, die die grundlegende GATK-Befehlszeilensyntax und einige Konfigurationsoptionen beschreibt:
# gatk
Usage template for all tools (uses --spark-runner LOCAL when used with a Spark tool)
gatk AnyTool toolArgs
Usage template for Spark tools (will NOT work on non-Spark tools)
gatk SparkTool toolArgs [ -- --spark-runner <LOCAL | SPARK | GCS> sparkArgs ]
Getting help
gatk --list Print the list of available tools
gatk Tool --help Print help on a particular tool
Configuration File Specification
--gatk-config-file PATH/TO/GATK/PROPERTIES/FILE
gatk forwards commands to GATK and adds some sugar for submitting spark jobs
--spark-runner <target> controls how spark tools are run
valid targets are:
LOCAL: run using the in-memory spark runner
SPARK: run using spark-submit on an existing cluster
--spark-master must be specified
--spark-submit-command may be specified to control the Spark submit command
arguments to spark-submit may optionally be specified after --
GCS: run using Google cloud dataproc
commands after the -- will be passed to dataproc
--cluster <your-cluster> must be specified after the --
spark properties and some common spark-submit parameters will be translated
to dataproc equivalents
--dry-run may be specified to output the generated command line without running it
--java-options 'OPTION1[ OPTION2=Y ... ]'' optional - pass the given string of options to
the java JVM at runtime.
Java options MUST be passed inside a single string with space-separated values
Was das alles bedeutet, besprechen wir in Kapitel 5 im Detail; für den Moment bist du damit fertig, die Umgebung einzurichten, in der du in den nächsten drei Kapiteln die GATK-Tools ausführen wirst.
Deine VM stoppen ... damit sie dich kein Geld mehr kostet
Die VM, die du gerade eingerichtet hast, wird sich im Laufe des Buches als nützlich erweisen; du wirst für viele der Übungen in den nächsten Kapiteln auf diese VM zurückgreifen. Solange sie jedoch läuft, kostet sie dich entweder Credits oder Geld. Der einfachste Weg, damit umzugehen, ist, sie zu stoppen: Schalte sie auf Pause, wenn du sie nicht aktiv benutzt.
Du kannst sie bei Bedarf neu starten; es dauert nur ein oder zwei Minuten, um sie wieder zum Laufen zu bringen, und sie behält alle Umgebungseinstellungen, die Historie der zuvor ausgeführten Aktionen und alle Daten, die du in der lokalen Speicherung hast. Beachte, dass du für diese Speicherung eine geringe Gebühr zahlen musst, auch wenn die VM nicht läuft. Unserer Meinung nach ist es das wert, weil du nach einer beliebigen Zeitspanne zu deiner VM zurückkehren und deine Arbeit dort fortsetzen kannst, wo du aufgehört hast.
Um deine VM zu stoppen, gehst du in der GCP-Konsole auf die Verwaltungsseite für VM-Instanzen , wie zuvor gezeigt. Finde deine Instanz und klicke auf das vertikale Drei-Punkte-Symbol auf der rechten Seite, um das Menü mit den Steuerelementen zu öffnen, und wähle dann Stopp, wie in Abbildung 4-21 gezeigt. Der Vorgang kann ein paar Minuten dauern, aber du kannst diese Seite getrost verlassen. Um deine Instanz später neu zu starten, befolge einfach die gleichen Schritte, klicke aber im Steuerungsmenü auf Start.
Abbildung 4-21. Anhalten, Starten oder Löschen deiner VM-Instanz.
Du kannst deine VM auch komplett löschen, aber bedenke, dass mit dem Löschen der VM auch alle lokal gespeicherten Daten gelöscht werden. Achte also darauf, dass du alles, was dir wichtig ist, zuerst in einem Speicher-Bucket speicherst.
IGV für das Lesen von Daten aus GCS-Buckets konfigurieren
Es bleibt nur noch ein kleiner Schritt, bevor du zum nächsten Kapitel übergehst: Wir werden einen Genombrowser namens Integrated Genome Viewer (IGV) installieren und konfigurieren, der direkt mit den Dateien in GCP arbeiten kann. So kannst du Sequenzdaten und Variantenaufrufe untersuchen, ohne die Dateien auf deinen lokalen Rechner kopieren zu müssen.
Wenn du das Programm noch nicht auf deinem Computer installiert hast, hol dir das IGV-Programm von der Website und befolge die Installationsanweisungen. Wenn du bereits eine Kopie hast, solltest du sie auf die neueste Version aktualisieren; wir verwenden 2.7.2 (macOS-Version). Sobald du die Anwendung geöffnet hast, wähle in der oberen Menüleiste Ansicht > Einstellungen, wie in Abbildung 4-22 dargestellt.
Abbildung 4-22. Auswählen des Menüpunkts Einstellungen.
Dies öffnet das Fenster Einstellungen, wie in Abbildung 4-23 dargestellt.
Aktiviere im Bereich Einstellungen das Kontrollkästchen "Google-Zugriff aktivieren", klicke auf Speichern, beende IGV und öffne es erneut, um eine Aktualisierung der oberen Menüleiste zu erzwingen. Du solltest jetzt einen Google-Menüpunkt sehen, der vorher nicht da war. Klicke darauf und wähle Anmelden, wie in Abbildung 4-24 gezeigt, um IGV mit deinen Google-Kontodaten einzurichten.
Abbildung 4-23. Das Fenster IGV-Voreinstellungen.
Abbildung 4-24. Auswählen des Menüpunkts Google Login.
Dies führt dich zu einer Google-Anmeldeseite in deinem Webbrowser. Folge den Eingabeaufforderungen, um IGV den Zugriff auf die entsprechenden Berechtigungen in deinem Google-Konto zu ermöglichen. Wenn dies abgeschlossen ist, solltest du eine Webseite sehen, auf der einfach OK steht. Wechseln wir nun zurück zu IGV und testen, ob es funktioniert. Klicke im Menü auf der obersten Ebene auf Dateien > Von URL laden (siehe Abbildung 4-25) und achte darauf, dass du nicht aus Versehen eine der anderen Optionen auswählst (sie sehen sich sehr ähnlich, so dass man leicht in die Irre gehen kann). Vergewissere dich auch, dass das Dropdown-Menü in der oberen linken Ecke des IGV-Fensters auf "Human hg19" eingestellt ist.
Hinweis
Wenn du verwirrt bist, was die Unterschiede zwischen den menschlichen Referenzgenomen sind, lies die Hinweise in "Das Referenzgenom als gemeinsamer Rahmen" über hg19 und GRCh38.
Abbildung 4-25. Der Menüpunkt Von URL laden.
Gib schließlich den GCS-Dateipfad für eine der BAM-Beispieldateien, die wir im Buchdatenpaket bereitstellen, in das sich öffnende Dialogfenster ein (z. B. mother.bam, wie in Abbildung 4-26 gezeigt) und klicke dann auf OK. Erinnere dich daran, dass du eine Liste der Dateien im Bucket über gsutil von deiner VM oder von der Cloud Shell aus abrufen oder den Inhalt des Buckets mit dem Browser der Google Cloud Console Speicherung durchsuchen kannst. Wenn du den Pfad zur Datei über die Browseroberfläche abrufst, musst du den GCS-Dateipfad zusammensetzen, indem du den ersten Teil der URL vor dem Bucket-Namen entfernst; entferne zum Beispiel https://console.cloud.google.com/storage/browser und ersetze ihn durch gs://. Das Gleiche gilt für die zugehörige Indexdatei der BAM, die denselben Dateinamen und Pfad haben sollte, aber auf .bai endet.2
Abbildung 4-26. Das Dialogfeld Von URL laden.
Dadurch werden dir die Daten in IGV als neue Datenspur zur Verfügung gestellt, aber standardmäßig wird nichts in den Hauptviewer geladen. Um zu überprüfen, ob du die Daten sehen kannst, gib im Suchfenster die Genomkoordinaten ein 20:9,999,830-10,000,170 ein und klicke dann auf Go. Diese Koordinaten führen dich zur 10-millionsten DNA-Base ±170 auf dem 20. menschlichen Chromosom, wie in Abbildung 4-27 zu sehen ist, wo du den linken Rand der Sequenzdaten siehst, die wir in dieser Beispieldatei bereitstellen. Wie du die visuelle Ausgabe von IGV interpretieren kannst, erklären wir ausführlich in Kapitel 5, wenn wir es verwenden, um das Ergebnis einer echten (kleinen) Analyse zu untersuchen.
Abbildung 4-27. IGV-Ansicht einer BAM-Datei, die sich in einem GCS-Eimer befindet.
IGV ruft jeweils nur kleine Datenabschnitte ab, sodass die Übertragung sehr schnell sein sollte, es sei denn, du hast eine besonders langsame Internetverbindung. Bedenke jedoch, dass GCP, wie alle kommerziellen Cloud-Provider, eine Gebühr für die Übertragung von Daten aus der Cloud verlangt. Das Gute daran ist, dass es sich dabei um eine geringe Gebühr handelt, die proportional zur übertragenen Datenmenge ist. Die Kosten für die Anzeige von Daten in IGV sind also trivial - in der Größenordnung von Bruchteilen von Pfennigen - und auf jeden Fall besser als die Kosten für die Übertragung der gesamten Datei zum Offline-Durchsuchen!
Du kannst den Inhalt anderer Datendateien, wie z.B. VCF-Dateien, mit denselben Operationen einsehen, solange die Dateien in einem GCP-Bucket gespeichert sind. Leider funktioniert das nicht für Dateien, die sich auf der lokalen Speicherung deiner VM befinden. Wenn du also eine dieser Dateien untersuchen willst, musst du sie zuerst in einen Bucket kopieren. Du wirst dich in kürzester Zeit mit gsutil vertraut machen.
Oh, noch eine letzte Sache, während du IGV geöffnet hast: Klicke auf die kleine gelbe Sprechblase in der Symbolleiste des IGV-Fensters, die das Verhalten der Detailanzeige steuert, wie in Abbildung 4-28 gezeigt. Tu dir selbst einen Gefallen und ändere die Einstellung von Show Details on Hover zu Show Details on Click. Unabhängig davon, welche Aktion du wählst, erscheint ein kleiner Dialog, der dir detaillierte Informationen über jeden Teil der Daten gibt, auf den du klickst oder über den du den Mauszeiger bewegst; zum Beispiel werden dir bei einem Sequenz-Read alle Mapping-Informationen sowie die vollständige Sequenz und die Basenqualitäten angezeigt. Du kannst es jetzt mit den Daten ausprobieren, die du gerade geladen hast. Wie du sehen wirst, ist die Detailanzeige an sich sehr praktisch, aber die "on Hover"-Version dieses Verhaltens kann etwas überwältigend sein, wenn du neu in der Benutzeroberfläche bist; deshalb empfehlen wir dir, zu "on Click" zu wechseln.
Abbildung 4-28. Ändern des Verhaltens des Detail Viewers von "bei Hover" zu "bei Klick".
Nachbereitung und nächste Schritte
In diesem Kapitel haben wir dir gezeigt, wie du mit den GCP Ressourcen beginnst, von der Erstellung eines Kontos über die Nutzung der Cloud Shell bis hin zu deiner eigenen VM. Du hast gelernt, wie du Dateien in GCS verwaltest, Docker-Container ausführst und deine VM verwaltest. Schließlich hast du die Daten und den Quellcode des Buches abgerufen, deine eigene VM für die Arbeit mit dem GATK-Container eingerichtet und IGV für die Anzeige der in Buckets gespeicherten Daten eingerichtet. In Kapitel 5 werden wir dich mit GATK selbst vertraut machen, und bevor du dich versiehst, wirst du echte Genomik-Tools auf Beispieldaten in der Cloud ausführen.
1 Wenn du Konten für andere Nutzer/innen in deinem GCP-Projekt erstellst, können diese auch per SSH auf deine VMs zugreifen. Es ist möglich, den Zugriff auf deine VMs in einem gemeinsamen Projekt weiter einzuschränken, aber das geht über die einfache Einführung hinaus, die wir hier vorstellen.
2 Zum Beispiel wird https://console.cloud.google.com/storage/browser/genomics-in-the-cloud/v1/data/germline/bams/mother.bam zu gs://genomics-in-the-cloud/v1/data/germline/bams/mother.bam.
Get Genomik in der Cloud now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
