Transkripte
1. Einführung: Go ist eine unglaublich
leistungsstarke Backend-Sprache , die für das Toolkit
jedes Entwicklers von Vorteil sein kann Sie ist leistungsstark. Es hat Serialisierung und
Deserialisierung eingebaut Serialisierung und
Deserialisierung JSON, es hat
eingebaute Tests und vieles mehr. In diesem Kurs werden
wir
komplett bei Null anfangen , einen neuen Ordner
erstellen, ein
G-Projekt einrichten, den gesamten Code dafür
schreiben und Tests für das Projekt
schreiben Dockerisierung der Anwendung
und am Ende schließlich
Automatisierung einer CICD-Pipeline zum Testen
und Erstellen
eines Workflows mit CircleCI . Ich hoffe, dass Sie am Ende des
Kurses einen praktischen und praxisnahen
Überblick darüber
erhalten, wie Sie einen praktischen und praxisnahen
Überblick darüber
erhalten Docker-Go-Anwendungen, einschließlich Tests, erstellen können Docker-Go-Anwendungen Ich hoffe, Sie nehmen an
diesem Kurs Go for real world
2. Warum gehen: Bevor wir überhaupt anfangen, darüber
zu
sprechen, was unsere Anwendung machen wird oder welche Programmierung, möchte
ich kurz darauf eingehen
, warum wir G überhaupt als Sprache
wählen würden . Warum sollten wir uns also für G entscheiden? Zunächst einmal ist es
extrem leistungsstark. Zu diesem Zeitpunkt habe ich
mindestens ein Dutzend
Bewerbungen geschrieben , und noch nie musste
ich nach irgendwelchen Rennbedingungen
oder Leistungsproblemen Und eine davon war eine API
für ein ziemlich großes Startup. Wir hatten etwa 10.000 Benutzer und an einigen Stellen 1.000
bis 2000 gleichzeitige Benutzer. Und selbst dann hatten
wir nie größere Leistungsprobleme, und das Ganze lief auf einer virtuellen Maschine mit
vier Kernen. Go ist außerdem extrem kompakt. Die Anwendung wird also in der
Regel von einer einzigen
Hauptdatei mit Punkt Go ausgeführt, und das kann einfach durch Eingabe von
go run main dot go erreicht werden. Wie wir später
im Kurs sehen werden, ist
dies extrem leistungsfähig wenn wir unsere App
andocken möchten Es ist sehr einfach, eine Go-Anwendung zu transportieren
und auszuführen. Go ist auch extrem testbar. Es hat ein integriertes
Test-Framework. Also würden wir
dieses Testpaket importieren. Das geben wir an
unsere Testfunktion weiter. Und dann ist es so einfach wie das
Aufrufen der Funktion
, die wir testen möchten. Und in diesem Fall habe ich einen Fehler
von dieser Funktion
zurückgegeben. Wenn der Fehler nicht Null ist, gilt
dies für nicht
Null oder leer. Dann verwenden wir diesen Zeiger
auf das Test-Framework und geben einen Fehler aus.
Das ist also eingebaut. Wir benötigen keine
externe Konfiguration. Wir benötigen keine
externen Bibliotheken. Es ist in die Sprache eingebaut. Go ist auch extrem
API-freundlich. Deshalb habe ich hier ein Beispiel, um Ihnen zu
zeigen, wie es in Go funktioniert. Wenn wir also davon ausgehen, dass
wir eine Art
JSON-Antwort von
einer solchen API haben , können
wir das JSON-Paket und
auch den JSON-Bezeichner verwenden ,
wenn wir hier einen Typ
definieren, es ist eine API,
es ist eine Struktur. Und wir wissen, dass
unsere Antwort
einen Typ int und
ein String-Array hat . Es ist ein String-Array. Wir verwenden diesen JSON-Bezeichner. Die Magie
passiert nun, wenn wir diese Bezeichner verwenden und wir
das eingebaute JSON-Paket verwenden.
Nehmen wir an, wir haben bereits die Antwort von der API, eine
Art binäres Ergebnis Wir können JSON einfach
Unmarshal aufrufen und Golang serialisiert
dieses binäre Ergebnis serialisiert
dieses binäre Ergebnis
in unser Antwortobjekt. Und wenn es diese Schlüssel sieht, weiß
es, dass es
diese Werte in jeden
dieser Teile dieser Struktur einfügen muss diese Werte in jeden
dieser Teile dieser Struktur Also gingen wir
davon aus, dass es keinen Fehler gab, die
Antwort
zu
marshallten, wenn wir einige Int-Zahlen abmelden würden, bekämen wir fünf und wenn wir die
Zeichenketten in einer Schleife durchgehen würden, bekämen
wir A, B und C. Also nochmal, wir brauchen keine
Konfigurationsdateien, keine externen Bibliotheken Wir verwenden einfach die integrierte JSON-Bibliothek mit der
Unmarshal-Methode, und Golang kümmert sich sofort um die
gesamte Serialisierung und Deserialisierung von
JSON. Das Gehen ist auch extrem einheitlich. Wenn Sie also mit
einem modernen Code-Editor
wie Visual Studio Code schreiben , formatieren Sie beim Speichern
nach den eigenen integrierten Regeln. Und das bedeutet, dass Sie
unabhängig davon, wo Sie G-Code
lesen, ob es sich um ein
externes Paket, ein Paket eines Drittanbieters Code
Ihrer Teamkollegen handelt, Sie sehen
werden jedem G-Code immer
dieselben Muster,
Einrückungen und
Abstände Das macht es sehr einfach, andere Go-Projekte zu
lesen. Dies erspart Ihnen und
Ihrem Team auch Zeit um über Formatierungsregeln
wie Tabulatoren und Leerzeichen
und all diese Dinge zu
diskutieren wie Tabulatoren und Leerzeichen
und all diese Dinge Diese Regeln sind auch
in die Go-Sprache integriert. Zusammenfassend lässt sich sagen, dass G
sehr performant ist. Es ist sehr schnell, zumindest nach
all den Erfahrungen, die ich damit gemacht
habe, es ist sehr kompakt Sie benötigen nur Ihre
einzige Haupt-Dot-Go-Datei. Es ist leicht testbar. Das Testen erfolgt in
der Sprache selbst. Es ist sehr API-freundlich. Diese JSON-Serialisierung
und Deserialisierung ist
ebenfalls
standardmäßig in
der Sprache enthalten und sie ist einheitlich Diese Linting- und
Formatierungsregeln sind
auch Insgesamt ist G also eine sehr gute Wahl für jede Backend-Software, die
Sie möglicherweise erstellen müssen Mit einem grundlegenden Hintergrundwissen
darüber, was G ist und
welche Vorteile es bietet, können
wir uns
in der nächsten Lektion mit
der eigentlichen Anwendung befassen,
die wir erstellen werden,
und dann können wir endlich
mit der Programmierung der Anwendung beginnen der eigentlichen Anwendung befassen,
die wir erstellen werden, .
3. Allergie-API: In diesem Kurs
werden wir
eine Anwendung entwickeln, die uns täglich
Nachrichten sendet und uns vor den zu erwartenden
Pollenwerten in der Luft
warnt. Wenn Sie wie ich sind, können
Sie jedes Jahr von etwa Mitte
Mai bis Mitte Juni an
Heuschnupfen leiden , zumindest auf der
Nordhalbkugel. Und mach dir keine Sorgen Auch wenn Sie keinerlei
Allergien haben, verspreche
ich Ihnen, dass die Inhalte
und Muster in diesem Kurs äußerst nützlich
sind, unabhängig davon welche Art von
Go-Anwendung Sie verwenden. Also, wo ich in Österreich lebe, die Medizinische
Universität Wien hat
die Medizinische
Universität Wien diese großartige Website, die die Pollenwerte für den Tag
vorhersagt Und nach einigem Suchen und
Prüfen der
API-Aufrufe für diese Site
habe ich die Endpunkte gefunden, die alle Daten
produzieren Es gibt hauptsächlich zwei Endpunkte
, die wir verwenden werden. Der erste besteht darin,
stündliche Ladedaten abzurufen, die einen
Erfolgsschlüssel und das Ergebnis Am wichtigsten ist, dass hier dieses stündliche Array
ist. ergibt also für jede Stunde Es ergibt also für jede Stunde einen erwarteten Pollenwert in
der Luft, der von Null
bis, glaube
ich, acht oder neun reicht. Der zweite Endpunkt
, den wir in diesem Kurs
verwenden werden , ist das
Abrufen aktueller Diagrammdaten. Diesen werden wir
für historische Durchschnittswerte verwenden. Wie Sie
hier sehen können, haben wir auch einen Erfolgsschlüssel. Wir
haben einige Ergebnisse. Und für jedes Ergebnis haben
wir ein Datum, das
aktuelle oder in diesem Fall das, was
an diesem Tag in diesem Jahr tatsächlich passiert ist, und dann den historischen Durchschnitt. Es ist jedoch
gerade der 16. Mai, und wie Sie sehen können, ist
der Strom Null, und selbst für gestern ist
der Strom Null. Diese Daten sind also
etwas verzögert. Wie ich bereits erwähnt habe, werden
wir es jedoch hauptsächlich
für die Durchschnittswerte verwenden. Wir werden also
sowohl den erwarteten Wert
für den Tag aus
diesen stündlichen Daten als
auch den historischen
Durchschnitt für den Tag herausgeben für den Tag aus diesen stündlichen Daten . Mit einem Überblick
und einer Vorstellung davon was unsere App
sein wird, werden
wir in der nächsten Lektion kurz die
technischen Anforderungen besprechen , die unsere App erfüllen soll, und dann können wir
endlich anfangen , Code zu schreiben.
4. Anwendungsanforderungen: In der letzten Lektion haben wir uns mit
der Allergie-API befasst , die wir verwenden
wollten , und mit der Herkunft dieser
Daten. Und in dieser Lektion werden wir
nur kurz
die Anwendungsanforderungen auf
einer eher technischen Ebene besprechen die Anwendungsanforderungen auf , bevor
wir mit dem Programmieren beginnen. Aus Sicht des
Anwendungsablaufs, also zu einer bestimmten Tageszeit, wollen
wir diese
Allergie-Endpunkte nennen Wir werden
die JSON-Antwort
von jedem Aufruf analysieren und dann
einige Formatierungsarbeiten durchführen ,
um sie
in eine nette, für Menschen
lesbare Nachricht umzuwandeln in eine nette, für Menschen Dann wollen wir endlich
diese nette Nachricht
über Slack-Webhooks senden diese nette Nachricht
über Slack-Webhooks Alle Funktionen, die wir
schreiben, sollten Tests haben. Die Anwendung sollte von einem Docker-Container aus
ausgeführt werden. Der Docker-Container sollte bei jedem Fehler oder Absturz
neu gestartet sollte eine automatisierte Pipeline
erstellt werden ,
die alle von uns geschriebenen Tests ausführt und dann den
Docker-Container
veröffentlicht , falls all
diese Tests Und schließlich sollten die
verschiedenen wichtigen Werte, die rund um die Anwendung
verwendet werden, wie die API-Endpunkte, die Slack-Webhook-URL, die Cron-Job-Zeit und
die
Crown-Job-Zeitzone, alle konfigurierbar sein In diesem Kurs werden
wir uns also Schritt für Schritt mit all diesen Anforderungen befassen und sie erfüllen In der nächsten Lektion werden
wir endlich
damit beginnen, unsere Go-Anwendung zu entwickeln
5. Installieren von Go und Visual Studio Go-Erweiterung: Fangen Sie an, wir sollten alle überprüfen, ob G installiert ist. Um zu überprüfen, ob ich
G installiert
habe, gebe ich einfach die
G-Version heraus. Und ich kann sehen, dass ich G 1.20 0.2 habe. Wenn dieser Befehl nichts oder einen Fehler
zurückgibt, müssen Sie wahrscheinlich G auf Ihrem System
installieren Sie können zu Go Dot Dev
Slash DClash Install Dort finden Sie die
Installationsanweisungen für Linux, Mac und Windows Für den Rest
dieses Kurses gehe
ich davon aus, dass
Sie zusammen
mit mir Visual Studio-Code programmieren mit mir Visual Studio-Code Daher empfehle ich auch, dass Sie die G-Erweiterung installiert
haben. Um die G-Erweiterung zu finden, gehen Sie zur
Registerkarte Erweiterungen und suchen G. Es sollte
das erste Ergebnis sein, und ich habe
sie natürlich schon installiert. Diese Erweiterung ist
eine zentrale Anlaufstelle für alles, was Sie für die Bearbeitung von G-Code
benötigen sollten. Es ist eine Kombination aus Inter,
Tester, Debugger und Format für G. Sobald Sie diese Erweiterung
installiert haben, können
wir mit dem Aufbau unseres G-Projekts beginnen
6. Gerüste für das Projekt: In der letzten Lektion haben wir sichergestellt,
dass G installiert ist, und wir haben auch die
Visual Studio Code G-Erweiterung installiert Jetzt werden wir unsere App als Gerüst einrichten. Wenn Sie ein neues G-Projekt
starten, würden
Sie normalerweise einen neuen
Ordner für diese Anwendung erstellen In diesem Fall würde ich es
Allergy Cron nennen und Sie würden Make DR Allergy Cron
ausgeben Da ich mich jedoch bereits
im Kursarchiv
befinde, habe ich hier einen Ordner für das Projekt und werde keinen neuen Ordner
erstellen Der nächste Schritt wäre dann, ein Modul
für das Projekt zu initialisieren Normalerweise verwende ich den gleichen Namen
wie den Ordnernamen selbst. In Ihrem Fall
wäre das Allergie Cron. Also hier werden wir
es entsprechend
diesem Ordnernamen initialisieren es entsprechend
diesem Ordnernamen Der Befehl zur
Initialisierung eines G-Moduls lautet Gomd init und dann in
unserem Fall Go wird uns mitteilen, dass es eine neue Go Dot-Mod-Datei
erstellt hat. Wir können in diese
Gomd-Datei springen und sehen, was darin enthalten ist. Da wir vorerst keine
zusätzlichen Pakete
installiert haben , enthält
sie nur den Modulnamen
und die Go-Version, mit der es erstellt
wurde Als Nächstes können wir
die Hauptdatei erstellen, also Touch Main Dot Go. Und wenn Sie sich immer noch
nur in einer Terminalumgebung befanden, hatten
Sie keinen Editor geöffnet. Sie könnten den Hauptpunkt
natürlich
auch mit dem Befehl Öffnen öffnen. Oder wenn Sie
es in Visual Studio-Code öffnen möchten, können Sie den
Code Main Dot Go eingeben. Nach all dem Setup sind
wir also endlich bereit, mit dem Schreiben von G-Code zu
beginnen.
7. Erstellen des Cron-Jobs: In der letzten Lektion haben wir unser neues G-Projekt
aufgerüstet und ein G-Modul
initialisiert, was uns
diese Go-Dot-Mod-Datei hinterlassen hat, und wir haben eine leere
Haupt-Dot-Go-Datei erstellt In dieser Lektion werden
wir uns mit
der ersten technischen Anforderung befassen , nämlich einem täglichen Cron-Job
, der genau
zur gleichen Zeit ausgelöst wird genau
zur gleichen Zeit ausgelöst Jede Go-Datei hat ganz oben eine
Paketdeklaration. In diesem Fall
ist dies das Paket Min. Dann haben Sie hier vielleicht
einige Importe. Und im Fall
der Dot-Go-Hauptdatei haben
wir unsere Hauptfunktion, die einfach die
Funktion main ist. Jetzt verwende
ich für Crown-Jobs und G gerne die beliebte
Rob Fig Cron-Bibliothek Diese Bibliothek
ermöglicht es uns auch,
den Cron-Job einer bestimmten
Zeitzone entsprechend einzustellen den Cron-Job einer bestimmten
Zeitzone entsprechend Also werde ich zuerst das Zeitpaket von
Go verwenden, um die Zeitzone zu
laden, und dann können wir den
Crownjob in dieser Zeitzone einrichten Also bekommen wir einen Standort und eine Fehlermeldung und das ist von
Zeit, Standort laden. Und da ich in Österreich bin, will
ich Europa, Wien. Dann
müssen wir natürlich überprüfen, ob der Fehler nicht Null ist, dann geraten wir mit diesem Fehler in
Panik, und andernfalls
können wir weitermachen. Nun, um mit diesem Paket einen Crown
Job einzurichten, müssen wir nur neu
anrufen und den Standort
angeben, und wir werden den Standort
übergeben. Nun, wir sehen mit dem Inter, sobald ich auf diesen Cron
Bezug nehme, weiß
der Inter, welches
Paket ich verwenden möchte Das einzige Problem hier ist, dass dieses Paket noch nicht
in unserer Mod-Datei Wenn wir also hier mit der Maus über
den Import
fahren, beschwert sich Go, dass es
kein Modul gibt, das
dieses Paket bereitstellt Aber zum Glück
bietet uns der Linter eine schnelle Lösung,
nämlich einfach den Befehl install oder go get package Also wenn wir einfach darauf klicken, dass
das Paket installiert ist. Du solltest sehen, dass deine
GOT-Mod-Datei geändert wurde, und dann können wir hier mit unserem Code
weitermachen. Um das
tatsächliche Cron-Timing nicht zu übergeben, müssen
wir den
Punkt und Funk bei Cron Job hinzufügen, und das nimmt den standardmäßigen Cron-Identifier
vom Typ Unix
mit sechs Zeichen mit Und das sind speziell
die Sekunden, die Minuten, die Stunden, der Tag des Monats, der Monat selbst
und der Wochentag In unserem Fall denke ich, dass
ein vernünftiger Zeitpunkt, zumindest für mich, jeden Morgen
8:00 Uhr ist. Also gebe ich sowohl Null
für die Sekunden und Minuten acht für die Stunde an. Und dann ist der zweite Parameter für diesen Ad-Funk die Funktion, die wir
eigentlich ausführen wollen. Und vorerst werde ich dort einfach eine leere Funktion
platzieren. Ich kann diesen
Importkommentar bereinigen und wir können unsere Datei speichern. Eine weitere Sache, die ich hier hervorheben
möchte, ist die
Fähigkeit der Visual Studio Go-Erweiterungen, automatisch zu formatieren. Wenn wir
hier also
schlampige Abstände oder ähnliches haben , sehen wir, sobald wir, in meinem Fall,
auf einem Mac Command S speichern , sobald wir, in meinem Fall,
auf einem Mac Command S speichern,
dass der Inter diesen Code
automatisch formatiert Ich sollte
für diese Zeitzonen auch erwähnen, sogenannten
Iana-Zeitzonendatenbank nachgeschlagen werden sogenannten
Iana-Zeitzonendatenbank Ich habe eine nette Website
namens Nota Time gefunden, die all die
verschiedenen Zeitzonen auflistet Wo auch immer Sie
sich auf der Welt befinden, Sie können diese Tabelle jederzeit
durchsehen und die Zeitzone einstellen,
je nachdem, wo Sie sich befinden oder wann
Ihr Cron-Job ausgelöst werden soll Wir müssen auch sicherstellen, dass
unser Cron-Job gestartet wird. Also haben wir die Funktion hinzugefügt, aber wir müssen den Cronjob
Dot SAT explizit aufrufen Und wenn wir das belassen würden
, wenn wir
die Hauptfunktion ausführen, würde
sie einfach
hier laufen und dann Wir müssen also
den Haupt-Thread blockieren, um den Go-Prozess am
Laufen zu halten,
sodass dieser Cron-Job auch nach
dem Start aktiv bleibt
und der Cron bis zu
jedem Tag
weiterläuft, an dem er
das Zeitfenster von 8:00 Uhr erreicht. In dieser Lektion haben wir angefangen, unsere Haupt-Dot-Go-Datei zu
schreiben. Wir haben gelernt, dass jede Go-Datei mit einer
Paketdeklaration
beginnt. Dann gibt es normalerweise
einige Importe und dann deine Funktionen. In diesem Fall handelt es sich
um einen Sonderfall. Die Haupt-Dot-Go-Datei
hat immer eine Hauptfunktion. Und wir fingen an, den
Hauptteil unserer Hauptfunktion zu schreiben. Wir haben die Wiener Zeitzone geladen, und wir haben diese
Ortszeitzone in unserem Cron-Job verwendet
und den Cron-Job so eingerichtet, dass er jeden Tag um 8:00 Uhr
abgefeuert wird. Wir haben eine nette Funktion gesehen, wie das Visual
Studio-Codeformat die Einrückungen in unserem Code
automatisch korrigieren und formatieren
kann Einrückungen in unserem Code
automatisch korrigieren und formatieren Und wir haben auch
all die verschiedenen Möglichkeiten besprochen , die
Sie an
diese Ladeortfunktion übergeben können , damit Sie die gewünschte
Zeitzone einstellen können der nächsten Lektion werden wir uns mit der
Erstellung einer
HTTP-Hilfsfunktion befassen , sodass wir uns ansehen können,
wie wir
die API-URLs aufrufen , die wir schließlich in den Funktionstext
hier unseres Crown-Jobs
einfügen.
8. Erstellen einer generischen HTTP-Dienstprogrammfunktion: letzten Lektion haben wir
damit begonnen,
unsere Haupt-Dot-Go-Datei zu erstellen und den Cron-Job einzurichten , der unsere verschiedenen
Aufgaben um 8:00 Uhr
in der Wiener Zeitzone
auslösen könnte . in der Jetzt werden wir
eine generische
HTTP-Funktion schreiben , die sowohl für die
Allergie-API-Aufrufe als auch für das Senden unserer Slack-Nachricht
verwendet wird sowohl für die
Allergie-API-Aufrufe als auch für das Senden unserer Slack-Nachricht
verwendet Allergie-API-Aufrufe als auch Nun, diese Funktion
ist ziemlich komplex und nutzt die
generischen Funktionen von G. Ich werde nicht zu detailliert darauf eingehen ,
wie die Funktion aufgebaut
wurde. Ich habe einen separaten
Blogbeitrag, der
sich mit den Details der
Implementierung befasst, und Sie können
gerne separat darüber lesen. Um mit
dieser Funktion zu beginnen, erstellen
wir einen neuen
Ordner namens Utils und eine neue Datei namens make
http request dot go Das Paket hier wird Utils sein. Und für unsere Funktion
stellen Sie eine HDP-Anfrage. Das erfordert einen generischen Typ. Dann übergeben wir die vollständige URL, die eine Zeichenfolge ist,
die HTTP-Methode wir erwarten, die auch eine Zeichenfolge
ist. Alle Header, die der Aufruf benötigt
, also eine Zeichenkette
und eine String-Map Die Abfrageparameter, die vom Typ RL-Werte
sind, der Hauptteil, der IO-Reader ist, und der Antworttyp T, und wir geben diesen
Typ oder einen Fehler zurück Das erste, was wir
in dieser Funktion tun werden, ist , unseren HTTP-Client zu initialisieren Und wir konvertieren
die String-URL ein vollständiges URL-Objekt mit
Rl-Punktpaaren mit dieser vollständigen Wenn der Fehler nicht NIL ist, geben wir einfach unseren
Antworttyp und den Fehler zurück Wenn die Methode G ist, müssen
wir alle übergebenen
Abfrageparameter
anhängen übergebenen
Abfrageparameter
anhängen Also erhalte ich zuerst die
Abfrage aus dem URL-Objekt, und wir müssen diese
Schlüsselwertpaare innerhalb
der Abfrageparameter in einer Schleife
durchgehen Schlüsselwertpaare innerhalb
der Abfrageparameter Und wir werden
den Schlüssel und den Wert festlegen. Für jeden Parameter.
Und dann setzen wir die Rohabfrage auf die mit Narren kodierte erstellte
Abfrage, die wir hier erstellt haben Wir können auch den Hauptteil festlegen , indem wir
eine neue Anfrage stellen
und die Methode,
die String-Version
der URL und den Hauptteil
übergeben der URL und den Hauptteil Wenn der Fehler nicht Null ist, geben
wir wiederum den
Antworttyp und den Fehler zurück. Und jetzt, da wir unsere Anfrage
haben, müssen
wir die Header festlegen Was den Schlüssel und den
Wert dieser Header betrifft, werden
wir den Header-Wert festlegen Und schließlich können wir
ihre eigentliche Anfrage bearbeiten, und das ist buchstäblich mit der Punktdofunktion des Clients Auch hier gilt: Wenn der Fehler nicht NIL ist, geben
wir den
Antworttyp und den Fehler zurück. Wir überprüfen auch, ob
die Antwort selbst NIL
ist. Wir geben den Antworttyp und einen Fehler der
besagt, dass beim Aufrufen der URL eine leere Antwort
zurückgegeben und wir
diese String-Version
des URL-Objekts übergeben möchten . Andernfalls, wenn wir hier
weitermachen, wollen
wir den Text lesen. Und auch hier gilt: Wenn der
Fehler nicht Null ist, geben Sie den Antworttyp Fehler zurück verschieben Sie das Schließen dieses Textes Und wir wollen auch überprüfen, ob der Statuscode nicht
der Statuscode o ist Antworttyp, und wir
machen hier auch einen benutzerdefinierten Fehler. Ähnliche Formatierung hier. Sie können eine neue
Zeile mit dem Statuscode einfügen, eine weitere neue Zeile mit den
tatsächlichen Antwortdaten. Und dann wollen wir die URL-Zeichenfolge,
den tatsächlichen Statuscode
und diese Antwortdaten
eingeben den tatsächlichen Statuscode . Wenn wir nun so weit gekommen sind, können
wir die Antwortdaten endlich in
das Antwortobjekt zerlegen,
das vom Typ T ist, wie wir erwarten Also deklarieren wir das
Antwortobjekt
und wir werden
versuchen, die Antwortdaten in
das Antwortobjekt Antwortdaten in
das Antwortobjekt Wenn der Fehler nicht neu ist, ändern Sie den Antworttyp
und den Fehler selbst Schließlich können wir sicher
das vollständige
Antwortobjekt mit einem NL-Fehler zurückgeben . Wenn ich jetzt hier speichere,
importiert
die Visual Studio Go-Erweiterung automatisch Go-Erweiterung automatisch alle
Bibliotheken, die wir verwenden. Also IO, die HDP-Bibliothek, die URL-Bibliothek,
Zeichenketten und so weiter Mit ein wenig Aufwand haben
wir also eine sehr leistungsstarke
generische Funktion, und ich verwende diese
Funktion gerne für fast jeden
Standard-REST-HTTP-Aufruf, den ich tätigen muss Wie wir gesehen haben, ist sie
so implementiert , dass sie für Get Put,
Post und alle Arten
von HTTP-Verben funktioniert ,
Post und alle Arten
von HTTP-Verben Da diese leistungsstarke
Funktion nun implementiert ist, werden
wir in der nächsten Lektion die Allergie-API
aufrufen Wir werden auch die Typen definieren, die als dieser generische Typ übergeben
werden. Wir wissen also, dass die JCN-Antwort korrekt serialisiert
wird, und können sie dann
weiter unten in unserem G-Code verwenden
9. Aufrufen und Parsen der Allergy-API: letzten Lektion haben wir
diese ziemlich leistungsstarke generische
HDP-Anforderungsfunktion erstellt , und jetzt werden
wir in dieser Lektion davon Gebrauch machen, um
die Allergie-API der
Medizinischen Universität Wien aufzurufen die Allergie-API der
Medizinischen Universität Wien Um zu beginnen,
erstellen wir einen neuen Ordner. Es heißt Allergie-API und eine neue Go-Datei Allergy
underscore api dot go Und dieses Paket entspricht
dem Ordner- und Dateinamen,
Allergy Underscore API Als Erstes müssen
wir nun die Typen
definieren, die wir hier an unsere
generische Funktion übergeben, sodass der JSON-Code
hier,
wenn er unmarshallt ist, weiß
, in sodass der JSON-Code
hier,
wenn er unmarshallt ist, welchen Typ er demarshallt werden soll Und wenn wir uns diese
beiden separaten API-Aufrufe ansehen, haben
wir unsere stündlichen Ladedaten, die eine Art
übergreifende Struktur mit den Erfolgs- und Ergebnisschlüsseln haben,
und dann haben
wir innerhalb des Ergebnisses ein weiteres Objekt,
das eine totale, eine
Art
personalisierte Option hat ,
und dann, was für uns am wichtigsten ist, das stündliche Array, das eine Reihe von ganzen Zahlen
ist. Für das Abrufen aktueller Diagrammdaten haben
wir ebenfalls eine
ähnliche Struktur Wir haben ein großes Objekt, das
die Schlüssel für Erfolg und Ergebnis enthält. Aber dann ist das Ergebnis
hier direkt ein Array mit einem sich wiederholenden
Objekt, das das aktuelle Datum, die
durchschnittliche Jahreszeit und die Datumszeit hat . Und noch einmal,
am wichtigsten für uns ist hier der Durchschnitt. Wir nehmen
diesen Endpunkt für den historischen Durchschnittsanteil der Nachricht, die wir versenden. Lassen Sie uns also mit
den stündlichen Ladedatentypen beginnen. Also werde ich zuerst die Antwort
definieren,
und das hat hier einen Erfolgs
- und Ergebnisschlüssel. Also werde ich das
als stündliche Lastantwort definieren. Das ist ein Strup und
wir haben unseren Erfolg, der eine Ganzzahl ist
, und der JSON-Bezeichner hier
ist Erfolg in Kleinbuchstaben Und das Ergebnis, das wir
brauchen, um einen neuen Typ zu definieren, eine neue Struktur für
diesen verschachtelten Typ, nenne
ich es
stündliches Und wir müssen auch den JSON-Schlüssel
definieren, der das Ergebnis in Kleinbuchstaben darstellt Da dieser Typ nun diese andere Struktur
verwendet, möchte
ich
den obigen Typ normalerweise hier einfügen Und was haben wir? Wir haben die Summe und die
stündliche Summe ist eine Ganzzahl. JSON-Werte in Kleinbuchstaben und
stündlich sind ein Teil von Eins, und JSON ist stündlich Und wenn ich hier wieder speichere, formatieren
die Linters alles nett und ordentlich in Spalten Jetzt können wir
zu den Diagrammdaten übergehen. In ähnlicher Weise haben wir die Antwort auf
die Diagrammdaten. Und schauen wir uns das an. Auch Erfolg und Ergebnis sind entscheidend. Erfolg ist also ein Int. Und das Ergebnis, oder ich sollte sagen, Plural der
Ergebnisse ist ein Array, und dieser Typ muss ein anderer benutzerdefinierter Typ
sein
, den ich aktuelles
Diagrammdatenergebnis nenne Und wir müssen auch den JSON-Schlüssel
angeben. Ich nehme das und
definiere den Typ hier. Und alles, was wir wirklich
brauchen, ist das Datum, das vorerst als
Zeichenfolge verwendet wird, und den Durchschnitt
, der eine Gleitkommazahl ist. Wir haben also das Datum und den Durchschnitt ich kann das speichern, und das sollte alles
sein, was wir für
benutzerdefinierte Eingaben benötigen. Jetzt schreiben wir
für jeden API-Endpunkt eine
separate Funktion für jeden API-Endpunkt Die erste Funktion können wir aufrufen,
um stündliche Ladedaten zu erhalten. Und die zweite rufen wir
get current chart data auf. Für beide
erwarten wir nun, dass sie
einen Zeichenkettenzeiger und einen Fehler zurückgeben . Und diese Zeichenfolge wird
letztendlich die Nachricht sein, die an unseren
Slack Messenger weitergegeben
wird Und wir wissen, dass das Ziel hier darin besteht, unsere generische Funktion hier
aufzurufen Wir erhalten also eine Antwort
und einen Fehler von can
import this Utils-Paket
, das wir gerade in
der vorherigen Lektion erstellt haben , und
der Make HTTP-Anfrage Jetzt müssen wir den Typ nicht mehr explizit angeben
. Golan wird das für uns ableiten. Und für die URL haben
wir sie hier. Das ist dieser Indexpunkt PhP. können wir einbauen. Wir wissen, dass
dies eine GET-Anfrage sein wird. Wir müssen keine Header
übergeben. Wir müssen
einige Abfrageparameter übergeben. Es gibt keinen Text, den
wir übergeben müssen, und der Antworttyp ist die
stündliche Lastantwort. Und wenn der Fehler
nicht NL ist, geben wir
eine Nil-String zurück und
den Fehler vorerst, gehen
wir zu diesen
Abfrageparametern über. Dieser Typ sind die URL-Werte. Und wir können alle
Parameter hinzufügen, die wir benötigen. Für diese Stunde sind also ziemlich viele
hier. Wir haben eine EID, ein Aktionstyp kann
eine Postleitzahl angeben und so weiter. Also werden wir all
diese Abfrageparameter bereitstellen. Wir sind uns also sicher, dass
unsere Get-Anfrage genauso
funktioniert wie im Browser. Also werden wir diese EID hinzufügen Der Typ ist ZIP. Die PLZ ist 6.800. Das Land ist Österreich A. T. Und es gibt auch diese Flagge für den Cure JSON, und das ist eine Kann dieses URL-Paket importieren. Lassen Sie uns nun mit
dem Formatieren und
Erstellen dieser Zeichenfolge fortfahren , die wir zurückgeben möchten. Aus den Daten hier haben wir also das gesamte Spektrum der zu erwartenden
stündlichen Belastung abgeleitet. Also machen wir eine
Schleife über dieses Array, erstellen einen Durchschnitt
und dann
eine Zeichenfolge, die angibt,
was dieser Durchschnitt ist. Also werden wir zuerst eine
durchschnittliche Last definieren. Und dann wiederholen wir den Bereich, von dem wir
wissen, dass er innerhalb des stündlichen
Teils des Ergebnisses liegt. Das Plus
entspricht also dem Stundenwert, und dann wird
die durchschnittliche
Last zur durchschnittlichen Last geteilt durch
die Länge aller Stunden Eine weitere Sache, die mir beim Umschauen in
der API
aufgefallen ist, ist, dass sie eine
Art Normalisierung
der Daten durchführen eine
Art Normalisierung
der Es wird hier nicht angezeigt,
aber diese Zahlen können bis zu acht oder neun betragen, aber sie zeigen nur einen Rang 0-4 auf der eigentlichen
Benutzeroberfläche der Website Um diese Funktionalität irgendwie
nachzuahmen,
teilen
wir vorerst einfach den Durchschnitt, wir nennen es eine
skalierte durchschnittliche Auslastung, und das ist nur diese
durchschnittliche Last geteilt durch Die formatierte Nachricht,
die wir senden werden, nehmen das
Formatpaket Sprint F
und sagen, aber die durchschnittliche Pollenlast für
heute ist skaliert als Durchschnitt, und wir werden diese
formatierte Nachricht ohne Fehler zurückgeben Die Implementierung für das Abrufen aktueller Diagrammdaten
ist ziemlich ähnlich Ich werde
das alles tatsächlich kopieren, und dann können wir entsprechende
Änderungen vornehmen. Und ich habe hier einen
kleinen Fehler gemacht. Dies ist die Aktionstaste, und die EID ist
in der Tat eine App-Oberfläche. Das kannst du hier hinzufügen. Hier, in diesem
Fall, besteht die Aktion darin, wie wir hier in der URL
sehen können, aktuelle Diagrammdaten abzurufen. Die ganze ID, das ist eigentlich
für die Art der Pflanze. In diesem Fall habe ich
es gegen meine Allergie gemacht, die gegen Gräser oder Heu ist Wir können den Reißverschluss immer noch weitergeben. Wir kümmern uns nur um
die Saisondaten, und das ist die Flagge
für die Saisondaten. Und wir wollen auch, dass das reine
JCN-Flag aktiviert wird. Die URL ist dieselbe.
Die Methode ist dieselbe. Wir übergeben natürlich immer noch
die Abfrageparameter, und jetzt müssen wir nur noch den Antworttyp
ändern
, der der aktuelle Antworttyp für
Diagrammdaten ist. Jetzt
wird sich G hier natürlich beschweren, weil die Form der
Antwort anders ist. Bei dieser Methode wollen wir also all diese Ergebnisse wiederholen ,
bis wir ein passendes Datum gefunden haben, und dann wollen wir
den historischen Durchschnitt
für das aktuelle Datum ausdrucken . Ich werde eine Variable
namens current YY MMDD definieren. Das ist jetzt Timepunkt, und dann müssen wir es mit dem Go-Stil für die Formatierung
von Zeichenketten formatieren Wir definieren einen
durchschnittlichen Verlauf
, der
eine Null initialisiert, und dann werden
wir diese Ergebnisse wiederholen und das passende Datum
finden Wenn also das Ergebnisdatum diesem aktuellen Datum
entspricht,
dann wissen wir, dass der historische Durchschnitt dieser Ergebnisdurchschnitt
ist Und in ähnlicher Weise sollten wir, wie
wir es oben getan haben ,
einen skalierten Durchschnitt erstellen und daraus eine Ganzzahl nehmen , da wir nur
Null bis Vier wollen, und wir runden einfach den durchschnittlichen historischen Befund geteilt durch zwei, und dann können wir
unsere formatierte Nachricht erstellen In diesem Fall
sagen wir, historisch gesehen, die durchschnittliche
Pollenbelastung für heute ist und wir geben
diesen skalierten Wir speichern den
Zwischenspeicher, importieren diese Pakete und wir sollten fertig sein In dieser Lektion haben
wir angefangen, darüber nachzudenken, wie wir
diese beiden Endpunkte aufrufen und den von ihnen zurückgegebenen JSON
deserialisieren können diese beiden Endpunkte aufrufen und JSON
deserialisieren Wir haben uns zunächst
die Struktur des JSON angesehen und die benötigten Typen und
die benötigten Teile
dieses JSONs definiert benötigten Typen und
die benötigten Teile
dieses JSONs , die wir
für die Erstellung unserer Nachrichten verwenden müssen Dann fingen wir an
,
die eigentlichen Funktionen zu schreiben , die den Endpunkt aufrufen, und nutzten dabei unsere
Make HTP-Anfrage, die wir
in der vorherigen Lektion erstellt haben Sobald wir die Antwort erhalten
haben, führen wir ein wenig
Berechnungen und Formatierungen durch Und für jede Funktion wir letztendlich
die formatierte Zeichenfolge zurück, die wir über Slack
senden können In der nächsten Lektion nehmen wir diese Rückgabezeichenfolge und senden
sie über Webhooks durch Slack
10. Erstellen einer Slack-App und einer Messaging-Funktion: In der letzten Lektion haben wir einige Typen
definiert und zwei Funktionen
geschrieben, um die Allergie-API
aufzurufen, einige Berechnungen durchzuführen und letztendlich eine
gut formatierte Zeichenfolge zurückzugeben, die wir
dann an Slack weiterleiten würden damit wir
die Nachricht über
Slack senden könnten Um unsere
Nachrichten über Slack zu versenden, benötigen
wir zunächst Dann müssen wir
eingehende Webhooks für diese App aktivieren , und dann
haben wir endlich eine URL, die wir
tatsächlich posten können, um die
Nachricht zu senden Wir kehren dann zurück zum Code und schreiben eine weitere Hilfsfunktion, um jede Nachricht an unsere
Slack-App zu
senden Um mit der
Erstellung einer Slack-App zu beginnen, gehe zu api dotslaq.com und gehe bis hierher
und klicke auf deine Apps. Du musst dich anmelden
, um zu deinen Apps zu Ich werde mich hier mit Google anmelden. Und ich möchte das
Full Stack Craft-Konto meines Unternehmens. Und wir können hier einfach
auf Abbrechen klicken. Jetzt, wo wir
angemeldet sind, können wir zu api dotslag.com
zurückkehren Und dann klicke auf deine Apps. Sobald wir auf der Seite mit der
App-Liste sind, klicken Sie auf Neue App erstellen. Und wir möchten
unsere App von Grund auf neu erstellen. Ich nenne meinen
Allergy Cron Bot. Und wieder möchte ich es in meinen
eigenen Fullstack Craft Works haben. Auf der resultierenden Seite
wollen wir dann eingehende Webhooks hinzufügen Und wir wollen nur
diesen Schalter auf ON stellen,
und wir werden sehen, dass hier ein
Code erscheint Jetzt wollen wir einen neuen Webhook
hinzufügen, also klicken wir hier und
müssen einen Kanal auswählen, auf dem er posten Vorerst wähle ich
Allgemein und klicke auf AAO. Wenn wir bereits eine
Slack-App geöffnet haben, sei es im Web oder in
der Desktop-Version, sollten
wir sehen, dass die
Integration hinzugefügt wurde Also hier im Allgemeinen sehe ich, dass ich meinen Allergy Crown Bot hinzugefügt habe Zurück in der Weboberfläche kannst
du sehen, dass Slack eine Webhook-URL für uns
erstellt hat, sodass wir
diese sofort kopieren können Alternativ kannst du ihr Beispiel
hier kopieren. Dies ist ein Hello World-Beispiel. Und direkt im Terminal hier werde
ich dieses Beispiel einfügen, sollte es
ohne Probleme starten. Und wenn wir zu Slack wechseln, sehen
wir tatsächlich die
Hello World-Nachricht von unserer brandneuen Slack-App Im Moment kopieren wir einfach die URL selbst und gehen
zu unserem G-Projekt Wir werden eine Hilfsfunktion erstellen , an die wir eine Nachricht senden können. Also rufe ich diese Datei auf und
sende eine Slack-Nachricht. Das ist das Paket Utils und die Funktion hier,
Slack-Nachricht senden Wir akzeptieren einfach eine Nachricht, die eine Zeichenfolge ist, und sie
geben einen Fehler zurück, falls vorhanden Alles, was wir hier tun müssen,
ist einen Body zu erstellen, und wir werden
das JSON-Paket verwenden und eine String-String-Map
mit diesem Textparameter zusammenstellen, und das ist
die Nachricht, die wir an die Funktion übergeben Wenn der Fehler nicht Nil ist, geben
wir diesen Fehler zurück Dann können wir unsere
Make HTP-Anfrage verwenden. Das wird unsere URL sein. Darauf werden wir posten. Bei den Headern müssen
wir keine Abfrageparameter angeben. Wir können es auch als Nil verlassen. Wir erstellen einen Puffer
aus unserem Körper, und wir können einfach eine
leere Zeichenfolge als unseren Typ haben. Wir
bekommen nicht wirklich eine Antwort. Wir würden einfach einen
200-Code bekommen, wenn es erfolgreich ist. Wir müssen also nichts analysieren. Und von hier aus
können wir Nil zurückgeben. Und wenn ich diese Datei speichere, importiert
der Linter
das JSON-Paket, und wir sollten fertig sein Nun, diese URL ist
technisch gesehen geheim, denn wenn jemand
sie in die Finger
bekommt, könnte er deinen
Slack-Kanal auf unbestimmte Zeit spammen Vorerst belassen wir es
hartcodiert , aber in einer späteren Lektion werden
wir all
diese hartcodierten Werte sammeln und sie in einer
Umgebungsdatei Um es in dieser Lektion zusammenzufassen Wir haben eine neue Slack-App erstellt und
eingehende Webhooks aktiviert Und nachdem wir einen Kanal ausgewählt hatten
, dem wir eine Nachricht senden wollten, generierte
Slack eine URL
, an die wir posten können
, um die Nachricht letztendlich an diesen Kanal weiterzuleiten . Zurück in unserem G-Code haben wir
eine kurze Nachricht zum Senden von
Slack geschrieben, eine kurze Nachricht zum Senden von
Slack dann verwenden können, um
das, was wir aus der Allergie-API analysiert haben,
weiterzuleiten was wir aus der Allergie-API analysiert haben,
weiterzuleiten In der nächsten Lektion kombinieren
wir alle Funktionen, die wir in Main Dot Go
geschrieben haben, und dann sind wir bereit, unsere Anwendung
zum ersten Mal auszuführen
11. Abschluss des Cron-Jobs: letzten Lektion haben wir eine Slack-App
und diese Dienstprogrammfunktion zum Senden von Nachrichten
an Slack
erstellt und diese Dienstprogrammfunktion zum Senden von Nachrichten
an Slack die
Nachrichten, die in unseren
Allergie-API-Funktionen
generiert wurden, tatsächlich an Slack gesendet werden können in unseren
Allergie-API-Funktionen
generiert wurden In dieser Lektion werden wir
endlich
all diese Funktionen kombinieren , die
wir in Main Dot Go geschrieben haben In dieser Cron-Funktion rufe
ich also unsere
stündlichen G-Ladedaten auf, rufe
aktuelle Diagrammdaten ab und leite diese kombinierte
Nachricht
dann an Slack weiter Wir haben also unsere
durchschnittliche Tagesnachricht. Und das kommt von
der Allergie-API. Holen Sie sich stündliche Ladedaten. Wenn der Fehler nicht gleich 0 ist, wir in Panik Und wir werden auch den
historischen Durchschnitt ermitteln. Und wenn die Luft
nicht heiß ist, geraten wir ebenfalls in Panik. Und dann
wird die eigentliche
Slack-Nachricht, die wir senden , diese
beiden Nachrichten kombinieren und wir fügen einfach ein neues
Zeilenzeichen zwischen die Mit dieser Kombination können wir
unsere Funktion Slack-Nachricht senden
mit dieser Slack-Nachricht aufrufen unsere Funktion Slack-Nachricht senden
mit dieser Slack-Nachricht Und auch hier gilt: Wenn der
Fehler nicht gleich NULL ist, geraten wir bei Utils in Panik. Kann das importieren. Und vorerst werde
ich mich zum Debuggen
abmelden, werde
ich mich zum Debuggen
abmelden dass wir die Slack-Nachricht erfolgreich gesendet haben, und wir werden die
eigentliche Slack-Nachricht hinzufügen Das können wir speichern, und wir
sollten startklar sein. Um einen kurzen Überblick über
diese Lektion zu erhalten, wir endlich zu unserer
Hauptdatei zurückgekehrt und haben die Option
Stündliche Lastdaten abrufen und
auch aktuelle
G-Diagrammdaten aufgerufen , um
sowohl den Tagesdurchschnitt als auch den
historischen Durchschnittswert anzuzeigen Wir haben diese
mit einer neuen Zeile kombiniert und dann unsere Funktion Neue Slack-Nachricht
senden aufgerufen, wodurch letztendlich
der volle Funktionsablauf
unserer Anwendung vervollständigt der volle Funktionsablauf
unserer In der nächsten Lektion werden
wir
die Cron-Job-Zeit so ändern, dass sie
mehr oder weniger sofort ausgelöst wird, und dann werden wir
unsere Anwendung ausführen
12. Ausführen der Anwendung: In der letzten Lektion haben wir den Hauptteil
der Funktion
fertiggestellt , die tatsächlich zu unserer angegebenen Cron-Zeit
ausgelöst wird zu unserer angegebenen Cron-Zeit
ausgelöst Da wir nun bereit sind, unsere Anwendung
tatsächlich auszuführen, sollten
wir sie auf
die nächste Stunde und
Minute aktualisieren , damit wir schnell
sehen können , wie der Cron-Job
ausgelöst wird, und wir können den eigentlichen Hauptteil
hier
testen , um zu sehen, ob
alles funktioniert der aktuellen
Aufnahmezeit ist es also 1209, also werde ich
das auf 1210 erhöhen, und dann können wir unsere Funktion
mit go run main dot go
aufrufen mit go run main dot go Und wir sollten damit rechnen, dass genau
gegen 1210 Uhr
diese APIs aufgerufen und
unsere Slack-Nachricht gesendet wird diese APIs aufgerufen und
unsere Slack-Nachricht Wir sehen also tatsächlich nur
ein Häkchen nach 1210. Wir erhalten die folgende
Slack-Nachricht, die gesendet wurde. Die durchschnittliche
Pollenbelastung für heute ist eins, und historisch gesehen liegt die durchschnittliche Pollenbelastung für heute bei zwei Wir können auch
hier in unserer Slack-App sehen , dass wir tatsächlich genau
dieselbe Nachricht erhalten Unsere Anwendung funktioniert also
genau so, wie wir es erwarten. Bisher entspricht das, was wir
in diesem Kurs entwickelt haben den technischen Anforderungen
, die wir
in Bezug auf den Ablauf
und die Funktionsweise der App festgelegt haben . Sie ruft die Daten von der API ab, konvertiert
sie in eine für
Menschen lesbare Zeichenfolge und sendet diese
Nachricht dann über Slack Es gibt jedoch noch
viele Optimierungen, die wir
vornehmen können , um diese Anwendung eher zu
einer Anwendung für Unternehmen zu machen . In den kommenden Lektionen werden
wir uns also mit Dingen
wie dem Entfernen
dieser Zeichenketten und dem Einfügen
in eine Umgebung befassen , sowie mit Dingen,
die eigentlich einer
Umgebungsdatei wie
der Slack-URL und auch dem
Endpunkt der Allergie-API überlassen
werden sollten einer
Umgebungsdatei wie
der Slack-URL und auch dem
Endpunkt der Allergie-API überlassen
werden der Slack-URL und auch dem
Endpunkt der Allergie-API Sobald wir das getan haben, werden wir uns mit dem
Testen und dann
sogar der Implementierung einer
automatisierten CICD-Pipeline befassen sogar der Implementierung einer
automatisierten CICD-Pipeline
13. Schreibtests: letzten Lektion haben wir
unsere Anwendung ausgeführt und festgestellt, dass tatsächlich alles wie
erwartet funktioniert. Nun, das ist alles in Ordnung und gut,
aber was ist, wenn sich die API ändert oder etwas Seltsames
in unserer Anwendung passiert , das
dazu führt, dass sie kaputt geht? Wir
möchten wahrscheinlich wissen, ob eine
unserer Funktionen
defekt ist, ohne die Anwendung
in einer kompletten
Produktionsumgebung ausführen
zu müssen die Anwendung
in einer kompletten
Produktionsumgebung ausführen
zu . In dieser Lektion werden wir also
Tests für jede der
Funktionen schreiben , die wir geschrieben haben. Insbesondere die Funktion
Slack-Nachricht senden und auch die beiden Funktionen
innerhalb der Allergie-API,
das Abrufen stündlicher Ladedaten und
das Abrufen aktueller Diagrammdaten Wir werden nicht explizit
einen Test für meine HTTP-Anfrage schreiben da diese
Funktion tatsächlich von den anderen drei
aufgerufen wird , für
die wir Tests schreiben werden Wenn wir also per Proxy
einen Test für diese
drei Funktionen schreiben , wir im Gegenzug auch testen
wir im Gegenzug auch
per Proxy die Funktion
make HTP request Um mit dem
Schreiben unserer Tests zu beginnen, erstellen
wir einen Ordner
namens Tests Und ich erstelle zwei Dateien, eine für jedes
der Module oder Funktionen
, die wir testen werden. Also werden wir
unseren Allergie-API-Test durchführen und wir werden auch unseren Test „Slack-Nachricht
senden“ durchführen Und Anmerkung vier: Gehen Sie dazu über, diese Dateien
als tatsächliche Tests zu erkennen Sie müssen mit dem Unterstrich und
dem Suffix „
Testpunkt go“ enden Unterstrich und
dem Suffix „
Testpunkt go In jedem von ihnen ist
dies also unser Pakettest. Wir wissen, dass wir das Testmodul
benötigen werden, das eingebaute Testmodul von G. Und auch für
den Funktionsnamen
gibt es eine Regel, dass der Name mit Test beginnen
muss. Also brauchen wir hier sowohl das
Unterstrich-Testsuffix als auch
den Funktionsnamen, der mit dem Wort
test for go in Großbuchstaben
beginnt, um sowohl die
Datei als auch die Funktionen
in den Dateien vollständig zu
erkennen ,
damit es sich um einen Deshalb nenne ich
es hier Test Allergy API, und wir müssen
einen Zeiger auf dieses
Testmodul übergeben einen Zeiger auf dieses Lassen Sie es vorerst leer
und machen Sie dasselbe hier. Für unseren Slack-Nachrichtentest sind
dies Pakettests Importiere das Testmodul. Und ich nenne diesen Test Slack-Nachricht
senden und wir geben einen Zeiger
auf dieses Testmodul Um nun unsere Funktionen tatsächlich zu
testen, rufen
wir die Funktionen für
stündliche G-Ladedaten und
Diagrammdaten Und jetzt rufen wir unsere Funktion so auf, wie wir es
an jeder anderen Stelle in unserem Code tun würden. Also nenne ich das zuerst „Stündliche Ladedaten
abrufen“, und dann werden wir
verschiedene Überprüfungen
des Fehlers und der Meldung durchführen , um unseren Test abzuschließen. Wenn der Fehler also nicht neu ist, wollen wir
die Funktion T dot f verwenden,
und wir können sagen, dass beim
Abrufen der stündlichen Ladedaten ein Fehler aufgetreten ist. Wir können den tatsächlichen Fehler weitergeben. Sie sollten auch überprüfen
, ob die Nachricht Null lautet. Das ist auch ein Fehlerfall. Und in diesem Fall sagen
wir einfach Fehler beim
Abrufen der stündlichen Ladedaten. Die Nachricht ist NIL und wir können auch überprüfen, ob die Nachricht
selbst eine leere Zeichenfolge ist. Das ist wahrscheinlich auch kein sehr gutes Ergebnis
unserer Funktion. Also Fehler beim Abrufen der
stündlichen Ladedaten. Die Nachricht ist leer. Und fast dasselbe gilt für das
Abrufen aktueller Diagrammdaten. Habe unsere Nachricht und unseren
Fehler und die gleichen Prüfungen erhalten. Wenn der Fehler also nicht Null ist,
kann ich ihn tatsächlich kopieren. Achte nur darauf,
die Nachricht hier zu ändern. Es ist also klar, wenn
wir unsere Tests durchführen. Wir werden auch überprüfen, ob die Nachricht Null oder
die Nachricht leer ist, und ich werde einfach diese stündliche Ladezeichenfolge
durch aktuelle Diagrammdaten
ersetzen. Im Test „
Slack-Nachricht senden von dieser Util-Funktion nur ein Fehler zurückgegeben, und ich rufe einfach
die Option Slack-Nachricht
mit Testnachricht senden auf die Option Slack-Nachricht
mit Testnachricht senden Wenn der Fehler
nicht gleich Null ist, sagen wir Fehler beim
Senden der Slack-Nachricht und geben
den eigentlichen Fehler ein.
Jetzt verwenden wir den integrierten Befehl go test,
um Deshalb gebe ich gerne ein paar
Flaggen weiter, wenn ich meinen Test durchführe. Der erste ist P, was die Anzahl der
parallelen Tests auf eins setzt. Mit anderen Worten, das würde Ihre Tests seriell
ausführen. Und ich mag dieses Format , weil Ihre Tests
immer in derselben Reihenfolge ausgeführt werden und Sie immer ein
erwartetes Ergebnis für die
Ausführung Ihrer Tests erhalten . Mit der Zeit können Sie sich also daran
gewöhnen, wie diese Ausgabe aussieht. Wenn Sie eine sehr, sehr
große Codebasis haben, könnten
Sie natürlich erwägen, diese
zu
ändern , um mehrere
Tests parallel auszuführen. Ich füge auch das V-Flag hinzu, das eine ausführliche Ausgabe ermöglicht Und das ist nützlich, damit den Fall, dass etwas schief
geht, Sie für
den Fall, dass etwas schief
geht, mehr Ausgabe erhalten und den Fehler schneller finden
können Wir müssen auch
den Ordner übergeben , in dem wir unsere Tests ausführen
möchten. In diesem Fall ist es
der Testordner. Zusammengenommen lautet der
Befehl also, P zuerst zu
testen und dann für den Ordner Verbose
und dann für den Tests-Ordner Und wenn wir in unserer Arbeit
gut sind, diesen Befehl ausführen würden wir hoffen,
dass alle Tests erfolgreich sind,
wenn
wir Und tatsächlich haben unsere beiden Tests, die Testallergie-API und die
Testsens-Nachricht, beide bestanden, und unsere
Tests sehen gut Um es kurz zusammenzufassen :
Wir haben die Tests für die
meisten Funktionen geschrieben , die
wir in unsere Codebasis geschrieben haben Wir haben sie in den Testordner gelegt
und besprochen, wie man ein gültiger Test für G
sein kann.
G muss sowohl den
Unterstrichtest am Ende als auch den Funktionsnamen
in der Testdatei sehen , um mit einem groß geschriebenen Test zu beginnen Dann haben wir unsere Tests geschrieben. Wir haben sie mit
dem G-Testbefehl
mit einigen zusätzlichen Flags ausgeführt und festgestellt, dass alle
unsere Tests bestanden haben. In der nächsten Lektion werden
wir uns ansehen, wie wir unsere
Anwendung dockerisieren können
14. Dockerisierung der Anwendung: letzten Lektion haben wir
Tests für unsere Anwendung geschrieben
und festgestellt, dass
die Tests tatsächlich bestanden haben In dieser Lektion werden
wir uns ansehen, wie wir unsere
Anwendung dockerisieren können Da GO
zu einer einzigen Binärdatei kompiliert wird, müssen wir nicht allzu viele komplexe
Schritte ausführen,
damit unsere GO-Anwendung
in Docker reibungslos läuft Wir müssen zwei Dateien definieren, die Docker-Datei selbst
und dann die
Docker-Compose-Datei
, mit der wir unseren Container
mit einem Tool wie Docker Compose ausführen können, mit
dem wir unsere Container mit einem Tool wie Docker Compose ausführen können, mit verwalten und orchestrieren können Also werde ich
mit der Docker-Datei beginnen und sie hier
im Stammverzeichnis unseres Projekts platzieren Das ist einfach eine Docker-Datei. Und ich fange mit
dem Gang-Alpencontainer und nehme den
1,2-Golang-Container Das ist also von Golang
1.2 auf Alpine. Dann werden wir das Wd als App
definieren, und das ist eine gängige Praxis,
sodass wir keine Dateien im
eigentlichen Stammverzeichnis dieses Containers erstellen oder erstellen,
sondern die Definition
unseres eigenen Workspace wird
normalerweise nur
als App in diesem Container verwendet, und dort werden wir das eigentliche Erstellen
durchführen Dann wollen wir also
alles, was wir hier
in unserer Codebasis haben, in
diesen App-Ordner kopieren , und das ist einfach Punkt für Punkt. Dann werden wir tatsächlich unsere Anwendung
erstellen. Also machen wir Go Build O und nennen es Allergy
Cron. Um das dann,
wie erwähnt, auszuführen,
erstellt G eine einzige Binärdatei,
und wir müssen nur diese wie erwähnt, auszuführen,
erstellt G eine einzige Binärdatei, Binärdatei
ausführen Dieses Dockerfile
würde also schon ausreichen, um einen Container zu erstellen, den wir erstellen und dann ausführen
können, aber um ihn
mit Docker Compose benutzerfreundlicher zu gestalten, sodass wir ihn sofort
mit Docker Compose ausführen können, definieren
wir auch einen Docker
Compose-Punkt Yamofle. Also genau wie das Dockerfile werde
ich hier direkt in das Stammverzeichnis den Docker Compose Dot
Yamofle einfügen und die neueste Version für Docker Compose werde
ich hier direkt in das Stammverzeichnis den Docker Compose Dot
Yamofle einfügen und
die neueste Version für Docker Compose verwenden. Das ist 3.9. Dann
definieren wir unsere Dienstleistungen. Wir haben den Allergie-Cron
, der unser einziger Service ist Und dann definieren wir
den Build-Kontext. Es ist einfach hier, was bedeutet, dass
Docker Compose direkt in
unserem Stammverzeichnis
nach dieser Docker-Datei sucht direkt in
unserem Stammverzeichnis
nach dieser Docker-Datei und
diese Dockerfile verwendet Dann können wir auch
die Neustart-Richtlinie definieren, und ich werde sie
mit einem Stop-less-Stop-Wert definieren Das heißt, wenn unser Container aus irgendeinem Grund
abstürzt, erkennt
Docker das und
startet den Container für uns neu Um nun zu sehen, ob wir in diesen beiden Dateien alles
richtig
konfiguriert
haben, können wir unseren Container erstellen und
dann ausführen Um
den Container zu erstellen, verwende
ich zunächst den Befehl
Docker Compose, und wir wollen bauen Und da es das
allererste Mal ist, dass wir unsere
Anwendung quasi
als doppelte Sicherheitsüberprüfung erstellen , werde
ich auch keinen Fall angeben,
und das bedeutet, dass
alles, was zum Erstellen
des Containers benötigt wird, frisch aus
dem Internet heruntergeladen Wir werden hier
keine lokalen Dateien verwenden. Sobald das erledigt ist,
können wir auch Docker Compose ausführen. Und in diesem Fall wollen wir aufstehen und ich übergebe auch das D-Flag, das ist das separate Flag, und das bedeutet, dass
Docker
unseren Container im Hintergrund startet unseren Container im Hintergrund und uns unser Terminal zurückgibt Wenn wir dieses D-Flag nicht übergeben, die Protokolle
unseres Containers direkt
angehängt,
und wenn
wir unseres Containers direkt
angehängt, die Terminalumgebung verlassen oder verlassen , wird
auch unser Container verlassen Also übergeben wir dieses D, damit der Container im Hintergrund
betriebsbereit bleibt Wenn also alles richtig funktioniert, sollten
wir hier am Ende der
gesamten Build-Ausgabe ein schönes Grün
sehen . Und wir können mit
dem Befehl
Docker PsA überprüfen, ob der Container tatsächlich läuft Und wir sehen tatsächlich, dass
unser Allergie-Cron läuft, der
vor 18 Sekunden nach 15 Sekunden erzeugt wurde Und so haben wir
erfolgreich unsere Go-Anwendung
in einem Docker-Container erstellt und ausgeführt Als kurze Zusammenfassung definieren wir
sowohl eine Docker-Datei als auch eine
Docker-Compose-Datei , damit
unsere Anwendung
mit dem Befehl Docker Compose ausgeführt werden kann mit dem Wir haben beide unsere Anwendung erstellt und dann im Hintergrund
ausgeführt, und wir sehen, dass
unsere Anwendung tatsächlich in
ihrem Container auf
unserem lokalen System ausgeführt wird ihrem Container auf In der nächsten Lektion werden
wir uns kurz damit befassen, unseren Container
mit minimaler Ausfallzeit
neu zu starten
15. Neustart des Containers mit minimaler Ausfallzeit: In der letzten Lektion haben wir
die beiden Konfigurationsdateien erstellt, die
erforderlich sind, um sowohl
einen Docker-Container
selbst zu erstellen als auch diesen Docker-Container dann mit Docker Compose
auszuführen In dieser Lektion werden wir uns
kurz ansehen, wie wir einen laufenden Container
mit minimaler Ausfallzeit
ersetzen können einen laufenden Container
mit minimaler Ausfallzeit
ersetzen Und tatsächlich kommt es darauf an, die Anwendung
neu zu erstellen
und zu ersetzen Und wieder wird
dieser Docker Compose-Befehl verwendet. Wir werden
wieder ohne Cache bauen. Und geben Sie den Befehl up losgelöst und vor allem
mit Force Recreate aus. Wir geben dieses Flag weiter, damit
wir sicher sind, dass Docker den
vorhandenen Container
immer durch den neu erstellten ersetzt den neu erstellten Wenn wir also diesen Befehl ausgeben, sehen
wir erneut, dass er abgeschlossen ist Und wenn ich unsere
Container mit PSA überprüfe, sehen
wir tatsächlich, dass die neue Version vor 10 Sekunden nach 7 Sekunden
erstellt wurde Also wurde sie einfach ersetzt. Nun, für eine
Cron-Job-Anwendung wie diese ist
dieser Befehl wahrscheinlich
ausreichend für Ihre Bedürfnisse Denken Sie jedoch daran, dass dies
keine Methode ohne Ausfallzeiten ist. Dies ist nur eine Methode mit minimalen
Ausfallzeiten. Für
die kurzen Momente
, die
Docker benötigt, um den Container auszutauschen, hätten Sie Ausfallzeiten die kurzen Momente
, die
Docker benötigt, um den Container auszutauschen, Bei einer
Cron-Job-Anwendung wie dieser ist
es wichtig, daran zu denken,
diesen Container nicht zu dem Zeitpunkt
auszutauschen , zu dem Ihr Crown-Job Wenn Sie etwas
Komplizierteres tun , das wirklich keine Ausfallzeiten erfordert, müssten
Sie etwas
Komplexeres
tun , z. B.
mehrere Container erstellen, Load
Balancer
wechseln und so weiter Diese Art von Strategie
fällt jedoch nicht in den
Rahmen dieses Kurses Zusammenfassend lässt sich jedoch sagen, dass
diese Methode letztlich wenn Sie wissen, was Ihre
App tut und wann es sicher ist Container zu
ersetzen für viele Arten
von Anwendungen ziemlich
gut funktioniert,
wenn Sie wissen, was Ihre
App tut und wann es sicher ist, diesen . In der nächsten Lektion werden wir uns
wieder mit dem Programmieren und der Verbesserung der Nachricht befassen
, die wir über Slack versenden
16. Hinzufügen ausgefallener Formatierung zu Slack-Nachrichten: In der letzten Lektion haben wir kurz
besprochen, wie wir einen Container
mit minimaler Ausfallzeit neu aufbauen
und ersetzen können einen Container
mit minimaler Ausfallzeit neu aufbauen
und ersetzen In dieser Lektion werden
wir uns wieder mit
etwas Code befassen und uns ansehen, wie wir die Formatierung
der von uns versendeten Slack-Nachrichten
verbessern können die Formatierung
der von uns versendeten Slack-Nachrichten
verbessern der von uns versendeten Slack-Nachrichten Wenn wir also in unsere
Allergie-API-Datei springen, können
wir uns daran erinnern, dass wir
zwei ziemlich einfache Slack-Nachrichten senden zwei ziemlich einfache Slack-Nachrichten Es könnte nett sein, etwas mehr Farbe und vielleicht
sogar ein paar Emojis hinzuzufügen , damit die Stimmung
unserer Botschaft schneller und interessanter
dargestellt werden kann schneller und interessanter
dargestellt Wir werden also diese ursprüngliche Nachricht
ändern. Wir werden die
historische Botschaft so lassen, wie sie ist. Aber für die
tatsächlichen Echtzeitdaten werden
wir die
Formatierung dieser Nachricht verbessern. Also werde
ich hier unten eine neue Funktion
namens Allergiedaten formatieren definieren . Und es ist
hier nur eine Funktion in
Kleinbuchstaben , weil wir sie nicht exportieren
müssen Es wird nur
in dieser Datei verwendet. Ich gebe die skalierte Durchschnittslast weiter
,
die wir haben, das ist eine Ganzzahl, und wir
geben eine Zeichenfolge zurück Was wir derzeit haben, ist unsere formatierte Nachricht
und sie sieht so aus Die durchschnittliche Pollenbelastung für heute und diese
skalierte Durchschnittsbelastung geben wir weiter Aber wir werden dieser Nachricht
sowohl ein Präfix als auch ein
Suffix hinzufügen, um
sie etwas schicker zu gestalten Wir können das mit einem
Schaltergehäuse machen und ich
werde die skalierte Durchschnittslast einschalten Und zum einen ist das ein eher
moderater Fall. Also stellen wir ihm
dieses gelbe
Kreis-Emoji voran und setzen Okay, dann ein Leerzeichen und dann die
bestehende Nachricht, die wir haben Und wir möchten vielleicht eine Obergrenze setzen,
ob es sich um ein niedriges
oder ein moderates Niveau Falls es dann zwei sind, können
wir die Farbe auf eine Art orangefarbene
Warnfarbe erhöhen und mit
unserer formatierten Nachricht
so etwas wie Vorsicht noch einmal sagen mit
unserer formatierten Nachricht
so etwas wie Vorsicht noch einmal Und in
diesem Fall ist es mittelgroß und wir beenden es mit dem orangefarbenen
Emoji Dann vier oder drei.
Wir setzen Rot und mit
dieser formatierten Nachricht erneut eine Warnung ein und weisen darauf hin , dass der Wert hoch ist
und mit dem roten Emoji endet Wenn es nun die höchste
Stufe ist, also vier, dann werden wir drei
dieser roten Emojis
platzieren und mit unserer
formatierten Nachricht eine Warnung auslösen Und
diese höheren Fälle hier besonders hervorheben. Und wir schließen das auch
mit drei dieser roten Emogi-Kreise ab Wenn der Fall dann
Null ist, fallen wir durch nehmen auch die
Standardeinstellung
und geben
diesen grünen Emogi zurück und sagen dann nett mit der formatierten
Nachricht, der Nur um die Interpunktion hier
einheitlich zu machen und wir können die Klammer unseres Schaltergehäuses
schließen Anstatt
unser Format hier zu verwenden, werden
wir das jetzt loswerden, da es in
unserer neuen Funktion bereits ausgefallen ist . Wir rufen
die Funktion „Allergiedaten formatieren und geben diese
skalierte Durchschnittslast Wenn wir das jetzt speichern,
können wir unsere Anwendung testen. Im Moment sind es also 318. Ich werde
unseren Cron auf 319 erhöhen. Ich glaube, das werden 15
und 19 sein. Und wir können den Haupt-Dotco starten. Und tatsächlich, kurz nach 319 bekommen
wir hier eine Kopie von dem, was wir über
Slack geschickt haben , zusammen mit unserer netten neuen Und heute ist es ziemlich
heiß und trocken, also muss ich ein bisschen
aufpassen Das Niveau ist heute hoch. Als Rückblick auf diese Lektion haben wir uns unsere
Allergie-API-Datei angesehen
und die
erste Nachricht, die wir
versenden, durch diese
Allergiedatenfunktion im neuen Format ersetzt . Und wir haben hier
zusätzlichen Text
sowie einige Emojis hinzugefügt, die die Stimmung
der Informationen, die wir versenden
, besser widerspiegeln Stimmung
der Informationen, die wir versenden
, Und insgesamt finde ich, dass es ziemlich gut
aussieht und es
einfacher ist ,
die Art der
Nachricht sofort zu bestimmen die Art der
Nachricht sofort Es sind also nur noch
wenige Lektionen übrig. In der nächsten Lektion werden
wir uns damit befassen,
all diese hartcodierten Werte wie
die URL und die Cron-Zeitzone
sowie das Cron-Intervall zu verschieben all diese hartcodierten Werte wie die URL und die Cron-Zeitzone sowie das Cron-Intervall und sie in einer M-Datei abzulegen Sobald wir das getan und
sichergestellt haben, dass unsere Anwendung
noch funktioniert, werden
wir
CircleCI verwenden, um
eine CICD-Pipeline zu erstellen , die unsere
Anwendung
automatisch testet, erstellt und auf Docker Hub bereitstellt
17. Verschieben von Geheimnissen und fest codierten Werten in eine env-Datei: letzten Lektion haben wir diese Funktion zum
Formatieren von Allergie-Daten geschrieben , um die Formatierung zu verbessern und die Slack-Nachrichten
etwas bunter zu
gestalten In dieser Lektion nehmen
wir all diese hartcodierten Werte,
wie die API-URL, sowie den Cron-Speicherort
und den Cron-Zeitplan und fügen sie
in eine Umgebungsdatei ein Zu Beginn erstelle
ich also eine N-Datei, also Punkt N. Und sofort wollen
wir
eine Get Ignore-Datei erstellen und
diese N-Datei zur G-Ignoriere-Datei hinzufügen Dies ist eine gängige Praxis, da Sie in der Regel
mindestens einen oder möglicherweise
mehrere geheime Werte haben mindestens einen oder möglicherweise
mehrere geheime Werte , die Sie nicht
in Ihr Git-Repository einchecken möchten. Also erstelle ich dieses Get Ignore und füge einfach
die M-Datei hinzu. Also, was haben wir eigentlich für unsere Umgebungsvariablen? Wir haben hier die
Allergie-API-Stamm-URL. Wir haben auch unsere
Slack-Webhook-URL und wir haben unsere Cron-Zeitzone sowie die Zeitplanzeichenfolge Also fügen wir all diese
zu unserer Umgebungsdatei hinzu. Wir haben also unsere
Slack-Webhook-URL. Kann das einfügen Ich habe unser
Allergie-API-URL-Stammverzeichnis, ich nenne es. Das ist dieser Typ. Ich habe
unsere Cron-Zeitzone Das ist hier. Und der
Cron-Zeitplan. Und das ist dieser Und solange ich hier bin,
setze ich den auf den
ursprünglichen Wert um 8:00 Uhr
zurück, den wir hatten. ursprünglichen Wert um 8:00 Uhr
zurück, den wir hatten Damit die
Gang-Laufzeit diese Werte nun tatsächlich sieht oder
in der Umgebung hat, müssen
wir sicherstellen, dass
diese Umgebungsdatei in die Runtime geladen
wird Dazu können wir das
beliebte Johogo Dot Nv-Paket verwenden. Das sind also github.com, Joho und Go Dot V. Und das
können wir hier abrufen Und ganz oben in
unserer Hauptfunktion können
wir das laden Das gibt einen Fehler zurück und es heißt einfach Punkt N Punkt laden. Und wir müssen keine Parameter
übergeben. Es sucht standardmäßig
nach unserer Punkt-N-Datei. Natürlich wollen wir
überprüfen, ob der Fehler nicht
Null ist , dann werden wir hier
eine fatale Meldung erhalten. Fehler beim Laden der Datei. Jetzt müssen wir tatsächlich
den Wert dieser
Umgebungsvariablen übernehmen . Das kann
mit dem Aufruf s.gn geschehen. Also haben wir sie
als allererstes in unsere Hauptdatei geladen, und sie sollten
dann in unserer Umgebung verfügbar sein Wir haben also OS GNV. Und das wird
die Cron-Zeitzone sein. Und für diesen haben
wir OS GNN. Das ist Cron Schedule. Und
auch hier in der API OSG N musst du N musst du es, glaube
ich, unten oder oben
und auch in unserer Slack-Funktion hinzufügen glaube
ich, unten oder oben und auch in unserer Slack-Funktion Das ist OSG N. Und unsere
Slack-Webhook-URL. Jetzt müssen wir auch dieses Laden der Umgebung
in unseren Test aufnehmen Da wir den Code nun
überarbeitet haben,
erwartet der Code, der
unter diesen Tests ausgeführt wird, auch der
unter diesen Tests ausgeführt wird, auch diese
Umgebungsvariablen Im
Test ist es also etwas anders , weil wir uns
nicht im Stammverzeichnis befinden, wir können nicht einfach
den Standard-Load aufrufen, sondern wir müssen
den Pfad explizit zurück an die
Umgebung im Stammverzeichnis übergeben den Pfad explizit zurück an die
Umgebung im Ich kopiere das in den
Anfang unserer beiden Tests. Und wir müssen diesen Pfad nur
explizit angeben. Und importiere hier sowohl das
Godot-End- als auch das Log-Paket. Und das Gleiche gilt für
den anderen Test. Importiere diese. Und wir haben jetzt
schon Fehler definiert, also sind es nur die normalen Gleichungen Und das sollte für
die Tests reichen. Um es schnell zu überprüfen, haben wir eine Punkt-N-Datei für
all die verschiedenen
hartcodierten Werte erstellt all die verschiedenen
hartcodierten Werte , die wir in unserer Anwendung verwendet
haben. Wir haben auch eine
Datei mit dem Befehl „Get Ignore“ erstellt, um sicherzugehen, dass wir diesen Punkt N
ignorieren, da
es in der Tat Geheimnisse gibt In diesem Fall
ist diese Webhook-URL am wichtigsten. Wir wollen nicht, dass irgendjemand
darauf ankommt,
sonst könnte er
auf unserem Kanal posten Wir haben unseren
Code durchgesehen und
diese fest codierten Werte
durch ihre jeweiligen
Umgebungsnamen ersetzt diese fest codierten Werte . Und wir haben unseren Tests auch
die Möglichkeit hinzugefügt , die
Umgebungsvariable zu laden. Im Fall unseres Tests wird also explizit
der Pfad zu unserem Ende übergeben, das sich in den höheren Ordnern befindet. Wir verwenden also die
Unix-Notation mit Punkten ,
um
von unserem Testordner zu diesem Stammordner zu gelangen. Letztlich ist das
ein sehr schönes Muster ,
denn direkt in dieser M-Datei siehst
du sofort einige
der wichtigsten Schlüsselwerte
für die Funktionsweise unserer App, nämlich die
Zeitzone und den Zeitplan, aber auch wenn sich die URL ändern sollte oder wenn du einen anderen Anbieter
suchst, könntest
du
diese URL ändern und
einen anderen Client für diese API schreiben . Wenn
du zum Beispiel
deine Webhook-URL auf
einen anderen Kanal ändern würdest deine Webhook-URL oder
wenn sich das Team ändert, könntest
du diese auch schnell hier
ersetzen und dann wissen, dass sie in deiner Codebasis
verwendet wird ,
wo auch immer das sein mag. Jetzt, wo wir unsere Anwendung
angedockt haben, haben
wir
die Slack-Nachrichten bereinigt,
und wir haben auch hartcodierte haben
wir
die Slack-Nachrichten bereinigt, Werte
bereinigt In der
nächsten Lektion ist es endlich an der Zeit,
eine
vollständige CICD-Pipeline zu erstellen eine
vollständige CICD-Pipeline unsere Anwendung
zu erstellen und sie auf Docker Hub
bereitzustellen Und wir werden den Kurs endlich
abschließen,
indem wir den neu
erstellten Container
aus Docker Hub ziehen und ihn
ein letztes Mal ausführen , um sicherzustellen, dass
alles
18. Erstellen einer CI CD-Pipeline mit Circle CI: In der letzten Lektion haben wir eine Umgebungsdatei
zum Speichern aller hartcodierten
Werte und Geheimnisse in
unserer gesamten Anwendung
erstellt zum Speichern aller hartcodierten
Werte und Geheimnisse in
unserer gesamten und
diese hartcodierten Werte
durch die Namen
der Umgebungsvariablen
in der Anwendung ersetzt durch die Namen
der . Und das war wirklich der letzte
Schritt für uns, um bereit zu sein, die Art und Weise, wie wir unseren Container bauen
, zu
verpacken und zu automatisieren. In dieser Lektion werden
wir also
eine vollständige CI-CD-Pipeline erstellen , die erstellt und dann unsere Anwendung
erstellt und dann mit den von uns geschriebenen
Tests testet. Wenn diese Tests erfolgreich sind, wird unser
Container bereitgestellt oder auf den Docker Hub hochgeladen Am Ende werden wir diesen Container
abrufen und ihn als letzten Test
ausführen
, um sicherzustellen, dass alles funktioniert Um mit CircleCI zu beginnen, müssen
wir also zuerst einen
Ordner mit dem Namen Circle CI und in diesem Ordner
eine Config-Punkt-Yaml-Datei Das erste, was
Sie nun
in Ihrer Config-Punkt-Yamal-Datei tun müssen , ist, die Version bereitzustellen, ähnlich wie bei Docker Compose Derzeit ist diese Version oder
die neueste Version 2.1. Und wir werden auch eine Kugel auflisten. Nun, Orbs sind vorkonfigurierte Befehle oder Jobs, die
sehr häufig ausgeführt werden Sie
haben zum Beispiel eine Knotenkugel. Sie haben einen Slack-Orb, und das spart
Ihnen einfach Zeit, anstatt explizite
Bash-Befehle zu
schreiben, um Aufgaben zu erledigen Sie haben Dinge vorkonfiguriert Senden Sie zum Beispiel eine Slack-Nachricht, und Sie müssen nur die Zeichenfolge
übergeben Du musst diese
Curl-Anweisung oder
ähnliches nicht ausgeben Curl-Anweisung oder
ähnliches In unserem Fall benötigen
wir nur eine Kugel für den Docker-Hub, und das kann
durch Angabe von Docker erreicht werden, und wir nehmen die neueste
Version dieser Docker-Kugel, nämlich Jetzt
sind nur noch zwei Hauptteile einer
Config-Punkt-Yaml-Datei Es gibt sowohl Jobs als
auch Workflows. Jobs sind verschiedene
Schritte, die Sie ein- oder mehrmals
in Ihren Workflows
verwenden können . Sie könnten sie sich also
als einzelne Bausteine vorstellen , und Workflows
kombinieren und festlegen in welcher Reihenfolge und wie
diese Jobs ausgeführt werden sollen. In der Regel werden Workflows also weiter oben in
der Konfiguration Dot Yam
aufgeführt Aber da wir hier
Schritt für Schritt
vorgehen, schreiben wir zuerst die Jobs und danach
die Workflows einer schrittweisen Perspektive ist das etwas sinnvoller Aus einer schrittweisen Perspektive ist das etwas sinnvoller. Also werden wir damit beginnen, unsere Jobs zu
definieren. Und im Moment haben wir wirklich
nur eine Aufgabe, und das ist,
unsere Bewerbung zu testen. Also nenne ich es einfach Test, wir müssen
ein Arbeitsverzeichnis angeben. Und in der Circle CI-Welt ist
dieses Repo der besondere Signifikator für das
lokale Und wir werden ein Docker-Image
verwenden, und wir werden das GO-Image
verwenden Dann können wir
unsere Schritte definieren, was wir im Rahmen dieses Jobs tatsächlich
tun möchten Zuerst
checken
wir natürlich den Code aus und
können dann unsere Go-Sum-Datei zwischenspeichern. Dadurch werden nachfolgende
Builds schneller. Und wir werden einige überprüfen unserer Gos
überprüfen und auch
Abhängigkeiten davon installieren. Wir müssen GGet ausgeben und dann speichern
wir den Cache. den
Fall, dass wir
später neue Pakete installieren oder deren Versionen ändern, wird sich
das genau in
diesem Schlüssel
widerspiegeln , den wir für unseren Cache
definiert haben Und wir müssen auch definieren, in
welchem Pfad sich das befindet. Das meiste davon wurde also
einem Beispiel entnommen , das CircleCI auf
seiner Website für die empfohlenen
und bewährten Methoden
für eine Go-Anwendung hat seiner Website für die empfohlenen
und bewährten Methoden
für eine Go-Anwendung Und ich werde in den Unterrichtsressourcen einen Link
dazu einfügen. Jetzt müssen wir auch
unsere Umgebungsdatei erstellen weil wir wissen, dass unsere App ohne diese
Umgebungsvariablen nicht
ausgeführt werden kann . Also werden wir hier einen weiteren
Ausführungsschritt machen. Der Name lautet Create Dot N File. Der Befehl kann die Pipe
verwenden, um mehrere Schritte oder
mehrere Befehle auszuführen. Wir werden zuerst diese Datei
erstellen. Dann werden wir Echo verwenden, um alle
Umgebungsvariablen
wiederzugeben, die wir benötigen. Um in die
CircleCI-Umgebung zu gelangen, verwenden
wir diese Syntax, die Klammern mit
dem Dollarzeichen, und wir nehmen einfach dieselben Namen
,
die wir in unserer Anwendung haben Wir werden
später in der CircleCI-Benutzeroberfläche sehen, wie diese definiert werden. Und wir werden sie einfach an diese neue Datei
anhängen. Also werde ich
das ein paar Mal kopieren
und wir wissen, dass wir
den Allergie-API-URL-Stamm haben Wir haben auch unsere Cron-Zeitzone und wir haben auch diese
Cron-Zeitplanzeichenfolge und wenn diese vollständig ist
, werden wir Tests
durchführen. Also nenne ich das einfach
Run-Tests. Und der Befehl, den wir
aus der vorherigen
Lektion kennen , lautet go test. Wir setzen dieses parallele Flag
und auch das Verbose-Flag, und das wollen wir
im Tests-Ordner ausführen Wir haben also unseren
Einzeljob-Test definiert, und jetzt müssen wir die Workflows
definieren Das normale Muster besteht also,
wie ich bereits erwähnt habe,
darin, dass die Workflows
über die Jobs hinausgehen,
also springen wir wieder nach oben und spezifizieren
auch unsere Workflows. Wir
haben also auch nur einen Workflow, und das wird der
Produktionsworkflow sein, und wir müssen die Jobs spezifizieren. Und wir haben unseren Testjob, und wir werden auch nach der Branche
filtern. Und wir wollen nur
den Hauptzweig. Und dann wird der zweite Job, den wir wollen, diese Docker-Kugel hier nutzen Und das wird Docker
Publish sein. Und das Image wird
sowohl unser Benutzername als auch unser Repo-Name sein , den
wir
später
zusammen mit unseren anderen Umgebungsvariablen auch in der CircleCI-WebUI definieren später
zusammen mit unseren anderen Umgebungsvariablen auch in der CircleCI-WebUI zusammen Dazu kommen wir in ein paar Augenblicken. Jetzt müssen wir auch
die Reihenfolge dieser Jobs definieren. Wenn wir keine Reihenfolge angeben, CircleCI, werden wir sie einfach
parallel ausführen Das kann nützlich sein,
je nachdem, was Sie tun. Aber in unserem Fall möchten
wir natürlich
sicherstellen, dass diese Tests bestanden werden, bevor wir sie in unserem Container veröffentlichen
. Das geht mit
der Requires-Direktive, und wir verlangen natürlich, dass der Testjob abgeschlossen ist. Und wir wollen auch nach
dem Hauptzweig filtern. Nun, diese Datei enthält eine Menge
Yamil-Code,
und es ist nicht klar, ob wir
irgendwelche Syntaxfehler oder
Probleme haben , aber zum Glück bietet
CircleCI ein CLI-Tool, bietet
CircleCI ein CLI-Tool dem wir
diese Konfigurationsdatei überprüfen können Ich werde in den Unterrichtsressourcen
den Link zu ihrer offiziellen
Dokumentation hinzufügen den Link zu ihrer offiziellen , in der beschrieben wird, wie
Sie das installieren können Ich habe es bereits auf meinem System
installiert und die Konfiguration kann
mit CircleCI Config Validate
überprüft mit CircleCI Wir können hier sehen, dass ich vergessen habe, wie das Semikolon hier
aussieht Und ich werde den Check noch einmal durchführen, und ich habe auch ein S vergessen. Und schließlich sieht es so aus, als ob
wir hier eine gültige Konfiguration haben Also bekommen wir, dass das gültig ist. Wir können also bereits sehen, dass es sehr praktisch ist, um
Tippfehler oder Formatierungsprobleme
in unserer Konfigurationsdatei zu
finden Tippfehler oder Formatierungsprobleme
in unserer Konfigurationsdatei Jetzt, an dieser Stelle in Ihrem Code, wäre
es wahrscheinlich sinnvoll,
abzuzweigen und
einen entwickelten Zweig zu erstellen Zunächst müssen
Sie natürlich
das Git-Repository initialisiert haben und davon ausgehen
, dass Sie sich immer noch im
Haupt- oder Master-Branch befinden, dann würden Sie
natürlich Checkout B Develop ausführen und
alles in diesen Zweig Dann würden Sie
zusammenführen, wenn Sie bereit sind, zu Ihrem Haupt
- oder Master-Branch
zusammenführen, und dann
würde dieser Fall ausgelöst, es müsste der
Hauptzweig sein, sonst würde
CircleCI nichts tun Es wartet auf Commits für diesen Hauptzweig
,
wie wir Wenn Sie jedoch beispielsweise die
Master-Benennungskonvention verwendet haben, müssten
Sie diese in Master ändern, damit
CircleCI in
diesem Zweig etwas
tun kann In meinem Fall bin ich bereits hier im
kursspezifischen Repository und habe einen benutzerdefinierten Branchennamen Also werde
ich das vorerst so lassen, wie es ist, und wir werden sowohl
in die Docker Hub- als auch in die
CircleCI-Webanwendungen springen und dort konfigurieren, was wir brauchen Sie sich also in Doctor Hubb Melden Sie sich also in Doctor Hubb an oder erstellen Sie ein Konto Wenn Sie
keins haben, sind sie kostenlos. Und wir klicken hier einfach auf Repository
erstellen und ich nenne
meins Allergy Cron Wir können hier einfach auf Erstellen klicken. Und jetzt haben wir ein Repository
, in das wir pushen können. Dann gehen wir zu circleci.com und
klicken auf Und auf der Anmeldeseite hier, da sich das Repository in meinem Fall auf Github
befindet, werde ich mich mit
GitHub anmelden Wenn du dich zum Beispiel
dafür entschieden hast, Bitbucket zu
folgen , kannst
du dich mit Bitbucket anmelden Ich bin also in einer Reihe
von Organisationen tätig, aber das Repository, in dem wir
programmiert haben , befindet sich auf
meinem persönlichen Konto Also wähle ich das aus und du wirst all deine Repositorys
in deinem GitHub-Profil
sehen Und natürlich möchte ich diesen Kurs für reale
Anwendungen
machen, und wir können auf Projekt einrichten klicken Bevor CircleCI die Arc-Fig-Datei
finden kann, muss
ich zurück in
den Code gehen und diesen Also füge ich alles hinzu. Ich werde so etwas wie
CircleCI Config fertig übergeben. Ich werde darauf drängen, dass ich den Lektion
mit dem Namen
der Filiale angeben Dann sollte ich hier in der Lage sein den Zweig von Lektion 18
anzugeben, und wir sehen, dass CircleCI
sogar
unseren Code durchsucht und
die Konfiguration Yamofle findet Es ist also wirklich, wirklich
ein netter Service. Ich benutze CircleCI wirklich gerne.
Sie machen es sehr einfach In Ihrem Fall könnten Sie das also, je nachdem, wo
Sie es gepusht haben, ob Sie es in
den Entwicklungszweig, ob Sie es in den
Hauptzweig oder den
Master-Branch gepusht haben , je nachdem, wo
Sie es gepusht haben,
ob Sie es in
den Entwicklungszweig,
ob Sie es in den
Hauptzweig oder den
Master-Branch gepusht haben,
das hier angeben, und hoffentlich
findet CircleCI Ihren Konfigurationspunkt yamofLE. Sobald es das gefunden hat, können
Sie einfach Und es wird sogar versuchen, den allerersten Workflow zu
starten. Aber da der Commit für
den Zweig von Lektion 18 erfolgte , in der Konfiguration: Okay, für Lektion 18
gibt es nichts zu
tun, und es wird nur
kein Workflow angezeigt. Jetzt, wo wir unser
CircleCI-Projekt eingerichtet haben, sollten
wir all
diese
Umgebungsvariablen zur eigentlichen
CircleCI-Umgebung hinzufügen Umgebungsvariablen zur eigentlichen
CircleCI-Umgebung Um das zu tun, können wir hier
zu den
Projekteinstellungen und hier zu den Umgebungsvariablen gehen . Und wir können unsere
Schlüsselwert-Umgebungsvariablenpaare hinzufügen. Und wir wissen, dass wir
unsere Slack-Webhook-URL haben. Und wir können damit fortfahren,
alle Variablen hinzuzufügen , von denen wir
wissen, dass wir sie für
unsere Anwendung benötigen Habe Zeitzone. Ich habe den Cron-Zeitplan. Und jetzt müssen wir auch
einige für unsere Docker
Hub-Integration hinzufügen einige für unsere Docker
Hub-Integration Also müssen wir den
Docker-Benutzernamen, das Docker-Login, die eigentlich
ein und dasselbe sind,
das Docker-Passwort und
den Docker-Repo-Namen hinzufügen eigentlich
ein und dasselbe sind,
das Docker-Passwort und
den Docker-Repo-Namen In meinem Fall
ist mein Docker Hub also unser Firmenkonto Also werde ich das
sowohl für den Docker-Benutzernamen verwenden. Und auch die
Docker-Login-Umgebungsvariablen. Der Docker-Repo-Name ist
der Name, den Sie
für Ihr Repo angegeben haben Und in meinem Fall ist
das Allergy Cron. Und schließlich das
Docker-Passwort. Das werde ich hier natürlich nicht zeigen. Also haben wir jetzt alle
Umgebungsvariablen definiert ,
die wir Betrieb der CICD-Pipeline
benötigen Zurück im Code,
da
ich in meinem Fall bereits einen Hauptzweig
habe, ich in meinem Fall bereits einen Hauptzweig
habe ich nicht durcheinander bringen möchte, werde
ich einen separaten
Zweig namens Pipeline erstellen und auch diesen Zweigfilter
in der Config Dot Yam-Datei aktualisieren , damit wir die Pipeline testen können Also werde ich das einfach auf Pipeline ändern
. Und denken Sie daran, in Ihrem Fall können
Sie das
natürlich Maine
oder einem anderen Zweig überlassen, auf den Ihre
CICD-Pipeline abgefeuert werden soll Also werde ich
diesen neuen Zweig mit
G Checkout B Pipeline erstellen G Checkout B Pipeline Ich kann tatsächlich sehen, dass wir uns in
der Pipeline befinden. Ich werde alles hinzufügen. Und ich füge eine Nachricht so
etwas wie eine benutzerdefinierte
Pipeline-Verzweigung, und wir können pushen. Jetzt, zurück in CircleCI, sollten
wir sehen, dass der
Produktionsworkflow tatsächlich
gestartet wird , weil CircleCI
diesen Pipeline-Verzweigungsfilter sieht Wir können hier klicken, um unsere beiden
Jobs zu sehen. Wir haben also unseren Testjob und
unseren von Docker veröffentlichten Job. Und selbst in den
Jobs selbst können
Sie alle
Schritte und die Ausgabe sehen Es sieht also so aus, als ob unsere
Tests bestanden wurden. Dies ist das vertraute Ergebnis , das wir in
der vorherigen Lektion gesehen haben. Dann, zurück
im Workflow, geht
es natürlich weiter mit der Docker-Veröffentlichung,
und wir werden sehen, wie das läuft Sieht so aus, als ob das auch
erfolgreich war. Und tatsächlich sehen
wir auf Docker Hub, dass es vor ein paar Sekunden
veröffentlicht wurde, sodass unsere CICD-Pipeline einwandfrei
funktionierte Obwohl unser Build
und unser Workflow
zu funktionieren scheinen, würden wir, wenn wir tatsächlich
unseren Docker-Container ziehen und versuchen würden, ihn auszuführen, feststellen, dass G
sich beschwert, dass er nicht finden
kann Wir haben den Schlüsselschritt
in unserer CICD-Pipeline vergessen um diese
Umgebungsvariable zwischen diesen beiden Jobs beizubehalten ,
um diese
Umgebungsvariable zwischen diesen beiden Jobs beizubehalten. Um das hier am
Ende unseres Testjobs zu tun, können
wir diesen
Befehl persist
to workspace angeben und wir wollen angeben, dass das Stammverzeichnis hier ist,
und wir werden einfach
die Punkt-M-Datei, die wir hier
erstellen, beibehalten Und dann müssen
wir in unserem
Docker-Befehl publish angeben, dass wir ihn beim Veröffentlichen oder
Erstellen dieses Containers an
dieses aktuelle Stammverzeichnis anhängen möchten Und wenn Docker dann erstellt, wird
es diese
Umgebungsdatei
in seinem Build-Arbeitsbereich haben in seinem Build-Arbeitsbereich Eine sehr wichtige Sache
, die ich
hier betonen möchte , ist, dass dies ein
gewisses Sicherheitsrisiko darstellt Bitte beachten Sie
hier, dass es sich in diesem Fall einen öffentlich
gelisteten Container handelt und dass sich die Datei
innerhalb des Containers befindet. Das ist zwar für
öffentliche Variablen wie die Cron-Zeitzone und
die Cron-Zeitplanzeichenfolge in Ordnung, aber nicht für Geheimnisse
wie unseren Slack-Webhook In diesem Fall würde ich
vorschlagen, dass Sie eine separate Datei
erstellen und diese beim Ausführen
Ihres Docker-Containers übergeben,
wo auch immer das Ihres Docker-Containers übergeben, Diese Besonderheiten der geheimen
Verwaltung sind jedoch von Organisation
zu Organisation in der Regel sehr
unterschiedlich , weshalb ich das nicht in diesem
Kurs behandeln werde Vorerst werden wir nur
veranschaulichen, wie wir diese Datei in unsere CICD
aufnehmen können diese Datei in unsere CICD
aufnehmen Bitte beachten Sie jedoch, dass es sich um
ein potenzielles Sicherheitsproblem handelt ein potenzielles Sicherheitsproblem Eine letzte kleine Änderung, die
wir
hier in unserer konfigurierten AMO-Datei vornehmen müssen hier in unserer konfigurierten AMO-Datei besteht darin, diese
Cron-Schedule-Umgebungsvariable Da wir diese
Sternchen hier haben, Charakteren,
wenn sie
von CircleCI seltsamen Verhalten bei diesen Charakteren,
wenn sie
von CircleCI maskiert werden Um dem abzuhelfen, müssen wir diese
Variable nur in doppelte Anführungszeichen setzen. Dadurch wird das Problem behoben, dass dieser Wert
in unserer
Enddatei wiedergegeben Als letzten Test
für unseren Container werde
ich
diesen Crown-Zeitplan
in den nächsten Minuten auf etwas anderes ändern , und dann können wir
unseren Container ziehen, ihn ausführen
und sicherstellen, dass alles
läuft und funktioniert, und zwar zu dem Zeitpunkt, zu dem
wir unseren Cron-Zeitplan festlegen Es ist jetzt also etwa 4:18 Uhr. Also werde ich
das löschen und wieder hinzufügen. Lass uns das für 225 machen. Also das ist die 25. Minute, 14. Stunde und dann die
Sternchen für alle anderen Das kann ich wieder hinzufügen. Und zurück im Projekt hier werde
ich den
letzten Workflow erneut ausführen, um sicherzustellen, dass der Container mit dieser neuen Variablen
neu erstellt wird . Warten Sie hier einfach, bis
die Pipeline abgeschlossen ist, und dann können wir
zu Doctor Hub springen, unsere Container-ID
abrufen und den Container ausführen. Die Pipeline ist also abgeschlossen, und wenn wir hier rüber
zum Docker Hub springen , sehen wir, unser
neues Image
gerade veröffentlicht Wir klicken darauf. Wir
können den vollständigen Ausweis bekommen. werde ich kopieren.
Um es dann auszuführen, können
wir Docker Run ausgeben Dann wollen wir losgelöst und die
vollständige ID des Containers haben. Es wird für
uns heruntergeladen und gestartet. So können wir überprüfen, ob
es mit P A läuft.
Wir sehen, dass es läuft
und es gibt noch keine Logs, aber wir erwarten, dass
wir um 2:25 Uhr eine protokollierte
Kopie unserer Slack-Nachricht
und natürlich der
Slack-Nachricht selbst erhalten und natürlich der
Slack-Nachricht selbst Okay, 225 ist gerade bestanden. Schauen wir uns hier unseren Slack an. In der Tat bekommen wir diese Nachricht. Heute ist es also ein bisschen regnerisch. Die Pollenbelastung ist etwas
niedriger als der Durchschnitt. Ein paar gute Dinge, die ich wissen sollte. Und wenn wir zurück zu unseren Docker-Logs gehen, bekommen
wir die Kopie der Nachricht,
die den ganzen Weg zurück gesendet wurde
,
von der Lognachricht, die wir in den Hauptpunkt geschrieben haben,
einige Lektionen zurück Also, herzlichen Glückwunsch. Sie haben das Ende
der letzten
Lektion zur technischen Programmierung für diesen Kurs erreicht . Es ist nur noch eine Lektion übrig, und das ist die
Art von Outro- und Zusammenfassungsstunde, in der das, was
wir in diesem Kurs behandelt haben,
besprochen und erörtert wird , wo
Sie den Code,
das Buch und alle anderen
zusätzlichen Ressourcen
für den Kurs finden können das Buch und alle anderen zusätzlichen Ressourcen
für den
19. Outro: Also herzlichen Glückwunsch. Das ist es. Das ist das Ende dieses Kurses
für Anwendungen in der realen Welt. Ich hoffe, es hat Ihnen
genauso viel Spaß gemacht wie mir, es zu machen. Nur zur Erinnerung, es gibt eine PDF-Buchversion
dieses Kurses. Ich werde den Link dazu
in den Unterrichtsressourcen hinzufügen. Es gibt auch das
GitHub-Repository für diesen Kurs, in dem jede Lektion
allem entspricht, was wir
in dieser Lektion gemacht haben. Sie sind nach Branchen benannt. Das ist also alles, was ich von meiner Seite
habe. Viel Spaß beim Schreiben von G-Code und ich werde
euch alle beim nächsten Mal sehen. O.