Transkripte
1. Kurs-Einführung: Hallo zusammen, es ist max und
willkommen zu meinem Kurs darüber wie man die Augen deiner
Python-Anwendungen dunkler macht. Wie jeder
Softwareentwickler weiß, spielt
Darker eine sehr
wichtige Rolle in Ihrer
Softwareentwicklungskarriere da Sie so
sicher sein können, dass alles, was Sie vor Ort
haben, tatsächlich
dasselbe ist. Und es wird genauso
auf einer anderen Maschine
laufen ,
auch in der Cloud und in
einer Produktionsumgebung. Darüber hinaus bietet es Ihnen viele wirklich
nette Tools,
mit denen Sie auf einfache Weise verschiedene
Bilder erstellen können, sodass Sie alle Arten von Software
leicht verfügbar
haben. Aber wir wollen
sicherstellen können, dass wir Dunkler richtig
verwenden. In diesem Kurs lernen
wir die Grundlagen, wie Sie
Ihre erste Docker-Datei schreiben, wie Sie einen mehrstufigen Build durchführen
und wie Sie docker-compose verwenden, damit Sie
Ihre Python-Anwendung verwenden können wirklich welchen anderen
Code es geben würde. Aber in diesem Fall konzentrieren
wir uns nur auf Python und führen
das tatsächlich aus , indem wir Docker verwenden das Docker-Image erstellen und dann den Docker-Container
ausführen, beide über die regulären
Docker-Befehle als ebenso wie über
Docker Compose. Jetzt ist dieser Kurs
tatsächlich Teil
einer größeren Python-Serie. Wir werden lernen
, wie man eine vollständige
Python-Anwendung von Grund auf neu erstellt . Aber in diesem Fall
konzentrieren
wir uns nur auf den dunkleren Teil. Der Code
, den wir
verwenden werden, stammt also aus dieser
größeren Python-Serie. Und Sie
können tatsächlich über
den GitHub-Link unten in
der Kursbeschreibung darauf zugreifen . Sie können jedoch
natürlich auch einfach Ihren eigenen Python-Code
für die gleichen Zwecke verwenden. Oder du kannst den
Code verwenden, der
sich bereits auf GitHub befindet, wenn du möchtest. In jedem Fall finden Sie
jede dieser Lektionen auch als verschiedene GitHub-Zweige und das GitHub-Repository unten. Wenn Sie also dem Code
folgen möchten, überprüfen
Sie
das auch dort. Also sehe
ich dich ohne weitere Umschweife drinnen
und viel Spaß beim Lernen.
2. Docker Intro: Ordnung, in diesem Abschnitt werden
wir anfangen, etwas
über Docker zu lernen und in unsere Anwendung zu integrieren. Nun, Dr. ist ein
wirklich cooles Programm und ich würde
dir eigentlich empfehlen , einfach Google Docker herunterzuladen oder einfach zu dieser URL hier zu gehen, docker.com Slash-Produkte
Slash Docker Desktop. Und für mich, weil
ich auf einem Mac bin, gibt
es
mir die Mac-Optionen. Aber wenn Sie
unter Windows oder Linux arbeiten, werden
diese standardmäßig verwendet
und stellen Sie sicher,
dass Sie das herunterladen, da es ein paar hundert Megabyte sind. Das Herunterladen kann also
einige Minuten dauern. Ich habe
das schon gemacht. Also ja. Für Docker ist Docker
wirklich nett, weil
es uns hilft,
eine andere Art von Problem zu lösen , das wir bereits gelöst haben, als wir
über virtuelle Umgebungen sprachen. Wenn Sie sich also
an virtuelle Umgebungen erinnern, war unsere Hauptmotivation
, dass wir
sicherstellen wollen, dass
alles konsistent ist. Und in gewisser Weise ein
bisschen isoliert für alle
Python-Pakete, die wir brauchen. Wenn unsere Anwendung zum Beispiel eine schnelle API
benötigt, um ausgeführt zu werden, möchten
wir sicherstellen, dass
jeder, der versucht, unseren Code
auszuführen, FastAPI
installiert hat , sowie
all die anderen Dinge , die er auch benötigt, um dies
auszuführen Anwendung. Und dass es ihnen nicht
sagt wie : Oh hey, du verpasst
diese Installation, du verpasst
diese Installation
oder sie versuchen, die lokalen Installationen zu verwenden. Und dann gibt es eine
Versionskonflikt, z. B. verwenden
wir eine Version
, von der ich nicht weiß, wie zehn Punkte was auch immer. Und sie verwenden eine Version
wie Nine Point was auch immer. Und es gibt ein Versionskonflikt. All diese
Dinge haben wir also versucht
,
mithilfe virtueller Umgebungen anzugehen. Und es ist großartig und äußerst nützlich. Aber wir können noch mehr tun
,
um dies noch
konsistenter zu gestalten. Und die Idee hier ist
, dass
wir mit dunkleren Containern
isolierte Container erstellen können. Stellen Sie sich das also im Wesentlichen wie eine Box vor, die wir von Grund auf neu
aufbauen können, einschließlich des Betriebssystems. Und wir wissen, dass egal,
wo das laufen wird, wenn wir ihm die
richtigen Anweisungen geben, es überall
gleich aussehen wird. Und jetzt
fragen Sie sich vielleicht, warum wir das machen
wollen, klingt
ein bisschen übertrieben. Nun, eigentlich gibt es bestimmte Szenarien
und ich bin
tatsächlich selbst
mehrmals darauf gestoßen , in denen Sie möglicherweise
etwas auf einem Mac installieren und es
möglicherweise nicht richtig funktioniert, oder es
funktioniert auf einem Linux, oder Dinge funktionieren auf einem
Linux auf eine Weise, sie funktionieren eine andere Art und Weise und dann
funktionieren sie unter Windows
wie auf eine dritte Weise. Oder Sie haben auch
bereits lokale Dinge installiert
, die Sie möglicherweise
vergessen haben , weil Sie sie vor
sechs Monaten oder vor ein
oder zwei Jahren
installiert haben . Und dann versucht jemand anderes , deinen Code auszuführen
und sie
sagen: Hey, diese Dinge funktionieren
nicht. Und das liegt nur daran, dass
Sie
einige Dinge installiert haben, die Sie vergessen haben und die
sie nicht haben. Verwendung von Docker
hilft uns daher Die Verwendung von Docker
hilft uns daher, all diese Probleme
zu lösen. Und es gibt tatsächlich noch
viel mehr coole Sachen, die wir
damit machen können und die wir uns später
ansehen werden. Aber wir werden uns jetzt
konzentrieren. Zunächst einmal verwenden Sie Docker,
um im Wesentlichen
eine extrem saubere Box zu erstellen eine extrem saubere Box , die unsere Anwendung enthält , die unabhängig davon, wo Sie ausgeführt werden, konsistent
ist. Und tatsächlich wird Docker
weltweit verwendet , dass
Sie bei der Bereitstellung von Code diesen Code normalerweise
als Docker-Image
bereitstellen , das irgendwo ausgeführt
wird. Also ja, dunkler, sehr wichtig
dafür, dass
uns das wirklich hilft , alles von Grund auf
konsistent zu machen, vom selben
Betriebssystem, das mit denselben Versionen der
R-Programmiersprache läuft , das gleiche und dann
unsere virtuellen Umgebungen verwenden, um konsistente Pakete zu
installieren. Deshalb wollen wir nur
sicherstellen, dass alles
gleich ist , egal wo Sie
es betreiben , und dunkler wird
es uns ermöglichen, das zu tun. Und es ist extrem,
extrem nützlich denn dann musst du dir nie
Sorgen machen oh,
gab es etwas, das ich vergessen habe , das auch
installiert werden muss, das ich
installiert habe oder gibt es
welche Umgebungsvariable , die ich gesetzt habe und die ich vielleicht vergessen
habe? Oder, weißt du,
all diese
seltsamen Kuriositäten, die auftauchen können. Und dann besonders
bei Problemen wie, Whoa, warum funktioniert es nicht
auf Ihrem Computer? Es funktioniert gut auf meiner Maschine. Hast du die virtuelle
Umgebung richtig installiert? Ja, hast du.
Okay. Das ist merkwürdig. Warum läuft es auf
meiner Maschine und auf deiner? Darker wird uns helfen, all diese Probleme
zu lindern. Und dann, wie wir später sehen werden, gibt es tatsächlich noch ein paar
coole Dinge, die wir tun können , die dir das Leben mit Docker
erheblich erleichtern, z. B.
auch das Erstellen einer Datenbank, die wir verwenden
können oder Geld
aufwerfen, das wir gebrauchen können. Und viele coole Sachen werden noch kommen. Aber wir werden uns darauf konzentrieren zuerst unsere Anwendung zu
isolieren, sodass wir dieses Bild einfach jemandem
geben können und er es dann
ausführen kann und er genau
das bekommt
, was wir auf unserer Seite sehen. Also ja, damit würde
ich nur Google empfehlen, docker Desktop und
deine Lieblingssuchmaschine
herunterzuladen oder hier auf diese Website zu gehen, was sich mit der
Zeit ändern kann, wahrscheinlich nicht, aber docker.com slash-produkte
slash Docker Desktop. Und dann
mach einfach weiter und lade die dunklere Version für dich herunter.
Nochmals, das habe ich schon gemacht. Wenn ich dann das Bild
auspacke, muss ich es nur noch von hier
in meine Anwendungen
ziehen. Sobald Sie das getan haben, gehen Sie zu
Ihren Bewerbungen. Und hier willst du jetzt auf Darker
doppelklicken und es
einfach für
mich laufen lassen , weil ich es
schon einmal ausgeführt habe. Es fängt einfach
an zu laufen. Und Sie
sehen tatsächlich, wenn Sie auf einem Mac sind und in der
oberen rechten Ecke wird
es dieses kleine
Schiff geben ,
das so aussieht und das unter Windows
herumhüpfen wird. Wir werden
das in einer Sekunde durchgehen. Aber ja, warte, bis sich das öffnet. Es ist das erste Mal, dass
du es benutzt. Sie werden aufgefordert, die Allgemeinen Geschäftsbedingungen
zu lesen und zu akzeptieren Allgemeinen Geschäftsbedingungen bevor die Bewerbung gestartet
wird. Also, wann immer das
Pop-up auftaucht
, stellen Sie sicher, dass Sie
weitermachen und das tun. Und wieder auf einem Mac in
der oberen rechten Ecke, normalerweise in deiner
Symbolleiste dort oben, die
gerade nicht auf meinem Bildschirm ist, solltest
du einen Wal wie
diesen sehen , bei dem die
Behälter zirkulieren, was bedeutet, dass es angefangen hat. Und wenn es einmal eine feste Form
annimmt, bedeutet
das, dass es richtig
angefangen hat. Und nachdem Sie
die Allgemeinen Geschäftsbedingungen akzeptiert haben und
das Startup beginnt, sollten
Sie in der Lage sein, zu Ihrem PyCharm zu
gehen. Wenn Sie hier nur
dunkler eingeben, sollten
Sie hier eine Ausgabe sehen , die anzeigt, dass die Installation erfolgreich
abgeschlossen wurde. Wenn Sie
Probleme damit haben, würde ich als
Erstes empfehlen, zunächst zu
warten, bis Ihr Docker
geöffnet ist. Und wenn es immer noch
Probleme gibt,
versuchen Sie, Ihren PC neu zu starten, sollten
Sie nicht müssen, aber es ist im Allgemeinen eine
gute Sache, es zu versuchen. Und wenn Sie hier dunkler
eingeben, sollten
Sie sehen, dass es
auf eine Art Ausgabe reagiert. Wir sind hier. Für die Windows-Seite der Dinge. Wir werden auf derselben
Seite sein und wir können hier sehen mir bereits
die Windows-Version empfohlen wird. Fahren Sie fort und klicken Sie auf
Herunterladen, was ich bereits
getan habe , da das Herunterladen ein
paar Minuten dauert. Dann
öffnen Sie das Installationsprogramm. Sie werden aufgefordert, wenn Sie dies öffnen möchten, klicken
Sie auf Ja. Und dann öffnen
wir das Installationsprogramm
oder es
gibt zwei Kontrollkästchen, die standardmäßig aktiviert
sind. Verlassen Sie diese einfach und klicken Sie auf Weiter. Dann beginnt
die Installation, was wiederum ein
paar Minuten dauert. Also lasse ich es einfach im Hintergrund
laufen. Und dies ist der Zustand
, in dem Sie erreichen werden, wo die
Installation erfolgreich war. Und dann klicken wir einfach
auf Schließen und starten neu. Also werden wir dafür
unsere Maschine neu starten. Nach dem Neustart auf der
Windows-Seite werden
wir auch mit diesem Popup hier
aufgefordert. Ich akzeptiere
die Bedingungen und mache einfach damit
fort. Und jetzt
öffnet sich Docker , falls Sie dieses Popup
erhalten. Wir folgen hier nur einigen weiteren Anweisungen, um den Installationsvorgang zu erhalten. Also lasst uns einfach schnell
weitermachen und das tun. Schieb das aus dem Weg. Folgen Sie den Anweisungen hier. Donald, das hier, ganz schnell. Öffnen Sie execute und führen Sie einfach diesen Vorgang
durch. Und dann habe ich hier schon
PyCharm geöffnet. Ich nehme das und
kopiere es einfach. Gehen Sie in PyCharm, wo die PowerShell
bereits geöffnet ist. Füge das da rein. Ich werde nur noch einmal
auf Neu starten klicken. Und nachdem wir hier
einen Neustart durchgeführt haben und zu unserem Docker übergehen, sollten
wir jetzt sehen, dass Docker Desktop diese Anwendung
öffnet. Wenn wir nach rechts unten gehen, dann auch da, was für
mich gerade außerhalb des Bildschirms ist. Aber es gibt auch, die Sie sehen
sollten, wenn Sie
auf diesen kleinen
Fensterpfeil klicken , den Sie immer haben, dass Sie dieses
dunklere Schiffsding hier haben. Und dann haben Sie
die Container, die sich bewegen
sollten.
Und auch dort. Wenn Sie darauf
klicken, sollten Sie zurück zur Docker-Anwendung gelangen,
wie wir sie hier haben. Okay, jetzt gehe ich
in unseren PyCharm, wenn wir treffen oder wenn wir hier dunkler
eintippen. Und dann, auch von
Windows, sollte
dieser Befehl jetzt mit etwas
registriert sein und
wir sehen uns in einer Sekunde. Jetzt haben wir die
damit verbundene Ausgabe. So
werden wir den Installationsprozess unter Windows angehen.
3. Erstelle eine Docker: Ordnung, jetzt wo wir Docker installiert
haben, wollen wir weitermachen und
Docker tatsächlich verwenden , damit wir
unsere Anwendung darüber ausführen können. Bevor wir darauf eingehen, möchte
ich
Ihnen kurz im Allgemeinen zeigen, woher wir
diese Basisbetriebssysteme bekommen , sind diese
vorinstallierten Basispakete ,
von denen wir verwenden werden. Um das zu tun, können
Sie auf hub.docker.com gehen. Dann müssen
Sie hier ein Konto erstellen. Wenn Sie also keins
haben, melden
Sie sich einfach dafür an. Sie können sich anmelden
und gelangen zu einer Seite, die wahrscheinlich
ungefähr so aussieht. Und Sie können entweder zum
Erkundungsbereich gehen , wenn Sie möchten. Und hier sehen wir
bereits eine Liste
verschiedener Arten von Basissystemen
, die uns zur Verfügung stehen. Diese können Ihnen etwas
bedeuten oder auch nicht. Und wir können hier sehen, dass
Python einer von denen ist. Wir können also entweder direkt
darauf
klicken oder wenn wir nach etwas
Bestimmtem suchen. Wir könnten auch hier
oben suchen, z.B. Python. Und wir werden
eine Version davon verwenden. Und wenn wir hier drin sehen, können
wir sehen, dass ihnen
im Wesentlichen ähnliche Tags
zugeordnet sind . Und wir werden in einer Sekunde sehen,
wie wir diese nutzen können. All dies sind jedoch im Wesentlichen unterschiedliche
Versionen, auf die wir
Zugriff haben und die wir verwenden können. Und die Wichtigkeit der Verwendung von Tags ist, dass sie ein
Gefühl der Konsistenz vermitteln. Wenn wir ein Tag verwenden, können
wir dasselbe
konsistent wiederverwenden. Und auf diese Weise wissen
wir, dass sich unser System nicht ändern
wird, selbst wenn Upgrades oder
ähnliches veröffentlicht werden. Es
wird immer unter genau
den gleichen Bedingungen laufen , was für uns offensichtlich
so wichtig ist. Also für uns werde ich Python hier
verwenden. Aber nur zu Ihrer Information , wenn Sie jemals
eine andere Basis oder
Bilder verwenden müssen eine andere Basis oder , als wenn Sie sich nicht sicher sind, wonach genau
Sie suchen, ein schnelles Google oder die Verwendung Ihrer
Suchmaschine von Wahl, wir werden Sie wahrscheinlich sehr schnell in oder in die Richtung
weisen, aber ansonsten können Sie auch einfach durchsuchen, welche Bilder der
Öffentlichkeit an einem Ort
zur Verfügung stehen , gehen Sie
einfach in den Docker Hub. Und du wirst hier
z.B. für Python sehen, das ist ein offizielles
Bild und das ist normalerweise ein gutes Tag, nach dem
du suchen willst. Da diese im Allgemeinen
die vertrauenswürdigsten sind. Da dies nicht
die Basis bilden wird. Deshalb sollten Sie
sicherstellen, dass das, was Sie
installiert haben , wie eine
richtige Version ist und nicht nur von einer zufälligen Person erstellt wurde , die möglicherweise etwas
weniger vertrauenswürdig ist. Obwohl die grüne Linie, die graue Linie in diesem Bereich, auch ein
wenig fragwürdig wird, was, was vertrauenswürdig ist
und was nicht. Aber im Allgemeinen ist es
ein guter Indikator,
als Erstes nach den offiziellen Bildern zu
suchen. Und wenn es nicht so ist
, dann hat es dieses Etikett nicht. Stellen Sie einfach sicher, dass Sie verstehen,
was Sie verwenden. Da es das ist,
worauf Sie Ihre Anwendung ausführen werden. mir dessen nur
aus Sicherheitsgründen bewusst. Aber davon abgesehen, kehren
wir zu
unserer Bewerbung zurück. Und was ich hier
machen werde, ich werde eine neue Datei erstellen. Und ich nenne
diese Docker-Datei wie diese D-Docker-Datei in Großbuchstaben. Ich drücke einfach die Eingabetaste. Und jetzt erstellen wir
hier unsere Docker-Datei. Das erste, was wir tun
müssen, ist, dass wir
spezifizieren müssen , was
die Grundlage unseres Systems bilden soll. Also im Wesentlichen die
Art und Weise, wie wir diese
Docker-Container erstellen werden,
über die Sie nachdenken können. Wir versenden diese
gut strukturierten, verpackten, isolierten Container,
fast wie eine Werft. In jedem dieser Container wird in unserem Fall eine Anwendung enthalten
, aber sie kann wirklich alles
enthalten, was drin ist. Und es klingt wie
autark oder enthält zumindest
alles, in einem einzigen Paket enthalten sein
muss. Das erste, was wir tun
müssen, ist, dass wir
definieren müssen , in was unsere Basis sein
wird. Und so brauchen wir eine Art
Betriebssystem. Wenn wir jedoch nur
von einem Betriebssystem aus starten, wird
es im Allgemeinen ärgerlich, da wir
dann
alle zusätzlichen
Python-Abhängigkeiten installieren müssen alle zusätzlichen
Python-Abhängigkeiten um sicherzustellen, dass
wir Python ausführen können. Und so viel einfacher für uns ist es,
als nur mit grundlegenden Betriebssystem zu beginnen und von dort aus aufzubauen, wir können ein paar
Schritte weiter gehen und wir können beginnen Sie mit einem Betriebssystem
, auf dem Python installiert ist. Und dann
müssen wir nur noch
all das Zeug installieren , das wir brauchen und im Wesentlichen
unsere Anwendung ausführen. Das werden wir also tun. Wir beginnen
mit diesem Schlüsselwort, das definiert,
womit wir beginnen wollen. Ich werde das Python-Bild verwenden
. Und speziell werde ich das Tag Drei-Punkt-Neun
verwenden,
was, wie Sie vielleicht vermutet haben,
darauf hinweist, dass dies für
Version 3.9 für Python ist. Und dann füge ich
hier noch einen Strich hinzu und mache das Alpenbild. Nun, das alpine
Image ist im Allgemeinen eine nette Sache, um darauf
aufzubauen , da es
relativ klein ist. Was Sie nicht wirklich
wollen, ist, dass Sie kein riesiges
Betriebssystem
installieren möchten riesiges
Betriebssystem
installieren , auf dem eine Menge
Dinge installiert sind, aber Sie
werden nicht viele davon verwenden. Im Allgemeinen
reicht also das
alpine Image selbst mit dem Python für Ihre Anwendungsfälle aus. Aber falls es jemals nicht der Fall sein sollte, gibt es eine andere
Sache namens Slim Buster, die Sie ausprobieren können. Aber alternativ wird
ein schnelles Google oder eine schnelle Verwendung Ihrer
Lieblingssuchmaschine, oder eine schnelle Verwendung Ihrer
Lieblingssuchmaschine,
was auch immer das sein mag, Sie
sehr schnell in
die richtige Richtung weisen , wofür Sie
möglicherweise ein besseres Bild
verwenden können dieses. den meisten Fällen reicht Ihnen
das Alpenbild jedoch aus. Und wieder ist der
Vorteil, den wir daraus ziehen, dass wir
nicht nur
eine Menge Sachen installieren und dass unser
Container sehr groß wird. Vielmehr wollen wir es so klein wie
möglich
halten , damit
wir nicht viele unserer
Systemressourcen
verbrauchen , nur um all
diese Dinge zu installieren , die wir nicht einmal verwenden. Wir beginnen also mit
dem Python-Image mit dem Tag 39 dash Alpine, das wiederum eine
Python 3.9-Version ist und all das und
die Abhängigkeiten vorinstalliert
enthält . Und wir verwenden hier die
Alpine Version da diese
relativ klein ist. Ordnung, das ist also der
erste Befehl, den wir haben, nämlich das Frontkommando. Jetzt schauen wir uns den nächsten Befehl
an
, der ein run-Befehl
sein wird. Hier können wir
diese Befehle verwenden , um bestimmte Schritte einzuleiten. Und die Art und Weise, wie wir Dinge
angehen und Docker, ist jeder einzelne Befehl
, den wir überall haben, jedes einzelne Keyword,
das Sie hier verwenden, Sie können sich vorstellen, dass Sie Ihrem Bild
eine weitere Ebene hinzufügen . Wir haben also unsere erste Schicht hier. Wenn wir jetzt unser
erstes Keyword hier haben, run, das wir in einer Sekunde
sehen werden. Wir werden
unsere zweite Schicht bilden. Wir haben hier ein anderes Schlüsselwort, sagen
wir mal einen weiteren Lauf. Ich werde gerade unsere dritte Schicht
bilden. Und damit bauen
wir Schicht für Schicht
auf. Nun der Grund, warum
das nett ist, weil Docker tatsächlich auch
irgendeine Form von Caching hat. Es wird also erkannt,
ob Sie für
etwa die Hälfte Ihrer Sachen keine Änderungen vorgenommen haben . Und wirklich nur der letzte
Schritt ist derjenige, der sich ändert, dann kann er die meisten
Dinge von
zuvor wiederverwenden und es
muss nur die letzte Ebene geändert werden. also daran, dass es
eine sehr wichtige Sache ist, nur weil Sie beim
Erstellen Ihrer Docker-Images wirklich die Dinge, die sich
kaum ändern, ganz oben platzieren möchten, und die Dinge, die kann
sich regelmäßiger ändern, z.B. die Pakete, die Sie
installieren müssen oder auch nur
Ihren Anwendungscode. All das sollte
eher nach unten gerichtet sein. Ordnung, also fange ich mit
diesem Run-Befehl an. Hier können wir Docker anweisen, einen bestimmten Befehl
auszuführen, und
Sie werden dies erkennen. Wir starten
pip, installieren pip. Also werden wir hier diesen Befehl
ausführen
, den Sie wahrscheinlich
aus einer früheren Lektion kennen, in der wir pip end mit unserem PIP
installieren werden. Und wir haben PIP
verfügbar, weil wir dieses
Python-Basisimage
installieren, das bereits
Python enthält und die Dinge, die wir dafür
benötigen, oder alles
davon ist vorinstalliert. Python-Version
hier wird wieder 3.9 sein, und wir haben auch den Befehl
pipa man sofort
damit einhergeht. Also ja, wir werden R so
installieren. Eine weitere Sache, die
wir tun werden ist, ein neues Verzeichnis zu
erstellen. Wir werden einen neuen Ordner
erstellen in dem wir
all unsere Sachen aufbewahren können. Denn letztendlich erstellen
wir diesen Container und wir
wollen alles, was wir
brauchen, an einem Ort ablegen , damit es für uns verfügbar ist genau wie wir es hier
in unserer Projektdatei haben, z. diesen Container und wir
wollen alles, was wir
brauchen, an einem Ort ablegen
, damit es für uns verfügbar ist,
genau wie wir es hier
in unserer Projektdatei haben, z.
Um dies zu tun, werden
wir dieses
MK-Verzeichnis für das Make-Verzeichnis verwenden. Und wir werden dieses Minus p
haben, was es uns im Wesentlichen ermöglicht, mehrere Ordner gleichzeitig zu erstellen. Und dann werden wir einfach
diese Pfadbenutzer-SRC-Slash-App verwenden . Und hier werden
wir unseren gesamten Code für
unsere Anwendung platzieren . Nun, dieses Zeug, ich möchte mit
all den Linux-Befehlen nicht
zu sehr ins Detail gehen,
weil es tatsächlich
einen separaten Kurs darüber gibt . Ich möchte
hier also nicht ein bisschen zu sehr
entgleisen ein bisschen zu sehr
entgleisen und mich wirklich
darauf konzentrieren. Aber im Wesentlichen
denken Sie daran, und Sie können
die Syntax einfach wiederverwenden ,
indem wir nur dieses Verzeichnis hier und
diese Ordner erstellen. Im Benutzerordner haben
wir also den SRC-Ordner und dort haben wir
die Anwendung. Und wenn eines davon nicht existiert, werden
wir es schaffen. Also machen wir das nochmal, nur damit wir einen Ordner haben , in den wir unsere Sachen legen können. Das nächste, was wir
tun werden, ist
einen neuen Befehl namens loops work zu verwenden . Und das wird unser
aktuelles Arbeitsverzeichnis festlegen. Das wird
uns helfen, denn
anstatt das immer überall
eingeben zu müssen, wann immer wir etwas ausführen
wollen oder in einer Sekunde, werden wir sehen, wie wir etwas
kopieren. Wir können einfach sagen, dass wir
unseren aktuellen Standort verwenden. Es wird es uns also nur
ein bisschen einfacher machen ,
sodass wir
dieses Jahr nicht die ganze Zeit wiederholen müssen. Also werden wir
es an diese Benutzer-SRC-App verkaufen. Dies wird unser
Arbeitsverzeichnis oder
der Ordner sein , in dem wir
gerade arbeiten
, in dem alles relativ in Ordnung
sein sollte. Jetzt haben wir pip installiert, wir haben den Ordner, in den
wir
unsere Sachen ablegen werden. Und wir werden
auch nur
einen relativen Standort dafür festlegen . Jetzt müssen wir Zugriff auf unsere Dateien
haben, aber wir möchten sie in
unser Bild kopieren und an der richtigen Stelle ablegen. Wir werden
diesen Kopierbefehl verwenden. Und jetzt müssen wir uns
ansehen, was wir hier haben. Und im Grunde
wollen wir das jetzt kopieren. Und wir wollen hier größtenteils
dieselbe Struktur haben , außer vielleicht etwas
von dem Müll loszuwerden , den wir nicht brauchen. Also machen wir
das in zwei Schritten. Wir beginnen mit der Pip-Dateisperre
und der Pip-Datei sowie dieser main.py. Da dies diejenigen sind
, die mehr draußen sind, sind sie
eine Ebene höher. Also werden wir sie
kopieren. Also
kopieren wir unsere Pip-Datei, unsere Pip-Datei dot loc. Und wir werden auch unsere main.py
kopieren. Und wir werden das einfach verwenden weil wir nicht
die vollständige Pfadbenutzer-SRC-App
ausschreiben
müssen , in die wir sie kopieren möchten, weil wir unser
Arbeitsverzeichnis festgelegt haben, können
wir einfach
die relativer Pfad, was bedeutet, dass er in das
aktuelle Arbeitsverzeichnis kopiert wurde. Das wird also
kopieren, das nehmen und es wird das für uns
kopieren. Ordnung, jetzt wo wir
diese Dateien kopiert haben, wollen wir
jetzt
alles in unserem
Anwendungsordner hier kopieren . Leider können wir unsere App hier nicht einfach hinzufügen, da sie den gesamten
Inhalt von innen übernimmt und
sie einfach auf dieselbe Ebene kopiert, was wir nicht wollen. Also fügen wir hier einen
zweiten Kopierschritt hinzu. Und wir möchten
den Inhalt
unserer App im Wesentlichen in
einen App-Ordner kopieren . Also was ich tun werde, ist, dass ich hier einen
weiteren App-Ordner erstellen werde. Unsere Ordnerstruktur
wird also
Ihr oberster Ordner sein , ist die usr, dann gehen wir zu SrC. Dann haben wir den App-Ordner und hier drin haben wir
einen weiteren App-Ordner. Sie können sich das also
nur anhand dieses Ordnernamens vorstellen ,
anstatt Angebote zu sein, kaufen Sie sie, das Projekt
wäre aktiv und wir haben App hier und App hier. Und jetzt wollte ich den
Inhalt dieses Ordners, der App ist
, in den
App-Ordner kopieren , der sich hier befindet. Ordnung, also haben wir
unsere Sachen für das erste Level hier kopiert. Es wird
auf derselben Ebene sein. Und jetzt möchte ich sicherstellen
, dass alle Inhalte und hier auch in diesem Format vorliegen. Und wieder, wenn ich das nur benutzt habe, wird
das den
Inhalt von hier übernehmen und sie
einfach
auf die gleiche Ebene kopieren, was offensichtlich nicht die
aktuelle Struktur ist , die wir haben. Dazu füge ich hier einfach einen weiteren Ordner hinzu, in den
wir das kopieren können. Ordnung, jetzt wo wir
das haben, wir weiter und lernen vorerst
einfach, wie wir unser Image
beginnen können, und
schauen uns unsere aktuelle Struktur an um sicherzustellen, dass das in Ordnung ist. Und was wir dann tun
werden, ist, dass
wir mit dem Rest
der Sachen fertig
werden, die mit der
Pip-Installation installiert werden und auch unseren Server tatsächlich
betreiben werden. Aber jetzt schauen wir uns
unsere aktuelle Struktur an und
sehen, ob sie richtig ist. Und dafür verwende ich ls minus l,
was, wenn Sie auf einem Mac oder
Linux sind , für Sie funktionieren sollte. Ich glaube nicht, dass das unter Windows
funktionieren wird, aber das ist okay, weil es hier drin funktionieren
wird, weil wir sowieso eine
Linux-basierte Version verwenden werden. Aber Sie können sehen, was
dieser Befehl bewirkt, ist, dass er den Inhalt
des
aktuellen Ordners
ausdruckt , in dem ich mich befinde. Im Wesentlichen können wir hier
sehen, dass die Inhalte hier genau wie die hier aufgeführten
Inhalte sind. Also werde ich das vorerst
ausführen, nur damit wir einen Blick in
unser Image werfen
können , das wir
hier aufbauen , um sicherzustellen, dass
unsere Struktur korrekt ist. Ordnung, jetzt wo wir
unsere Docker-Datei definiert haben, In Ordnung, jetzt wo wir
unsere Docker-Datei definiert haben,
die die Schritte definiert
, die wir ausführen werden, angefangen von einem Basisimage und Kopieren all unserer Sachen bis hin zu diesem Image enthält all
das Zeug, das wir brauchen, damit wir unsere Anwendung tatsächlich
ausführen können. Es hat
noch nicht alles, aber wir werden es schaffen. Jetzt müssen wir also
tun, da wir dieses Bild hier zu finden
haben, wir müssen dieses Image erstellen. Wir mussten
diese Befehle also nicht ausführen und
alles in ein fertiges Paket packen
, das wir einfach ausführen können. Um dies zu tun, verwenden
wir den
Befehl Docker build. Und jetzt
verwenden wir hier ein Minus-t, das das Ziel sein wird in
das wir das kopieren wollen, der Name, den wir dem
zuordnen wollen. Also nenne ich das
hier einfach meine erste App. Und ich werde
dem Tag spätestens eine Wendung geben. Das neueste ist ein Tag, den Sie sehr oft sehen werden. Zeigt nur an, dass dies die neueste Version
dieses Bildes ist. Normalerweise
haben Sie jedem Bild
ein Tag zugeordnet, und dann
haben Sie auch ein neuestes Tag. Auf diese Weise können Sie, wenn Sie nur die neueste Version ausführen möchten
, das neueste Tag verwenden, das sich wahrscheinlich mit der
Zeit ändert , wenn Updates angewendet
werden. Auf diese Weise sind Sie garantiert immer
auf der
neuesten Version. Oder Sie könnten auch
auf ein bestimmtes Tag verweisen, wie wir es
in diesem Fall hier tun, was bedeutet, dass selbst wenn mehr als 3.10
uns gehören, es 3.11,
13.12, 13 ist , wenn das herauskommt oder Wenn Price
und Four herauskommen, wird das nicht
beeinflussen, denn
wir werden uns immer noch
an ein
bestimmtes Bild halten , das hier mit diesem Tag
gekennzeichnet ist. Es garantiert uns also Konsistenz , dass
wir, selbst wenn sich
die Dinge rund um eine Änderung ändern, immer dieselbe Basis verwenden
werden. Es gibt also offensichtlich
Vor- und Nachteile für jeden. Auf diese Weise können Sie problemlos mit der neuesten
Version
auf dem Laufenden bleiben , wann immer Sie sie starten
oder neu erstellen. Aber offensichtlich sind sie auch Vorbehalte, denn
wenn sich die Dinge ändern, können
sie inkompatibel werden und dann laufen deine Sachen
möglicherweise nicht mehr, was offensichtlich nicht gut ist. Wenn wir das im Hinterkopf behalten, haben wir
jetzt das
Ziel, das wir sagen
wollen , in das wir einbauen wollen. Jetzt müssen wir nur noch den
Speicherort unserer Docker-Datei angeben, die ich hier platzieren werde
,
was nur darauf hinweist, dass sie
sich im aktuellen Ordner befindet, in dem
wir uns gerade befinden. Ich drücke Enter. Für Sie wird dies wahrscheinlich ein
wenig Zeit in Anspruch nehmen da Sie dieses Bild zuerst
herunterladen müssen. Und dann werden Sie all
diese Befehle darüber ausführen . Für mich wurde ein Großteil der Sachen
bereits eingelöst. Und Sie können hier sehen,
wenn wir nach oben scrollen, wurden viele dieser Schritte eingelöst. Und so wird kein wirklicher
Download für mich durchgeführt. Und der Bauprozess geht
tatsächlich sehr,
sehr schnell, wie wir sehen können. Wenn Sie dies
das erste Mal ausgeführt haben und es erneut ausführen, wird es
auch sehr schnell gehen. Denn auch hier werden diese
Ebenen zwischengespeichert. Jetzt, wo wir
unser Image erstellt haben, wollen wir es
jetzt ausführen. Wir haben also dieses Paket, das
fertig ist und jetzt wollen wir es ausführen. Und um das zu tun, verwenden
wir
den Befehl docker run. Und wir geben jetzt den Namen sowie das
Tag an, das wir ausführen möchten. Also wollen wir
dieses Bild hier ausführen. Und ich werde
ihm auch einen Namen geben. Also
werden wir das ausführen, und das wird als Container
laufen. Wir werden dieses
Bild hier als Container laufen lassen. Und wir werden
diesem laufenden Container einen Namen geben , damit wir ihn besser sehen können. Das können wir, wenn wir uns ansehen, welche
Dinge laufen, was wir uns gleich
ansehen werden. Wir werden wissen, okay, das
ist, das ist keiner. Also können wir ihm irgendwie
einen lesbaren Namen geben. Also nennen wir das unsere vielleicht unterstrichene
erste Anwendung. Du brauchst die Unterstriche nicht, aber ich werde sie benutzen. Und ja, drücke einfach hier die Eingabetaste. Und wir werden das
ausführen und wir können sehen, dass es
diesen Befehl hier ausgeführt hat
, der nur den Inhalt
auflistet. Und die Struktur, die
wir haben, ist Pip-Datei. Wir haben die Pip-Datei dot loc. Wir haben den App-Ordner
, der all diese Sachen
enthalten sollte. Und wir haben die main.py. So
sieht unser aktueller Ordner aus, den wir haben. Das ist nett, weil wir die Tests
nicht haben, z. B. weil wir den
Test nicht brauchen, wenn wir unser Image ausführen oder um
diesen Code als Anwendung auszuführen. Denn bis dahin oder unsere
Tests habe ich ausgeführt und wir brauchen die Tests
dort nicht
mehr brauchen die Tests
dort nicht
mehr , weil wir
die Tests
nicht als Live-Anwendung ausführen werden . Wir werden
den Test durchführen, wenn wir lokal
testen, wir werden die
Tests später durchführen, wenn wir es sind, bevor wir unser Image erstellen. Sobald unser Image erstellt ist, benötigen
wir die Tests nicht mehr. Und so können wir
das verwerfen und sagen, sparen wir uns auch hier
ein bisschen Platz. Jetzt, wo wir das laufen
haben, wir weiter und setzen
unser Setup hier fort. Denn wir
wollen wirklich nicht nur den Inhalt
ausdrucken und
dann fertig sein. Vielmehr wollen wir
eine laufende Anwendung haben , die wir tatsächlich verwenden können. Dazu müssen
wir noch ein paar Schritte unternehmen. Das erste
, was wir tun müssen,
ist, dass wir unsere
Pip-Installation ausführen müssen , damit wir alle Abhängigkeiten installieren
, die wir benötigen. Also werden wir unsere
Pip-Installation verwenden . Wir werden
das def-Tag nicht verwenden, da dies im Wesentlichen unser
Produktionsbild sein
wird. Wir wollen die Entwicklungsabhängigkeiten also nicht installieren , weil wir diese nicht benötigen. Wir werden nur
eine reine Bewerbung sein. Wir werden jedoch ein neues Tag
verwenden, das Dash, Dash System sein
wird. Jetzt wird
alles installiert, was wir
systemweit verwenden , sodass wir es ausführen oder wenn
wir versuchen, darauf zuzugreifen, wir müssen nicht in
unsere virtuelle Umgebung gehen, aber es ist einfach wird für ein ganzes System
installiert, was es für uns ein bisschen
einfacher
machen wird , weil wir
dann die PIP und
Befehle nicht später wieder verwenden müssen ,
weil im Wesentlichen das, was wir in haben das ganze Bild hier ist
eine virtuelle Umgebung. Wir erstellen das
jedes Mal und es geht nichts
anderes hinein. Wir können es also
systemweit installieren , weil wir genau
wissen, was es ist, weil wir alles
bauen. Von Grund auf neu. Also werden wir
unsere Abhängigkeiten so installieren ,
wie wir es normalerweise tun. Und jetzt
müssen wir unsere Anwendung tatsächlich ausführen. Also werden wir dafür erneut den
CMD-Befehl verwenden. Und wir öffnen
und schließen Klammern. Und jeder der Einträge
ist jedes der Elemente , die wir hier haben
werden, wird eines der Argumente sein
, die wir anwenden werden. Also z.B. normalerweise, wenn wir die Unicorn Main Dash App
ausführen, die du tatsächlich so
ausführen kannst. Aber die bevorzugte Art, es zu
schreiben, wäre so. Wenn wir das also nur tun, wird
dies der übliche Befehl
sein
, den wir verwenden, außer normalerweise haben wir auch
dieses Reload, whoops Tag. Wir wollen dies nicht in der Produktion verwenden , da dies die Anwendung stark
verlangsamt. Stellen Sie also sicher, dass Sie dieses Tag nicht in der Produktion
verwenden. Wenn wir es
lokal ausführen, ist es in Ordnung. Das macht den Prozess
viel einfacher. Aber wenn ich
es in der Produktion betreibe, willst
du dieses Tag nicht mehr verwenden. Jetzt können wir es einfach so belassen, wenn wir
wollen, wir können es ausprobieren. Aber es gibt immer noch
einige Probleme, die wir in einer Sekunde damit sehen werden. Aber kommen wir zu denen,
wenn wir zu denen kommen. Was ich also tun werde, ist
,
mein Image erneut aufzubauen und dann in
meine erste App zu gehen, spätestens. Also werde ich dieses Tag
mit dem Befehl docker build
außer Kraft setzen. Und whoops, habe
das Minus t hier vergessen. In diesem Fall wird es also etwas
länger dauern, da wir
jetzt
dieses Pip-Installationssystem tatsächlich ausführen müssen. Also haben wir
das vorher nicht ausgeführt, aber jetzt führen wir es aus. Und so muss es tatsächlich
diesen Prozess ausführen , der heruntergeladen und alle Abhängigkeiten
installiert werden
muss der heruntergeladen und alle Abhängigkeiten
installiert bis es
zu diesem Zeitpunkt etwas langsamer sein wird, aber wir können alle
vorherigen Schritte hier sehen tatsächlich zwischengespeichert und so
gehen sie sehr, sehr schnell. Und wenn das erledigt ist, sollte
das
in nur einer Sekunde erledigt sein. Ja, los geht's. Jetzt, wo wir das verschüttet haben, können
wir Docker Run machen. Und wir geben unseren Namen, der
meine erste App sein wird, spätestens. Und lassen Sie uns denselben Namen wiederverwenden
, der
unsere erste Anwendung sein wird. Wir wollen hier
das Namensschild geben. Wir werden hier auf
ein Problem stoßen, weil es sich beschwert, dass dieser
Name bereits verwendet wird. Und wir werden in einer Sekunde auf dieses
Problem eingehen. Aber jetzt
verwenden wir einfach einen anderen Namen, z. B. so. Dieser Name ist jetzt
anders als dieser. Also sollte es in Ordnung sein. Aber wir werden uns in einer Sekunde mit diesem
Thema befassen. Also lasst uns weitermachen und das ausführen. Und das wird
sein, wir können hier
den Befehl sehen , den
wir normalerweise gesehen haben, nämlich unsere Anwendung
startet. Aber jetzt ist hier die
Sache. Wenn wir versuchen ,
darauf zuzugreifen, klicken wir hier. Wir
haben eigentlich keinen Zugriff darauf. Was offensichtlich ätzend ist,
weil wir im Idealfall ,
auch lokal, in der Lage sein
wollen Docker
tatsächlich für unsere Entwicklung zu
verwenden. Auf diese Weise können wir sehr sicher
sein , dass das, was wir lokal auf
unserem Computer
ausführen , genau das ist ,
was später
in der Cloud ausgeführt wird. Wir werden
keine Probleme haben, dass Dinge nicht ordnungsgemäß installiert
werden und Dinge nicht verfügbar sind. Das
werden wir uns jetzt ansehen. Ordnung, also bin ich hier getroffen, kontrolliere C, um es zu töten. Und jetzt
werde ich zuerst
diesen Dash, Dash Host-Tag verwenden. Anstatt
es auf 127 Punkt Null Punkt,
Punkt eins auszuführen ,
werde ich es stattdessen auf 0000 ausführen,
was nur bedeutet, dass dies jede Schnittstelle
akzeptiert, von der wir kommen, was es einfach mehr macht
allgemein, was wiederum nett ist, weil wir keine bestimmte Adresse
angeben wollen, aber im Grunde wollen wir es
nur schaffen, solange wir hier sind, wollen
wir Zugriff darauf haben. Also werden wir stattdessen
diesen Host benutzen. Und jetzt
definieren wir
auch einen bestimmten Port
, den wir definieren wir
auch einen bestimmten Port Konsistenzgründen verwenden wollen. Also werde ich hier
Port 80, 80 verwenden,
aber Sie können auch
verschiedene verwenden. Aber für diesen Fall
werde ich Port 80, 80 verwenden. Und wenn wir jetzt unser Image neu erstellen, scrollen wir
einfach nach oben und bauen es neu auf und warten, bis
dieser Vorgang abgeschlossen ist. Sie sehen, dass die meisten unserer
Layer zwischengespeichert sind, weil die einzige Änderung, die wir
vorgenommen haben, tatsächlich hier war. Alles andere wurde
bereits getan. Und so laden wir im Wesentlichen
all diese Schritte aus Bargeld neu. Und jetzt werde ich vorerst einfach einen neuen Namen
vergeben, da wir zuvor diese
Namenskollision hatten, die wir uns in
einer Sekunde ansehen und auf Ausführen klicken werden. Ordnung, jetzt können wir
sehen, dass hier
auf diesem Host läuft und wir auf diesem Port
laufen. Aber wenn ich hierher gehe, können
wir immer noch nicht darauf zugreifen. Und das liegt daran, dass unsere
Anwendung in
diesem Container ausgeführt
wird und derzeit
keinen Zugriff auf die
Außenwelt hat, auch nicht auf unserem eigenen Computer. Was wir also tun müssen, ist
in unserem docker run-Befehl, ich werde
das Minus-P-Flag verwenden. Und es wird
uns ermöglichen, Port-Forwarding durchzuführen. Wenn wir von unserer Maschine gehen und sie von unserem Port aus betrachten, wird
sie an einen bestimmten Port in unserem laufenden Container weitergeleitet, z. B. werde
ich Forward Port 808-02-8080 in der Behälter. Und auf diese Weise müssen
Sie jetzt, wenn ich diesen Namen
ausführe, wenn ich diesen Namen
ausführe,
diesen Namen vorerst ändern. Wenn ich hier bin. Jetzt wird es verfügbar sein. Und wir können sehen, ob wir auf die Dokumentenseite
gehen die Dokumente für
uns verfügbar haben , weil wir uns auf Port 80 befinden. 80, die nun tatsächlich an den Containerport
weitergeleitet wird . Um Ihnen das noch einmal zu zeigen, verwenden
wir hier einige
andere Zahlen. Verwenden wir Port 8.000
, an den wir
weiterleiten werden,
whoops, das ist nicht das,
was ich wollte. 8.000, die an Port 80,
80 und unseren Container
weitergeleitet werden . Denken Sie daran, in unserem
Container
läuft die Anwendung auf Port
80, 80, aber draußen
werden wir sie
von Port 8.000 weiterleiten. Also wenn ich das durchführe, habe ich den Namen wieder
angenommen. Ich leite es. Wenn ich hier klicke, haben wir
jetzt ein Problem weil auf Port 80 nichts
läuft. 80. Aber wenn ich Port 8.000 verwende , werden wir innerhalb unserer Anwendung an Port
80, 80
weitergeleitet . Das ist also nicht wichtig. Ups, zeig den Befehl noch einmal. Dies ist ein wichtiger
Schritt, den wir
unternehmen müssen , weil wir das, was wir auf unserer Maschine
haben,
weiterleiten werden , sodass wir
tatsächlich in den Container
gehen können. Ordnung, kommen wir jetzt
zu diesem Namensproblem. Wenn wir diesen
Befehl docker ps verwenden, können
wir uns tatsächlich alle aktuell
laufenden Container ansehen, denen es derzeit keine gibt. Aber wenn ich das nochmal starte,
dann nochmal der Name. In Ordnung, wenn ich das noch einmal starte, öffne
ich hier ein neues Terminal. Und warte einfach, bis
die Vorbereitung abgeschlossen ist. Ich werde
meine virtuelle Umgebung verlassen. Wenn ich jetzt den Befehl erneut verwende, docker ps, können wir
hier sehen , dass wir den einen
laufenden Container haben. Wir können hier sehen,
dass
dies der Befehl ist , der im Inneren ausgeführt wird. Dies ist die Portweiterleitung
, die wir gerade durchführen. Dies ist der Name
des laufenden Containers. Als es erstellt wurde. Die Stata ist, dass wir
das Bild hinzufügen müssen, dass es ausgeführt wird. Sobald wir getötet haben. Es. Kann hier
sehen jetzt ist es auch weg. Aber wenn wir uns alle verfügbaren
Container ansehen wollen , kehren wir zu
unserem vorherigen Terminal zurück. Wir können diesen Docker benutzen, ps dash, dash all, der uns
alle Container zeigt, die wir haben. Wir können hier sehen, dass dies der erste
ist
, den wir erstellt haben. Dann haben wir den zweiten, den dritten, den
vierten, den fünften 161. Was wir also tun können, ist, wenn
wir diese alten Container haben, anstatt nur
dort zu sitzen und Speicherplatz zu beanspruchen, wir können
sie tatsächlich löschen, wenn wir wollen, was wir
mit Docker Remove tun können. Und dann
geben wir hier die Container-ID an. Also drücke ich die Eingabetaste und es wird das entfernen , damit wir sehen können, ob
ich es erneut ausdrucke. Dieser ist jetzt weg. Und ich werde das auch
für diesen machen. Und lass es uns auch tun. Lassen Sie uns diese hier noch
einmal ausdrucken. Und um das ein
bisschen schneller zu machen, entfernen
wir mehrere. Da haben wir's. Drucke die aus. Jetzt können wir sehen, dass wir nur noch fünf
unserer Anwendung übrig haben , die ebenfalls nicht mehr läuft. Wenn wir diesen
löschen möchten, können
wir Docker auch entfernen. Jetzt haben wir also keine Container
und AlphaGo zurück zum Beispiel oder run command. Wir können denselben Namen wiederverwenden, da
derzeit kein Container mit ihm verknüpft ist. Jetzt
wird es wieder funktionieren. Es gibt hier jedoch noch einige andere
Befehle, von denen Sie wahrscheinlich einen
verwenden werden. Und was ich hier
tun werde, ist, dass ich einfach
zwei Befehle miteinander verketten werde. Also werde ich eigentlich zuerst die
Container-ID bekommen und ich
werde sie entfernen. Ordnung, also
schauen wir uns das gleich an. Aber zuerst ist eine Sache, die wir
wahrscheinlich tun werden,
was wir nicht wollen unser Terminal dadurch
blockiert
wird , weil wir immer noch Lage sein
wollen, andere Dinge zu
tun. Es gibt also einen Flug
, den wir verwenden können, nämlich dieses minus d, ihn als Daemon-Prozess ausführen wird, was bedeutet, dass er einfach im Hintergrund ausgeführt
wird. Es wird
diesen Vordergrund-Terminalraum nicht herausnehmen . Wenn wir das ausführen, können
wir hier jetzt sehen,
ob wir docker ps machen, wir haben einen laufenden Container. Und wenn wir zu unserem Webbrowser gehen, klicke ich hier auf Aktualisieren,
dann können wir sehen. Dass unsere Anwendung
tatsächlich läuft. Das waren die
anderen, also werde ich
sie einfach schließen. Dieser sollte auch nicht laufen, weil er sehr
wichtig ist. Lass uns jetzt einfach im Hintergrund
laufen. Jetzt
könnte die Frage sein, wie wir verhindern können, dass es ausgeführt wird, bevor wir
Control C drücken konnten. Was wir jetzt
tun können , ist, dass wir
den Befehl docker verwenden, kill und geben Sie die
Container-ID, drücken Sie die Eingabetaste. Und wenn wir es jetzt noch einmal versuchen, läuft
unsere Anwendung nicht
mehr. Wir können hier keine
laufenden Container sehen. Und habe den
Container trotzdem verfügbar. Also werde ich diesen entfernen. So wie das. Wir können dies auch über die
Desktop-Benutzeroberfläche tun, wenn wir möchten. Wenn wir also diesen hier
hochziehen und
unseren Container jetzt so laufen lassen , gehen
wir zurück zur Benutzeroberfläche. Wir können hier sehen, dass wir jetzt einen laufenden Container
haben. Wenn wir wollen,
können wir darauf klicken. Wir können
die Ausgabe tatsächlich hier sehen. Es gibt ein paar Sachen,
mit denen du herumspielen kannst, wenn du möchtest. Wann immer wir bereit sind. Ich meine, wir haben gesehen, wie wir
das einfach über das Terminal machen können. Wenn Sie die Schnittstelle
verwenden möchten, wenn Sie sie stoppen möchten, können Sie hier auf Stop klicken, wodurch sie
nicht mehr ausgeführt wird. Wenn Sie also Docker ps haben, können
wir sehen, dass es
keine laufenden Container gibt oder Docker ps
minus minus alle ausführen. Siehst du den Container noch
verfügbar? Und wenn wir hier auf Löschen klicken,
werden wir z.B. auch unseren Container löschen. Das war also unser erster
Blick auf Darker. Und ich weiß, dass wir viel abgedeckt haben. Aber wir sind an einem
wirklich schönen Punkt angelangt, weil wir
jetzt unseren
gesamten Code gut ausführen können, außer dass wir Änderungen vornehmen
, an denen wir
noch neu aufbauen müssen. Aber wir können unsere Anwendung wirklich über ein Docker-Image
ausführen, was großartig ist, da
dies
die genauen Spezifikationen sein werden , in
denen sie ausgeführt wird , wenn sie ausgeführt wird irgendwo eine
Cloud-Umgebung. Und so wissen wir, dass alles
, was hier läuft im Wesentlichen so ist, wie es
funktionieren wird , wenn es woanders
läuft. Was extrem toll ist,
weil wir jetzt viel
Konsistenz in unserem System haben Konsistenz in unserem System und wir uns keine
Gedanken darüber machen müssen, wie k, aber es läuft auf meinem Computer. Wird es wirklich
woanders laufen? Wenn wir Docker-Images
verwenden, wissen wir, dass
selbst wenn wir es einem Kollegen
geben möchten ,
dieser es herunterladen kann. Sie können das
Docker-Image erstellen, das es ausführen kann. Und sie werden
genau die gleichen Dinge sehen wie wir. Jetzt. Offensichtlich ist Darker
eine sehr coole Software und es gibt eine Menge
Dinge, die damit einhergehen. Und wir werden
nicht alle behandeln. Wir werden
uns auch mit Docker Compose befassen. Es gibt also einige Dinge, die wir dunkler machen
können und die
wir hier nicht untersuchen
werden ,
weil einige der Dinge,
die wir
mit Docker machen werden, komponieren, z. B. aber selbst damit,
offensichtlich Es gibt eine Menge Kleinigkeiten, auf
die man sich einlassen kann. Einige wirklich ausgefallene
und komplexe Dinge , um ein wirklich cooles System zu haben. Aber in den meisten, fast allen
Absichten und Zwecken ist
das, was wir
jetzt tun, im Wesentlichen was Sie brauchen
werden, oder Sie werden es tun, wenn
Sie tatsächlich bauen und betreiben.
begleitende Bewerbungen. Und wenn Sie jemals
bestimmte Dinge benötigen, stoßen Sie bestimmte Probleme als Google oder was auch immer Ihre
Lieblingssuchmaschine
ist, wird
Ihnen das wahrscheinlich
am schnellsten helfen , weil Sie wissen genau das, wonach du suchst, die grundlegenden Dinge dessen, was du
tun kannst und dann
kannst du einfach schnell, es gibt ein paar Sachen. Aber ja, wieder dunkler, ist sehr, sehr wichtig, sehr,
sehr häufig. Mein gesamter Code, den ich
im Wesentlichen ausführe,
wird dunkler und irgendwie ausgeführt weil es einfach
so schön ist
, die Konsistenz
dieses Images zu haben , die Konsistenz , das wir einfach bereitstellen
können irgendwo und ich weiß genau,
wie es funktionieren wird. Und Sie können
es einem Kollegen geben und er kann es auf
seinem Computer ausführen, und Sie wissen, dass alles, was er
hat, genau
das gleiche Setup sein wird , das Sie haben. Und so ist es einfach
sehr nett, weil es Konsistenz
und Reproduzierbarkeit
ermöglicht.
4. Mehrstufiger Aufbau: Wir haben also zuvor
gesehen, wie wir unsere Docker-Images
erstellen können . In dieser Lektion gehen
wir nun auf einige Best Practices ein und
Anpassungen können Sie
an diesem Docker-Image vornehmen , das wir mit
dieser
Docker-Image-Vorlage erstellen , die wir erstellen, um eine
Container aus. Und im Grunde sind
dies Dinge, die Sie sehr wahrscheinlich an vielen, vielen Orten
verwenden werden. Und nur im Allgemeinen. Zuallererst, als
kurze Randnotiz, wirst
du wahrscheinlich sehen,
wenn du
PyCharm verwendest , dass du irgendwelche
Plugin-Installationsanfragen für Docker bekommst . Wenn Sie möchten, können Sie
einfach auf Plugin installieren klicken. Es wird einen blauen
Balken geben und ich füge nur einige Formatierungen hinzu, da Sie
sehen können, dass ich sie hier habe. Aber wenn Sie es nicht möchten, können
Sie einfach auf Ignorieren klicken. Aber nur als kurze
Randnotiz werden Sie wahrscheinlich diese Popup-Leiste sehen. Aber wie auch immer, also für
diese Verbesserungen werden
Sie das im Allgemeinen oft sehen
. Und wir schauen uns
an, ob
wir zuerst einen Benutzer erstellen werden. Dieser Benutzer wird
uns helfen, weil wir am Ende nicht unser gesamtes System als
Root-Benutzer ausführen wollen . Wenn wir es jedoch
als Benutzer mit reduzierten
Berechtigungen ausführen , kann uns das helfen. Denn wenn unser Docker-Image oder ein Docker-Container
jemals angegriffen wird, dann
wird der Benutzer, der hackt, keinen
vollen Systemzugriff haben, aber er wird eingeschränkten
Zugriff haben, was nett ist. Die andere Sache, die
wir als mehrstufige Builds betrachten werden. Und das hilft
uns nur, die Größe
des endgültigen Bildes zu reduzieren ,
das wir ausführen werden,
was nur dazu beiträgt, die Dinge kleiner zu
halten. Also ja, und nur
als allgemeine Anmerkung, für dieses dunklere Zeug werden
wir das Schritt für Schritt
durchgehen
, damit du verstehst,
was wir tun. Aber die meiste Zeit wirst
du eine
Art Vorlage haben. Wenn Sie
in einer Organisation arbeiten, können
Sie wahrscheinlich ziemlich
sicher sein, dass sie eine Art Docker-Vorlage hat, mit der Sie arbeiten
können. Wenn sie kein
offizielles Repository haben, können
Sie einfach in
ein anderes Repository schauen und es als
Vorlage
verwenden und irgendwie an Ihre Bedürfnisse angepasst werden. Und alternativ, wenn Sie
wissen, wonach Sie suchen, gibt es viele
Vorlagen-Online-Tools, die Sie verwenden
können, damit Sie sich diese Dinge nicht
auswendig lernen müssen . Sie werden dafür wahrscheinlich Vorlagen
verwenden. Du musst nur irgendwie wissen, was du willst, warum es da ist. Und wenn etwas fehlt, fügen Sie das im Wesentlichen hinzu. Das werden wir also von Grund auf
durchgehen . Aber die meiste Zeit,
wenn du das tust, kannst
du es selbst schreiben. Es ist aber auch
einfach, eine Vorlage zu verwenden da Sie
die meiste Zeit sehr
ähnliche Dinge tun werden. Ordnung,
beginnen wir damit, unseren Benutzer hinzuzufügen. Also fügen wir hier
einen weiteren run-Befehl hinzu. Und wir machen Add
Group minus S. Um dies hinzuzufügen, erstellen
wir eine
Gruppe, zu der wir unseren Benutzer
in einer Sekunde hinzufügen werden. werden wir unserem System hinzufügen
. Und ich
nenne diese Gruppe einfach meine App, aber du kannst sie wie auch immer nennen. Dann verwenden wir dieses
und, was es uns ermöglicht, Befehle miteinander zu
verketten. Also werden
wir zuerst diesen ausführen, und jetzt werden wir nach diesem
einen weiteren Befehl ausführen , der add user sein wird. Und wir werden
dies auch zu einem Benutzer für unser System machen. Wir werden es
zu unserer Gruppe „Meine App“ hinzufügen. Wir geben diesem
Benutzer den Namen user und
weisen ihm auch eine ID zu. Lass uns einfach 1234 machen. Wenn wir jetzt
alles als Benutzer ausführen möchten, verwenden
wir diesen
Docker-Benutzerbefehl. Und dann können wir
hier
entweder den Namen angeben , den wir zugewiesen haben,
oder wir sehen in einer Sekunde, wir können alle sehen, ist die ID. Und was
das bewirken wird, ist,
dass es diesen
Benutzer im System nachschlagen wird, und es wird diese ID finden. Und dann wird der nächste Befehl oder
Einstiegspunkt, den wir haben, stattdessen mit
diesem Benutzer ausgeführt. Was nett ist, denn dann führen
wir
das nicht mehr als Root-Benutzer aus
, der vollen Zugriff hat, sondern mit reduziertem Zugriff. Also lass uns weitermachen und
sicherstellen, dass das läuft. Wir gehen zuerst zum
Docker-Build minus t. Wir machen meine App auf dem neuesten Stand. Und ich werde das auch
benutzen und
hier geben , damit Sie
sehen können, was es bewirkt. Aber im Wesentlichen führen wir das
zuerst durch. Und wenn das erfolgreich ist, dann werden wir
das nächste Ding hier ausführen. Und das wird
Docker sein, lauf. Unterschreibe einen Namen, mein AP-Test. Und wir können die
Ports abbilden, wie wir es
zuvor gelernt haben, und das Bild, auf dem wir meine App ausführen ,
spätestens, das hier sein
wird. Drücken Sie die Eingabetaste. Nun sollte das relativ
schnell gehen, da die Dinge zwischengespeichert
werden sollten und wir nur
zwei weitere Befehle ganz unten hinzugefügt haben, wir können hier sehen, dass der
Bauprozess sehr schnell verlief. Und da laufen wir los und es läuft einwandfrei. So ausgezeichnet. Okay, lass uns
weitermachen und das beenden. Control C. Und ja, fahren Sie mit dem
mehrstufigen Build-Teil fort. Und hier werden wir einige weitere Änderungen
hinzufügen, die wir gleich sehen werden. Das Erste
, was wir tun werden ist,
das vom Kommando abzuhalten. Wir werden
ihm tatsächlich einen Alias zuweisen und
das nennen wir unsere Basis. Und hier drin werden wir
im Wesentlichen unsere Installation
und unser Setup
durchführen. Und dann werden wir,
wie wir sehen werden, in Kürze
Dinge von
dieser Basis, die wir erstellt haben,
in unser laufendes Hauptbild kopieren . Und jetzt wird alles , was nicht
das neueste sein wird, das wir verwenden, nur
vorübergehend sein und dann
wird es verworfen, was nett ist, weil das bedeutet alles, was wir nicht in unser endgültiges Bild aufnehmen, wird verworfen und
nimmt keinen Platz ein. Ordnung, also erstellen wir hier
unser Basisbild. Also jetzt ist das erste
, was wir tun wollen, immer noch und wir wollen pip nth installieren. Und jetzt, anstatt
das Erste
, was wir tun wollen, oder der springende Punkt
dieser Basis-Images, wollen wir
im Wesentlichen einige unserer Sachen
installieren. Also was ich tun werde ist,
dass ich das hier nehme, ich schneide, ich lege es hier
hin. Aber ich brauche die
Hauptdatei momentan nicht weil ich nur unsere
Pip-Datei und unsere Pip-Dateisperre haben möchte. Weil ich nur die Installation
machen will. Ich werde jetzt nur
einen zusätzlichen Kopierbefehl hier unten erstellen . Und ich übernehme diesen
Teil und verschiebe ihn hierher, und wir werden später darauf eingehen. Im Moment kopiere
ich einfach die Datei oder pip und dann pip file lock. Alternativ können
wir pip file star verwenden, das nach
allem sucht, was diesem Format
entspricht. Also alles, was eine
Pip-Datei im Voraus hat und dann jede Datei, die danach
etwas hat. Also das ist z.B.
wir werden die
Pip-Datei und die Pip-Datei dot loc abgleichen . Und wenn wir
eine andere wie Pip-Datei,
Datei hätten , würde dies auch
damit übereinstimmen. Aber das, ups,
wollte das nicht. Wir können das
oder das andere benutzen. Aber das ist nur eine Abkürzung. Ordnung, also kopieren
wir unsere Pip-Datei. Und jetzt wollen
wir als Nächstes diese Installation ausführen. Weil wir dieses
erstellte und unser Basisimage ausführen wollen. Und dann kopieren
wir
die installierten Dateien,
damit wir keine haben, irgendetwas anderes. Ordnung, also werden wir eine ähnliche Syntax
beibehalten, aber die
Dinge ein wenig ändern. Also behalten wir
unseren Pip bei der Installation. Wir werden eine
systemweite Installation durchführen. Rocks werden hier
einen weiteren Flug hinzufügen, der die Einsatzflagge
sein wird. Und wenn Sie wissen möchten, was
diese Flags speziell tun , können
wir, weil
wir pip installiert
haben , pip install minus h. Und das wird
tatsächlich eine Hilfesuche aufrufen, die Ihnen alle
Befehle, auf die zugegriffen werden kann. So können wir sehen, ob wir zum System
gehen, z. B. werden wir
es nur auf unserem
System installieren oder bereitstellen. Das wird also gut
sein, denn wenn
etwas nicht stimmt, wie unsere Protokolldateien veraltet oder die Python-Version falsch ist, wird
es abgebrochen. Was gut ist, weil
wir nur
sicherstellen wollen , dass alles wie beschrieben
läuft. Und wenn hier etwas nicht
stimmt, wird
es einfach abgebrochen. Und dann fügen wir ein weiteres Flag hinzu, das Pip-Datei-Loops ignorieren
wird . Was bedeutet, dass wir
speziell vom Schloss aus bauen werden. In Ordnung, das wird also unsere Pip-Installation
sein, die ein bisschen anders ist, aber immer noch sehr ähnlich
zu dem ist, was wir zuvor hatten. Es gibt noch einige
Änderungen, die hier in einer Sekunde vorgenommen werden müssen, aber wir werden zu diesen kommen
, wenn wir dazu kommen. Jetzt fügen wir eine weitere
von hinzu und wir werden hier aus genau
demselben Bild
ziehen. Und dann hier. Jetzt werden wir, naja, wir wollen es kopieren. Die Sache ist, dass
wir zuvor hier
installiert haben , sodass
alle Pakete
, die wir installiert haben,
in unser Haupt-Image kopiert
werden , das
wir benötigen werden. Um das richtig zu machen, müssen
wir mehrere Dinge tun. Zunächst werden
wir also
einige Umgebungsvariablen hinzufügen , die
wir für Docker einfach dieses
End-Schlüsselwort verwenden können, das Umgebungsvariablen für uns setzt. Die erste
Umgebungsvariable ich verwenden werde,
wird unsere Pi-Wurzel sein. Und ich werde es so
definieren, dass es diesen Schrägstrich Pi-Wurzelwert hat. Und das wird
im Wesentlichen, wir werden es
in einer Sekunde verwenden, um zu sagen, wo wir auch Dinge
installieren wollen. Dann erstellen wir eine
Python-Benutzerbasisvariable. Jetzt ist diese Variable wichtig,
weil sie uns das
Basisverzeichnis für den Benutzer
mitteilt oder dem System mitteilt. Und wir werden diesen Wert
auf diese Piraten-Umgebungsvariable setzen. Und ich kann den in dieser Variablen
enthaltenen Wert referenzieren ,
indem ich das Dollarzeichen und
dann den Variablennamen verwende. Wenn ich möchte, kann ich
das auch in eckige Klammern setzen, was hilfreich sein kann,
wenn danach noch
andere Dinge
angehängt werden . Was wir nun getan haben, ist, dass wir diese
Umgebungsvariable auf diesen Wert
definiert haben . Und wir haben
diese
Umgebungsvariable für den hier
enthaltenen Wert definiert . Jetzt werden wir eine
weitere Umgebungsvariable verwenden, die der Pfad sein wird. Nun, mit dem Pfad ist, ist im Wesentlichen eine Liste von Orten denen unser Betriebssystem nach ausführbaren Dateien suchen
wird. Und weil wir hier in dieses
Verzeichnis
installieren werden , wollen
wir sicherstellen,
dass wir dies in die auffindbare Liste
der Dateien aufnehmen ,
um nach ausführbaren Dateien zu suchen. Für. Dazu referenzieren
wir
unsere vorhandene Pfadvariable und fügen
ihr unsere Piraten hinzu. Slash Bin Verzeichnis
speziell, weil hier unsere
Hinrichtungskutikula leben werden. Wie ich
bereits erwähnt habe, müssen
Sie das nicht von innen nach außen verstehen
. Sie müssen nicht in der Lage sein, dies im Gedächtnis zu
reproduzieren. Der Punkt ist, dass Sie verstehen, warum wir
diese Schritte ausführen. Hier. Wir fügen dies hinzu, weil wir eine Art
Basisbenutzerverzeichnis benötigen , in das
unsere Installationen gehen sollen. Und jetzt, da wir Installationen
hinzufügen, wollen
wir auch sicherstellen, dass die ausführbaren Dateien tatsächlich vom Betriebssystem
gefunden werden können . Das sind im Wesentlichen die Schritte
, die wir hier unternehmen. Und wenn wir
diese Schritte nicht unternehmen, werden Sie sehen. Und das können wir in einer Sekunde versuchen. Es wird nicht laufen.
Daher ist es wichtig wir diese Schritte hinzufügen
, damit sie ordnungsgemäß ausgeführt werden. Und alles, was wir hier tun, ist nur
Umgebungsvariablen zu erstellen. Ordnung, also haben wir
unsere Pip-Installation, Pip End, die
wir beibehalten werden. Also wollen wir immer noch pip end
installieren. Wir kopieren unsere
Pip-Akten. Und jetzt fügen wir hier noch
eine Flagge hinzu. Oder wir definieren
unsere Umgebungsvariable
für diesen Befehl. Und wir werden
die
Benutzerumgebungsvariable hier so setzen , dass sie eine will. Das bedeutet, dass
diese Installation
als Benutzerinstallation behandelt wird. Das bedeutet im Wesentlichen
das Benutzerstandortmaterial , das wir oben definiert haben. Ich werde wirksam werden. Deshalb haben wir das gerade aktualisiert, um es jetzt als
Benutzerinstallation zu behandeln. Und das ist der erste Teil. Daraus
wird unsere Basis bestehen. Und wieder ist der Zweck hier, das Setup durchzuführen. Und wenn Sie jemals andere
Abhängigkeiten installieren müssen, tun
Sie dies in
der Basiskomponente. Installieren Sie also
alles, was wir brauchen , um andere Dinge zu
installieren. ganze Zeug wird
hier reingehen. Jetzt haben wir
unsere zweite Docker-Phase. Hier. Wir werden tatsächlich unser endgültiges Bild
zusammenstellen und von hier aus übernehmen,
was wir brauchen. Und alles, was wir
nicht übernehmen werden, wird am Ende tatsächlich
verworfen,
was schön ist, weil uns das ein bisschen Platz
spart weil wir keine unnötigen Dinge
übernehmen. Wir werden
diese drei Variablen hier
genau auf die gleiche Weise definieren . Also kopiere
ich sie einfach. Das nächste, was ich
tun werde, ist, dass ich diesen Benutzerbefehl
annehmen werde . Und wir werden das hier nach oben
verschieben. Denn wenn
wir in einer Sekunde kopieren, möchte
ich
sicherstellen, dass ich
diese Dateien speziell
dem Benutzer zuordne . Aber bevor wir das tun, werden
wir hier
einen Kopierbefehl haben weil wir zuerst alle
unsere Pakete, die
wir mit
unserem PIP n installiert haben, in dieses Image übertragen
wollen unsere Pakete, die
wir mit
unserem PIP n installiert haben . Jetzt verwende ich ein eigenes CH. Und hier
definieren wir zuerst die Gruppe. Die Gruppe hier ist also meine App, und sie sollte
gleich sein, kein Doppelpunkt. Der Doppelpunkt ist hier. Das wird
also die Gruppe sein, und das wird
der Benutzer sein. Und wir werden
eine weitere Flagge von der Basis hinzufügen. Dieser Space verweist auf diesen
Alias, den wir hier oben haben. Jetzt kopieren wir den Inhalt aus
dem
Piratenverzeichnis, von unserer Basis in
unser Piratenverzeichnis
auf diesem Bild hier. Also im Grunde
kopieren wir jetzt all das Zeug, das wir
hier mit der Pip-Installation installiert haben , wir kopieren all
diese Pakete drüber, weil wir sie brauchen, weil wir sie brauchen
diese Dinge, die installiert wurden, um
unsere Anwendung auszuführen. Und dieser Befehl, diese Syntax hier, ist eine besondere Sache, die
wir für Docker hinzufügen können und Interessen bedeutet,
dies zu kopieren und unserem Benutzer
die Berechtigungen
für diese kopierten Dinge
zuzuweisen hier. Und von hier
wollen wir kopieren. In Ordnung, jetzt wo
wir
alle Pakete kopiert haben , die
wir installieren müssen, werde
ich dieses Jahr behalten weil wir unser Verzeichnis
behalten werden. Ich werde unsere Zuweisung
des Arbeitsverzeichnisses beibehalten. Und anstatt diese einfach direkt zu
kopieren, kopiere
ich sie jetzt mit den Berechtigungen, die diesem Benutzer
zugewiesen sind. So wie das. Ja, das ist alles. Das ist es. Dies ist unser aktualisierter
Docker-Befehl. Und lassen Sie uns das ausführen, um
sicherzustellen, dass es funktioniert. Und dann lass
es uns noch einmal durchgehen. Also werde ich zuerst das Bild entfernen, das wir zuvor ausgeführt haben
,
was ja ist, das ist der
Name, den wir ihm zugewiesen haben. Also muss ich
diesen zuerst entfernen. Und ich werde das tatsächlich und wieder hier
benutzen. Und was ich tun werde ist weil es mir hilft, es mehrmals
auszuführen. Wenn alles
erfolgreich ist,
entferne ich das Bild, das ich zuvor
erstellt habe. Das funktioniert
offensichtlich nur, wenn ich diese beiden Befehle zuerst ausgeführt habe. Aber sobald ich diesen Docker-Lauf ausgeführt habe, möchte ich ihn einfach immer wieder mit
demselben Namen ausführen . Ich werde das
vorhandene Bild entfernen, sorry, nicht. Ich werde den
vorhandenen Container entfernen. Ich werde ein neues Image aus unserer
Docker-Dateivorlage erstellen. Weisen Sie dasselbe Tag zu. Ich werde dieses Image
als neuen Container in diesem Namen ausführen . Also lass uns das versuchen. Okay? Wir können
hier also sehen , dass auch zwei verschiedene
Phasen stattfinden. Wir haben eine Basisphase und
wir haben unsere letzte Phase. Und los geht's. Unser System läuft
jetzt glücklicherweise immer noch. Wir haben jedoch einige Best Practices für
dunklere Druckmaschinen integriert. Wir laufen jetzt nicht
als Root-Benutzer. Stattdessen wurden wir
als Benutzer ausgeführt , den wir
mit reduzierten Berechtigungen erstellt haben. Und hier gibt es auch einen Schritt , der für uns
wahrscheinlich keine so
große Wirkung haben wird. Aber sobald Sie
andere binäre Dinge installieren müssen , um
Ihnen bei der Installation anderer Bibliotheken zu helfen, wie zum Beispiel zuerst, müssen Sie
einige Dinge installieren , damit Sie andere Dinge installieren
können. Es wird Ihnen helfen, denn die Dinge, die Sie zuvor
installiert
haben, werden Sie nach der Installation
Ihrer Bibliothek möglicherweise nicht mehr benötigen. Dieser Prozess wird also nur
dabei helfen, weil im Wesentlichen ein Großteil
des Setup-Materials, das wir
möglicherweise installieren müssen, aber
nach Abschluss der Installation möglicherweise nicht
mehr benötigen , wir können das alles verwerfen. Also alles hier
, was wir
in dieser letzten Phase nicht speziell kopieren. Derzeit ist dies
unsere letzte Phase. All das inklusive. All das hier, das hier nicht kopiert wurde,
wird verworfen. Das wird
uns nur helfen, wieder etwas Speicher zu sparen. Und ja, das ist ein
mehrstufiges Gebäude mit einem zusätzlichen laufenden
Ding als Benutzer, wir können
dies auch ändern, um
die Benutzer-ID zu verwenden , die wir ihm hier
zugewiesen haben. Und lassen Sie uns das noch einmal ausführen , um sicherzustellen, dass
das immer noch funktioniert. Wenn Sie Docker-Vorlagen sowohl innerhalb einer Organisation
als auch irgendwo online nachschlagen werden
sie einem
ähnlichen Format wie diesem folgen. Sie können irgendwo einige
Unterschiede haben, aber das wird
das Hauptziel sein, wenn Sie
ein Basisbild haben und Sie oft manchmal auch wie ein Basisbild
sehen. Dann sehen Sie ein Builder-Image , in dem der
Bauprozess tatsächlich stattfindet. Und dann sehen Sie
das endgültige Bild , in das die Dinge
kopiert werden. Es sind vielleicht sogar mehr
als zwei Schritte erforderlich, aber es ist die gleiche Idee das Setup
durchzuführen und dann alles zu
kopieren
, was wir brauchen, und den Rest zu
verwerfen, um unsere endgültigen
Bilder ein bisschen zu erstellen kleiner , damit wir keinen unnötigen
Speicher in unseren Bildern verwenden. Dass
wir im Grunde nicht wollen, dass Dinge installiert werden, die wir
nicht verwenden werden ist der springende Punkt
von all dem. Ordnung? Also, ja, es gibt noch eine weitere
Optimierung,
die wir durchführen können, die ich jetzt tatsächlich durchführen
werde. Wir haben hier zwei Stufen. Und im Allgemeinen ist es ein gutes Ziel, so wenige
Stufen wie möglich zu haben. Was ich also
tun werde, ist,
anstatt den Hauptpunkt py draußen
zu haben, werde
ich das hier in
unsere Anwendung verschieben . So wie das. Kopiere das rüber. Und in unserem Haupttopf hier. Wir haben unsere
Anwendung noch hier definiert. Und ich denke nicht, dass
wir
hier wirklich etwas
ändern müssen , was großartig ist. Aber jetzt müssen
wir dies in unserer Docker-Datei im Wesentlichen entfernen. Wir können auch eine
dieser Apps entfernen, da jetzt alles
in unserem App-Ordner enthalten sein wird . Wir können diese App
auch entfernen, wenn wir möchten. Oder alternativ könnten
wir das hier
belassen und es einfach so machen. Und lass uns das noch einmal erstellen und ausführen
. Und hoffentlich habe ich
alle Referenzen korrekt aktualisiert. Ich werde nur
ein bisschen länger brauchen weil wir hier einige
Änderungen an unserem Code vorgenommen haben. Und so irgendwann vor
dem Kopieren, oh, okay. Lassen Sie mich schnell herausfinden
, was hier vor sich geht. Main.py. Nun, ich denke, versuche es
einfach so. Und jetzt muss ich
meinen Einstiegspunkt hier aktualisieren , weil unser Arbeitsverzeichnis eine Ebene höher
ist. Also muss ich sicherstellen, dass ich in
diesen Ordner gehe und ihn dann
von dort aus starte. Ja, noch einmal. dritte oder dritte Mal ist ein
Zauber. In Ordnung, los geht's. Mit diesen Schritten
konnten wir die Anzahl der Schritte
,
die wir in unserer
Docker-Datei haben, um eins reduzieren Anzahl der Schritte
, , was nett ist. Und im Wesentlichen mussten wir nur einige der Dateien
ändern,
die wir in einigen
ihrer Namensreferenzen
hier
erstellt haben in einigen
ihrer Namensreferenzen
hier
erstellt , um sicherzustellen , dass sich alles
am richtigen Ort befindet, dass wir referenzieren
Sie es von der richtigen Stelle aus. Jetzt sind wir also im Wesentlichen
auf dieser Ebene. Hier gehen wir in
unseren Anwendungsordner, in unseren App-Ordner, wir verweisen auf die Hauptdatei. Und hier drin
verweisen wir immer noch auf diese App, diese initialisierte App
, die wir hier erstellt haben. Der Prozess ist also
immer noch derselbe, aber wir haben ihn irgendwie
in die eine Sache hier gesteckt. Wir haben unsere
Staaten schrittweise um eins reduziert, was einfach schöner ist. Je weniger Schritte Sie
haben, desto besser ist es. Lassen Sie uns nur eine allgemein
gute Sache anstreben. Nun, bevor wir diese Lektion
mit Docker-Best Practices abschließen , mir
tatsächlich aufgefallen, dass wir
auch
unseren Benutzer hinzufügen möchten , der
hier einem Flug entspricht, weil wir sicherstellen möchten , dass alle ist mir
tatsächlich aufgefallen, dass wir
auch
unseren Benutzer hinzufügen möchten, der
hier einem Flug entspricht, weil wir sicherstellen möchten
, dass alle
Installationen, die wir
durchführen, werden dieselbe Benutzerebene haben
, sodass wir nicht
einige Dinge auf unserem System und einige andere Dinge auf unserem Benutzer
installieren. Außerdem habe ich auch bei kleinen Tippfehlern
gemerkt, das sollte
nämlich
zuerst der Benutzer und dann die Gruppe sein. Also lasst uns das auch schnell beheben. Und los geht's.
5. Docker Komposition: Ordnung, also haben
wir uns zuvor eingehender mit dieser
Docker-Datei befasst und sie so
umstrukturiert , dass sie nach
Best Practices besser ist. Jetzt werfen wir
einen Blick auf Docker Compose, denn derzeit wenn wir die Docker-Datei
verwenden, wer hat
die einzelne Datei erstellt und dann haben wir sie ausgeführt. Aber was eigentlich
nett sein wird und was Sie sehen
werden, wenn wir
später dazu kommen , wenn wir
Datenbanken und Caching hinzufügen und so ist, dass wir nicht nur
unsere Anwendung laufen lassen wollen, wir wollen auch eine laufende Datenbank, die wir mit unserer Anwendung
verwenden können. Und wir
möchten wahrscheinlich auch einen separaten Cache haben , den wir
mit unserer Anwendung verwenden möchten. Und um
dieses ganze System einrichten zu können , das wir wiederverwenden können. Und es gibt tatsächlich eine Menge cooler Dinge, die du einrichten
kannst und nun, es ist ein tiefes Thema, in das du
eintauchen musst, und wir werden
natürlich nicht alles behandeln, aber wir werden die wichtigsten Punkte
durchgehen. Und wenn wir
in diesem Kurs an weiteren Punkten darauf eingehen
, werden
wir auch
diesen Docker Compose noch einmal berühren und Komponenten hinzufügen. ZB die Datenbank in der Kasse, von der ich gerade
gesprochen habe. Aber der Punkt ist, dass wir
manchmal einfach nicht eine Sache betreiben
wollen, die irgendwie isoliert ist,
sondern
dass wir
mehrere Dinge betreiben wollen und vielleicht diese Dinge
oder sogar miteinander verbunden. Um uns diesen
Prozess zu erleichtern, verwenden
wir
Docker Compose. Also beginnen
wir damit, hier eine neue Datei zu erstellen. Und ich nenne
das Docker Compose. Ein Docker, Compose
dot YAML, wie dieser. Wenn Sie Docker
installiert haben, sollten Sie auch Docker Compose haben. Also sollte
schon alles für dich eingerichtet sein. Ordnung, also schreiben wir zuerst
etwas Skeleton-Code und dann
erklären wir, was vor sich geht. Und im Wesentlichen ist das
erste, was
wir versuchen werden, zu versuchen, das zu reproduzieren,
was wir mit Dunkler
gelaufen sind zu reproduzieren, . Aber jetzt, anstatt Docker compose zu
verwenden, möchten
wir nur den
gleichen Dienst
wie einen Docker-Container zum Laufen bringen , auf den wir
weiterhin über
unseren Webbrowser zugreifen können . Das erste, was
ich
hier definieren muss , ist, welche Version
wir von der Syntax
verwenden werden , die wir
hier Version drei verwenden werden. Und dann definieren wir die Dienste,
die hier ausgeführt
werden. Sie können sehen, dass ich das
Docker-Plugin installiert habe. Also füllt sich einiges von diesem Zeug
tatsächlich automatisch. Wenn Sie es nicht
installiert haben, wird es nicht installiert. Und wenn Sie diese
Benachrichtigung noch hier oben haben, dann ist es natürlich am
einfachsten, einfach auf Plug-in installieren zu klicken und es
wird es für Sie installieren. Aber auch hier nicht wirklich notwendig. Es hilft einfach, hilft
beim automatischen Ausfüllen
und einigen Sachen. Aber ja, in Ordnung, also
hier werden wir die verschiedenen
Dienste
definieren, die ausgeführt werden. Einer dieser Dienste
wird z. B. Ihre Anwendung sein. Wir
definieren einen Dienst. Ich gebe ihm den Namen App. Wir können es nennen, wie wir wollen, aber ich gebe ihm
den Namen App, nur um
klarzustellen , was das ist. Und jetzt
werden wir hier einige der
Dinge darüber näher definieren. Das erste, was
ich herausfinden wollte, ist, wie kann ich
diese Anwendung erstellen? Was ist die Docker-Datei
, auf die wir verweisen müssen? In einigen Fällen verweisen wir
möglicherweise auf eine Docker-Datei, die
sich auf Docker Hub befindet. Und in anderen Fällen möchten
wir hier auf
eine Docker-Datei verweisen , die wir haben. Also werde ich
diesen Rechnungsparameter haben und
ihn einfach auf das aktuelle Verzeichnis verweisen. Also benutze dafür einfach einen
einzigen Punkt. Die andere Sache
, die ich
tun möchte , um Zugriff darauf zu erhalten, was wir auch zuvor getan haben,
ist, dass ich
die Portzuordnungen definieren werde. Also Docker, wir benutzen
das Minus p hier. Wir werden dafür sorgen, dass
das ein Port ist. Und wir können hier sehen, dass es es
schon automatisch für mich füllt. Aber im Grunde werden wir danach einen Doppelpunkt
haben. Wir gehen auf eine neue Linie. Und dann haben wir
einen Strich, der anzeigt, dass dies ein Array sein
wird. Wir können also mehrere
Port-Mappings durchführen , denn
wir werden nur eine Port-Zuordnung
verwenden, hier
wird es wieder von Port
80 zu Port 80, 80 sein, so. Und hier können wir sehen, dass wir das auf Port 80, 80
beginnen. Deshalb möchten wir sicherstellen
, dass unser externer Port dem
richtigen Insight-Port zugeordnet
ist. Das Gleiche, was
wir beim Ausführen der einzelnen
Docker-Datei behandelt haben. Und das ist es tatsächlich,
was wir brauchen, um im Wesentlichen das zu reproduzieren, was wir
mit unserem Docker-Build hatten. Also lasst uns weitermachen
und das durchdrehen. Das erste, was
wir tun müssen, um das zum Laufen zu bringen , ist, dass wir
den Befehl Docker dash
composed verwenden können . Und dann tippen wir
hier oben ein. Und wir werden auch
ein zusätzliches Flag hinzufügen , das minus minus Build sein
wird. Das bedeutet also
, dass wir unseren Container hochdrehen, ihn
aber auch zuerst bauen werden
. Also baue es zuerst, als es auszugeben. Also lasst uns weitermachen und das ausführen. Ich werde mir wahrscheinlich nur ein
bisschen Zeit
nehmen, um zu bauen. Das meiste davon sollte zwischengespeichert werden. Und lass uns hier nachsehen. Es wird gerade noch erstellt.
In Ordnung, also los geht's. Wir haben unseren Container in Betrieb. Und wenn ich darauf klicke, sollte
ich darauf zugreifen können. Wenn Sie also auf die Dokumentenseite gehen und einen dieser Endpunkte ausprobieren. Ordnung, los geht's, Cool. Das ist also der Standardwert , den wir haben und er funktioniert. Wenn wir
es dann wieder abnehmen wollen, na ja. Jetzt führen wir
es nicht im Daemon-Modus aus. Wenn ich also einfach Control C drücke, wird
es tatsächlich gestoppt, was wir sehen können, wenn
wir hierher zurückkehren und es
aktualisieren, ist es jetzt unten. Aber wenn wir
es im Daemon-Modus ausführen wollen, wie wir es für unseren Docker getan haben. Wenn es also
im Hintergrund läuft und hier nicht
den Vordergrund einnimmt, werde
ich
dasselbe tun, minus, minus Build. Und dann
füge ich
hier ein Minus-d-Flag hinzu und führe das noch einmal aus. Auch hier
sollte das Ganze zwischengespeichert werden, also sollte es ziemlich schnell gehen. Und los geht's. Jetzt läuft es
immer noch im Hintergrund. Ich kann docker ps machen, um zu sehen
, dass das tatsächlich läuft. Und wenn ich mich erfrischen gehe, dann rennen wir wieder. Wenn ich
den Dienst herunterfahren möchte, kann
ich Docker Compose Down machen, was das alles einfach
beenden wird. Und noch einmal, wenn ich das auffrische, los
geht's. Läuft nicht mehr. Ordnung, soweit so gut, oder? Ziemlich einfach und
ziemlich praktisch. Aber bis jetzt kein großer Unterschied zur Verwendung
des Docker-Befehls, oder? Es ist, es ist ein bisschen kürzer weil wir den Build and
Run-Schritt hier irgendwie
gleichzeitig ausführen können , aber immer noch nicht so viel kürzer. Lassen Sie uns also ein bisschen
näher
darauf eingehen und uns einige
der anderen coolen Dinge ansehen , die wir tun können. Eines der Dinge, die zusätzlich
tun können,
ist, dass wir diese
Einstiegsvariable definieren können. Und hier werden wir
die gleiche Syntax verwenden , die wir in unserem Befehl
hatten. Es wird
das übernehmen und es kopieren. Aber vielleicht möchte ich das
eigentlich tun, ich werde das hier drüben kopieren
, wenn wir
unsere Docker-Datei erstellen und sie irgendwo ausführen
wollen. Wir
wollen es natürlich nicht mit dem Dash,
Dash Reload Flag ausführen ,
weil das eine Menge Overhead
hinzufügen wird , den wir nicht wollen. Aber wenn wir uns lokal
entwickeln, ist
es wirklich schön
, diese Flagge zu haben, weil wir Dinge ändern und
Dinge schaffen können. Wir können uns einfach schneller entwickeln
, weil wir nicht
herunterfahren müssen , wenn wir
unsere Anwendung starten. Im Idealfall könnten wir also
dieses Minus-, Minus-Reload-Flag verwenden . Wenn wir also
einen Einstiegspunkt auf unserer
Docker Compose-Ebene definieren , wird
er tatsächlich diese Einstiegspunkte oder
diesen Befehl anstelle des
letzten
Befehls
verwenden diesen Befehl anstelle des , den wir hier haben. Also in diesem Fall, wenn
ich das erneut ausführe, docker-compose, und
ich baue es und führe es aus. Und David Mode, wir
werden es in einer
Sekunde sehen . Das werden wir eigentlich nicht. Also werde ich es
herunternehmen und
nicht im Daemon-Modus ausführen ,
damit wir die Ausgabe
direkt sehen können . Machen wir das
noch einmal. Hier sehen wir, dass wir unseren Prozess
neu geladen haben. liegt daran, dass wir
dieses Reload-Flag jetzt aktiv haben. Wir können also sehen, dass das richtig
funktioniert. Leider, weil wir
in einem Docker-Container laufen. Also wenn ich das aktualisiere, funktioniert
das wie beabsichtigt. Aber wenn ich versuche,
irgendwelche Änderungen vorzunehmen, zB hier
reinzugehen und vielleicht nur den
Namen dieses Endpunkts zu aktualisieren, füge einfach
etwas Zufälliges hier hinzu. Wir können bereits sehen,
dass es nicht neu gestartet wird. Und wenn ich hier aktualisiere, wird es auch nicht aktualisiert. Aber im Idealfall
möchte ich, dass dieses Ding laufen lassen und meinen Code bearbeiten kann
. Und da ich genau wie damals
bearbeite , als wir es
lokal ohne Docker ausgeführt haben, möchte
ich in der Lage sein, diese
Updates zu aktualisieren. Die Art und Weise, wie wir
das machen werden, ist, dass
wir es wieder abbauen werden. Wir werden hier eine
zusätzliche Komponente hinzufügen, die als
Volume oder Volumes bezeichnet wird. Und die Volumina ermöglichen es
uns im Wesentlichen externe Lager Orten innerhalb unseres Containers
zuzuordnen. Und Volumes sind sehr
nett, weil sie uns eine persistente
Speichermethode
bieten. Also
können unsere Container runtergehen, oder? Wenn wir zum Beispiel unser Docker-Ding laufen lassen
und Dinge speichern, wollen
wir im
Idealfall nichts in
unserem Container speichern , weil dieser
Container heruntergefahren werden kann. Und die Art und Weise, wie unsere
Container funktionieren
sollten, ist, dass wir
nur in der Lage
sein sollten, einen neuen hochzufahren,
und er sollte genau
den gleichen Zustand
wie der vorherige haben . Als ob es
sich nicht mit der Zeit weiterentwickeln sollte. Wenn wir Informationen speichern wollen, senden
wir sie entweder irgendwo an Datenbanken. Oder wenn es sich um eine Datenbank selbst
handelt, sollte sie sie
in einer Art
Speicher speichern , sodass der Speicher auch dann verfügbar ist, wenn
der
Container ausfällt . Und genau das ermöglicht uns dieses
Volumen. Es ermöglicht uns,
externe
Speicherorte Orten in
unserem Docker-Container zuzuordnen. Wir können dies für Datenbanken verwenden
, die wir später sehen werden, um Daten beim Hoch-
und Herunterfahren einer Datenbankinstanz beizubehalten. Aber wir werden
es vorerst verwenden, wenn wir
unsere lokalen Zustände unseres Codes dem Zustand
des Codes in
unserem Docker Compose zuordnen. Was ich tun werde,
ist unser aktuelles Verzeichnis zuzuordnen. Dieser Ort hier in
unserer Docker-Akte. Und das sollte nicht hier sein. Also lass uns das noch einmal
durchgehen, dann lass es uns laufen und
sehen, wie es funktioniert. Und dann nehmen Sie sich vielleicht noch ein paar Minuten Zeit, um darüber
nachzudenken, was hier
wirklich vor sich geht. Aber im Wesentlichen haben
wir in unserer Docker-Datei hier eine neue SRC-App für den
Ordnerspeicherort erstellt. Und im Wesentlichen, weil
wir
diese App in diesen
App-Ordner kopieren , in diesem Pfad, diesen Speicherort, an dem
wir uns in diesem Ordner befinden, repräsentiert
dieses Verzeichnis im Wesentlichen das, was wir hier haben. Wir haben nicht alles kopiert, aber im Grunde genommen, richtig,
das ist es, was wir haben. Wir haben die
Dinge kopiert, die wir brauchten. Also wenn ich hier das
Mapping hinzufüge, zB unseres aktuellen Standorts zu diesem Speicherort in
der Docker-Datei. Dann eigentlich, und ich
zeige dir das jetzt, und ich füge das
Minus-d-Flag erneut hinzu. Denn jetzt können wir es im Hintergrund
laufen lassen. Jetzt werden wir
diesen Ort in
unserer Docker-Datei
diesem Ort zuordnen , der sich derzeit
auf unserem lokalen Computer befindet. Sehen wir uns das in Aktion an. Also wenn ich das aktualisiere,
nimm es runter. Okay, da haben wir's. Jetzt haben wir immer noch
das, was wir hier haben. Lassen Sie uns jetzt weitermachen
und eine Änderung vornehmen. Ich füge hier ein
zusätzliches A hinzu, Save. Ich werde
die Dokumentation aktualisieren. Jetzt können wir sehen, dass unsere Updates
tatsächlich widergespiegelt wurden. Der
Grund, warum wir das tun
konnten , ist, dass wir
zuvor nicht
darauf zugreifen konnten, nachdem wir unser Docker-Image
erstellt haben unser Docker-Image
erstellt und mit
dem Container begonnen haben kann intern nicht auf
seinen Inhalt zugreifen. Aber jetzt haben wir
hier eine
Zuordnung dieses Ordners zu diesem Ordner erstellt . Und was wir auch tun könnten, ist, dass
wir tatsächlich
spezifischer sein und nur kartieren könnten. Und ich werde diese
Änderungen hier so rückgängig machen. Und lass uns Docker
Compose Down machen. Nur damit wir
von einer sauberen Weste beginnen. Wir können spezifischer sein und den
Bewerbungsordner, den wir
hier haben, der Anwendung zuordnen
, die wir dort haben. Also sind wir, weil wir das
in unsere Docker-Datei kopieren, so wie diese, die sich in diesem Pfad befinden wird
. Wir werden
hier eine
Zuordnung des App-Ordners zu dem Speicherort vornehmen , an dem die App
über eine und unsere Docker-Datei kopiert wird. Aktualisiere das noch einmal. Da haben wir's. Also was wir hatten, jetzt werde ich dieses
hier noch einmal
aktualisieren, speichern, aktualisieren. Und los geht's. Auch hier ermöglichen uns
Volumes,
diese Speicher aus
unserem Container einer
Art externem Speicher zuzuordnen diese Speicher aus
unserem Container einer . Und das ist wirklich nett, denn auf diese
Weise können
wir Daten auch draußen speichern. Und wenn ein Container ausfällt, können
wir ihn einfach mit
dem persistenten Volume verbinden. Sie haben keinen Zugriff
auf genau dieselben Daten. Was natürlich
sehr nett ist, wenn wir Datenbanken haben, die z.B. laufen und ja,
behalte das einfach im Hinterkopf. Das, wenn Sie
einen Docker-Container ausführen und in einer lokalen Datei speichern
. Sobald der Container heruntergefahren ist
, ist diese Datei weg. Wenn Sie also etwas benötigen, bewahren Sie es
immer irgendwo außerhalb Ihres Containers auf,
da Sie im
Container keinen wirklich einfachen
Zugriff darauf haben und wenn
es einmal heruntergefahren ist, ist es weg. Also behalte das einfach im Hinterkopf. Und hier helfen uns die
Bände wieder wirklich. Okay? Die Volumes sind also hübsch, das ist es, was
wir gerade haben, was im Wesentlichen
die Anwendung ist , die wir zuvor hatten. Lass es mich wieder runter nehmen. Jetzt können wir
viel mehr mit uns machen. Wir haben also unsere
aktuelle Bewerbung. Aber etwas, das wir auch tun
wollen, ist, dass wir in der
Lage sein wollen , unsere
Komponententests auszuführen, z. B. Idealfall würden wir das
im Docker-Container ausführen ,
weil das
genau das Setup ist , das wir machen zu haben, wenn es in der Produktion
läuft. Denn das ist der
springende Punkt, dass wir dieses
reproduzierbare Setup haben. Also werde ich einen neuen Service
erstellen. Ich nenne
diese App minus Test,
nur um darauf hinzuweisen, dass
es sich um eine Testversion von wrap handelt. Ich nehme das hier hin. Und ich werde einfach das meiste davon
kopieren. Und ich werde den Einstiegspunkt nicht
aktualisieren. Das ist nicht wirklich
wichtig. Und ich brauche auch kein
Port-Mapping, weil ich
eigentlich nichts mit unserem Testcontainer machen möchte. Und wenn ich
dieses Port-Mapping verwende, wird es einen
Konflikt geben, weil wir unseren
Systemport bereits diesem Port
zuordnen. Und so der Docker-Container, und wir können denselben Port nicht zweimal neu
zuordnen. Das wird also tatsächlich ein Problem
verursachen. Also müssen wir das sowieso
entfernen. Und ich werde jetzt, anstatt die App
zuzuordnen,
nur den App-Ordner, ganze Verzeichnis
zuordnen denn wenn wir
in eine Docker-Datei gehen, werden
Sie feststellen, dass wir
nicht wirklich kopieren über den Testordner, aber wir müssen immer noch Zugriff darauf
innerhalb eines Docker-Containers
haben . Wenn wir das jetzt ausführen, werden
wir tatsächlich zwei
separate Container laufen lassen. Die erste wird
Ihre Anwendung sein, die wir derzeit mit diesem
Schrägstrich-Slash-Reload-Flag verwenden, was uns ermöglicht, weil wir unseren Ordner
hier dieser Stelle
im Docker zuordnen Container
, um die Entwicklung durchzuführen und sie
in unserem Webbrowser anzusehen und damit herumspielen zu
können. Dieser Container hier wird im Wesentlichen
dafür verantwortlich sein , nur Komponententests
auszuführen , damit wir unseren Code
tatsächlich testen können. Okay? Ordnung, es gibt also noch einige andere Dinge, um die
wir uns kümmern müssen denn wenn wir in
unsere Docker-Datei gehen, wir
hier tatsächlich fest, dass wir
keine Dev-Abhängigkeiten installieren und wir brauchen die Dev-Abhängigkeiten, um unsere Unit-Tests
ausführen zu können. Was wir jetzt
tun müssen, ist, dass wir
unsere Docker-Datei aktualisieren müssen , sodass der
Installationsprozess, der
hier stattfindet, unterschiedlich ist,
je nachdem , ob wir uns in unserer Anwendung oder ob wir uns in die Anwendung , die nur
zum Ausführen von Tests gedacht ist. Also lasst uns das zuerst machen. Was wir jetzt brauchen, ist eine
Art, um
anzugeben, wo wir uns gerade befinden. Eine großartige Sache, die
Sie normalerweise
damit machen würden , ist die Verwendung von
Umgebungsvariablen. Leider haben wir
keinen Zugriff auf diejenigen innerhalb unseres
Docker-Containers, aber wir können
Build-Argumente bereitstellen. Die Art und Weise, wie wir diese
bereitstellen können, ist, dass
wir, anstatt hier nur
diese Build-Syntax zu verwenden, anstatt hier nur
diese Build-Syntax zu verwenden, dies tatsächlich
erweitern können. Und ich werde
zwei weitere Keywords angeben. Der Kontext wird also
wieder sein wo unsere Docker-Datei ist
oder wo wir dieses Ding vom Speicherort
aus
ausführen werden
, der nur
der aktuelle Speicherort sein wird. Dann. Jetzt können wir hier auch Build-Argumente
bereitstellen. Und wieder können wir dies
als Array bereitstellen , während die Liste, und wir
geben den Namen an, und dann geben wir den Wert
an. Also z.B. ich kann diesen Namen environment,
environment nennen und sicherstellen, dass
ich das richtig sage. Ich glaube schon. Der Wert
hier wird Test sein. Also werde
ich mir einfach einen Namen ausdenken, was ich Umgebung
nennen werde. Und das wird der Wertetest
sein. Und jetzt muss ich hier
oben etwas Ähnliches
tun , weil ich keine Dev-Abhängigkeiten in unserer Anwendung
installieren möchte . Und in diesem
Fall nenne
ich entweder dev oder vielleicht nenne
ich es lokal. Was ich jetzt tun möchte, ist dieses Gesetzesargument zu verabschieden. Jetzt muss ich in der
Lage sein, innerhalb eines
Docker-Containers darauf zuzugreifen . Und dann möchte ich unseren
Lauf hier aktualisieren, damit
ich, wenn wir, wenn diese
Umgebungsvariable hier test ist, wenn diese
Umgebungsvariable hier test ist, auch
Dev-Abhängigkeiten installieren möchte. Sonst tue ich das nicht. Ordnung, also das Wichtigste zuerst, um Zugang zu
diesem Gesetzesargument zu erhalten. Ich werde
dieses Args-Schlüsselwort verwenden. Und dann gebe ich hier
den Namen dieser Variablen ein. Jetzt gebe ich
uns Zugriff auf dieses Argument in
unserem Docker-Build hier. Ordnung, was wir jetzt tun
müssen, ist
diese Anweisung auf bedingt zu aktualisieren diese Anweisung auf bedingt zu und wir werden dafür eine
if-Anweisung verwenden, aber wir werden
eine bash IF-Anweisung verwenden, um sie
unter bestimmten Bedingungen
zu installieren Entwickler-Abhängigkeiten. Wenn dieser Umgebungswert hier ist, wird getestet, um eine
if-Anweisung und eine Bash zu schreiben. Und wir werden hier nicht zu sehr
ins Detail gehen, sondern nur
irgendwie durch
die Knochen gehen , um genug zu haben
, um das schaffen zu können. Denn die meiste
Zeit, in der Sie möchten, brauchen Sie nicht mehr als das. Und falls Sie das jemals tun sollten,
weil Sie wissen wie man bedingte
Anweisungen in Python schreibt, werden
Sie die Logik verstehen und Lage
sein, sie in bash zu übertragen. Sie müssen nur die entsprechende Syntax
nachschlagen. Die Syntax wird also wenn und dann eckige Klammern öffnen und
schließen. Und dann
werden wir hier IF setzen. Und um auf die
Umgebungsvariable in Bash zugreifen zu können, müssen
wir ein
1-Dollar-Zeichen davor setzen. Also wenn das bill-Argument, wenn der Wert dieses Build-Arguments ist, auf
das wir Zugriff haben, weil wir es hier oben definiert haben. Wenn dieser Wert
dem String-Test entspricht. Nun ist es sehr wichtig,
Leerzeichen vor oder nach und
vor dem Öffnen und Schließen
dieser eckigen Klammern zu haben. Dann setze ich hier
ein Semikolon. Dies ist wichtig, denn
wenn wir in Bash
mehr als einen Befehl in
derselben Zeile haben wollen , müssen
wir
diese durch Semikolons trennen. Andernfalls würden wir
neue Linien schaffen , die
auch diesem Zweck dienen würden. Aber weil wir das
meiste davon
in derselben Zeile haben würden , werde
ich hier
ein Semikolon setzen. Wenn unsere Umgebung also Test ist, dann wollen wir
mit Dev-Abhängigkeiten installieren. Also dann wollen wir hier
dasselbe tun, aber mit Entwicklerabhängigkeiten. Nochmals, Doppelpunkt, denn
das ist alles in einer Zeile. Jetzt, weil wir über eine Zeile
gehen werden, weil ich dieses
Ding
nicht haben möchte oder auf der
rechten Seite
ins Unendliche rennt . Wir können aber auch sehen, dass wir hier Vorschläge für ähnliche
Margen haben , und wir wollen das nicht durchgehen. Also um fortzufahren,
etwas , das
auf derselben Linie war. Und wir geben
einen Zeilenumbruch ein, den wir mit dem Backslash
machen können . Wir werden das in der nächsten Zeile fortsetzen
. Und dann werden wir unsere anderen Aussagen
haben. Noch ein Doppelpunkt hier. Und um diese Aussage zu beenden, machen
wir FI, also das Gegenteil von f. Also lass uns das
noch einmal durchgehen. Was haben wir gemacht? Wir haben ein Build-Argument erstellt
, das wir bereitstellen, während wir unser Image
mit diesem Wert hier aufbauen Dann erhalten
wir hier Zugriff auf
das verschüttete Argument. Und wir greifen hier auf
seinen Wert zu. Wir vergleichen es hier mit
dem Wertetest, indem wir ein
einzelnes Gleichheitszeichen verwenden. Dann haben wir eine
bedingte Aussage. Wenn dieser Wert also test ist, dann machen wir diese
install-Anweisung und
wir haben dieses Minus,
minus dev tall, einige
Stall-Dev-Abhängigkeiten hinzugefügt . Andernfalls machen wir
einfach unsere normale Installation. Und dann haben wir hier ein paar
spezielle Keywords. Nur weil das irgendwie so ist
, sieht die
if-Anweisung
so aus . Das
musst du schreiben. Ordnung? Okay, also lasst uns, nun,
fangen wir damit an. Das tun wir nicht, wir
führen unsere Tests noch nicht durch, aber wir können, wenn wir wollen. Wenn wir
wollten, könnten wir z.B. unseren Einstiegspunkt hier
so aktualisieren, dass er stattdessen so etwas wie pi-Test und Tests ist. Aber wir werden nach
einem besseren Weg suchen , wie wir das in einer Sekunde
tun können. Denn wenn wir es so machen, wird es nur
auf einmal laufen, wenn wir angefangen haben. Aber im Idealfall könnten wir einfach
nach Belieben hingerichtet werden. Ordnung, also werde
ich den Build gerade
nicht im David-Modus ausführen , damit wir die vollständige Ausgabe sehen können. Stimmt's? Dieses Mal wird es also etwas länger
dauern weil wir
unsere Aussagen hier aktualisiert haben. Und so gehen wir jetzt
nicht mehr von Bargeld aus, sondern
müssen dieses Ding wiederholen,
was eigentlich die
Installation von Komponenten, das
Abrufen von
online und das Herunterladen
während der
Installation beinhaltet Abrufen von
online und das Herunterladen verarbeiten. Es wird also ein
bisschen länger dauern, hoffentlich
nicht zu lange, weil alles andere
noch zwischengespeichert werden sollte. Warte, bis das
fertig ist. In Ordnung, also ist unser Build endlich fertig. Alles fängt an. Wir können hier sehen, dass dies
unser erster Container ist, der läuft, und dies ist unser zweiter. Und hier können wir tatsächlich
die Ergebnisse der Tests sehen. Wir haben neun Tests bestanden und der andere
Container läuft noch. Also werde ich einfach eine Schleife machen, also will ich nicht, dass das irgendwo
auf einen Link hier geklickt hat. Ordnung, also lasst uns das
abnehmen. Ordnung, also haben wir das zum Laufen gebracht. Hervorragend. Jetzt
werden wir diese Tests aktualisieren, anstatt
diese Tests nur einmal auszuführen. Stattdessen werden wir
lernen, diese Tests durchzuführen, wann immer wir wollen, gegen Ihre Container. Also werde ich das bauen, das
drehen, es erneut in Rechnung stellen, es
ausführen und den Daemon-Modus. Wenn sich kein Code geändert hat, müssen
Sie ihn auch nicht neu erstellen, wodurch
der Prozess natürlich schneller wird. Wenn wir es also so machen,
wird nur
das vorhandene Image, das
wir dafür erstellt haben, hochgefahren . Oder besser gesagt, wenn wir das Build-Flag
hinzufügen, wird es neu erstellt. Und selbst wenn
alles zwischengespeichert ist, dauert es
offensichtlich immer noch
ein bisschen länger. Um nun unsere Tests diesem
Testcontainer durchzuführen, den wir hier haben, werden
wir
docker ps, dash compose verwenden. Und dann
tippen wir hier exit exec ein. Also werden wir
etwas gegen etwas ausführen. Unser Ziel wird
dieser App-Dash-Test-Service sein , den wir hier haben. Und was wir ausführen werden, der Befehl, den wir
ausführen werden, es werden Pi-Testtests
sein. Also führen wir hier einen Pi-Test
gegen unseren Tests-Ordner durch. Wenn ich Enter drücke und los geht's. Also führen wir unsere Tests durch. Und jetzt ist das
wirklich nett, weil alles
in einem Docker-Container läuft. Wir haben mehrere
Docker-Container. Wir haben hier zwei separate
Container in Betrieb. Eine davon können wir
für die lokale Entwicklung nutzen. Wir können unsere Änderungen vornehmen. Also sieh dir das einfach nochmal an. Wenn ich das entferne, sollte es immer noch verschwinden. Und wir haben dieses Mapping
wegen des Volumens. Wir haben mehrere
Container in Betrieb. Eine davon
simuliert, was wir
in der Entwicklungsproduktion haben werden, außer dass wir
dieses Flag außer Kraft gesetzt haben, um neu zu laden. Dieser. Obwohl wir hier nie eine
der Testdateien
kopiert haben, weil wir
sie nicht in unserem endgültigen Image haben wollen weil wir hier ein
Volume-Mapping verwenden. all das haben wir hier eigentlich noch
Zugriff. Denn die Art und Weise, wie
dieser Ordner
in einem Docker-Image aussieht , wird jetzt tatsächlich durch das
dargestellt, was wir hier lokal haben. Dann konnten wir
diesen Docker Compose exec
Befehl verwenden , um einen Befehl für ein
bestimmtes Ziel auszuführen. Dies ist der Name
, den wir hier haben. Und das ist der Befehl , gegen den wir ausführen werden
,
was bedeutet, dass
wir, wann immer
wir Änderungen vornehmen, auch einfach unsere Änderungen hier vornehmen, unsere Tests hier
aktualisieren
und dann, wenn wir ausführen a führe es aus, wir können einfach
die Tests dagegen ausführen. Und mit dieser Art von Lauf unsere Komponententests und
alles in einer wirklich schönen reproduzierbaren Docker-Umgebung,
was großartig ist. Und mit diesem Setup können
wir dann in Zukunft
sehen, dass wir viel
mehr Dinge damit machen können. Wir können z.B. ähnliche
Umgebungsvariablen hinzufügen. Wenn wir
hier nur eine zusätzliche Tastatur haben, können wir schon sehen. Wir können das Zeug füllen. Wir können zusätzliche Dienste hinzufügen, die wie unsere
Datenbanken und unser Cache sein werden, z. B. oder wenn Sie tatsächlich mehrere Dienste
erstellen , die sich vielleicht gegenseitig
kontaktieren möchten, können
Sie tatsächlich
alle haben von diesen Diensten werden verschiedene Dienste
, die Sie aufbauen gleichzeitig
ausgeführt. Sie können sie also alle
testen, als
würden sie irgendwo live laufen. Und das gibt
uns wirklich viel Power,
weil wir in der Lage sind,
einfach alles hochzudrehen , es miteinander sprechen zu
lassen und auf sehr schöne und
reproduzierbare Weise zu testen . Also ja, Docker Compose. Ich hoffe du findest es nützlich. Und wieder
gibt es hier viel mehr
Argumente, die wir uns
angesehen haben oder die wir nicht betrachtet die wir uns nicht angesehen haben die zusätzliche
Funktionalität bieten. Und wenn Sie jemals
etwas anderes mit dunklerem benötigen, können
Sie einfach
nachschlagen, was
der Variablenname ist , den ich hier
angeben muss und wie
kann ich das eingeben? Sie können
das und Docker Compose festlegen. Und ich persönlich
bevorzuge das viel mehr, weil unsere Befehle hier viel
kürzer sind als diese längeren Docker-Befehle. Und wieder können wir in
diesen YAML-Konfigurationsdateien alles
definieren diesen YAML-Konfigurationsdateien , was jemand anderes
einfach annehmen und ausführen kann. Sonst
müsstest du
ihnen deine exakte Kopie von,
ähm, welchem Befehl
du gerade ausführst, schicken ihnen deine exakte Kopie von, . Drehen Sie Ihren Container
aus einem Bild heraus, wenn Sie viele
Umgebungsvariablen oder
ähnliches bereitstellen möchten. Während
wir mit diesem
Docker Compose YAML all
dies vorkonfigurieren können. Und hoffentlich sollte
jemand anderes der Lage sein, all das zu
übernehmen , es
hochzudrehen,
Docker Compose auszuführen und genau
dasselbe zu haben. Und es macht einfach
alles rundum einfacher, alles rundum einfacher denn wenn man diesen Punkt
erreicht hat, ist es
offensichtlich ein
bisschen Arbeit, hierher zu kommen. Aber sobald Sie diesen Punkt erreicht
haben, sind Sie an einem wirklich schönen Ort. Wir sind in der Lage,
reproduzierbare Dinge zu haben. Weißt du, was du hier hast, ist wie es sein wird, wenn
du es woanders laufen lässt. Es ist sehr einfach, Änderungen
vorzunehmen, neue Dinge
hinzuzufügen und alles wie
reproduzierbar und testbar zu halten und alles so. Eine kurze weitere Sache , die ich Ihnen zeigen möchte, ist, dass Sie
manchmal z. B.
mehrere Docker-Compose-Dateien haben . Und im Wesentlichen lass uns haben, ich werde hier ein
neues Verzeichnis erstellen. Ich nenne
es Schuldentest, DC. Wir werden sicherstellen, dass meine vorhandenen Container
abgebaut werden. Da haben wir's. Und
dann verschiebe ich
einfach diese
Docker-Compose-Datei hierher. Nehmen wir an, wir wollen verschiedene Komponisten
für verschiedene Szenarien
haben . Wenn Sie jemals so
etwas brauchen, kann ich
ein
Minus-F-F-F-F-F-F-F-F-F-F-F-F-F-F-Flag hinzufügen , wo das ist. Wenn ich das jetzt ausführe, wird es
nicht funktionieren, weil es keine Docker-Compose-Datei finden
kann. Aber wenn ich hier ein
Minus-f-Flag hinzufüge, kann
ich auf meine
Datei zeigen, die Intestacy Slash Docker,
compose, YAML
sein wird, das
ist unser Dateiname. Und dann können wir
versuchen, es erneut auszuführen. Und bam, los geht's. Es funktioniert. Also einfach eine kurze Seite für den Fall, dass Sie jemals auf so etwas
stoßen. Um es herunterzufahren, mussten
wir natürlich dieselbe
Syntax haben, um es herunterzufahren. Und das werde ich hier wahrscheinlich
nicht wollen. So das hier hinten. Offensichtlich. Das ist nicht so schön, als es
einfach direkt
hier zu haben und genau
so behalten es viele. Aber nur kurz beiseite, falls Sie jemals auf so
etwas stoßen, dann
können wir das auch so angehen. Aber ja, das ist also dunkler. Eine Menge Docker Docker komponieren. Und obwohl wir
viel Arbeit geleistet haben , um das
zu bekommen, haben wir jetzt einen wirklich
schönen Punkt erreicht, an dem
wir wieder sehr wenige
Befehle haben, die
sehr kurz und
lesbar sind und die Wir bauen sehr komplexe Systeme und lassen sie auf eine
Weise laufen, die reproduzierbar ist, was einfach super nett ist, weil dies
Ihnen viel Sicherheit geben kann um sicherzustellen, dass die
Dinge laufen so wird es sein, wie
die Dinge woanders
liefen. Was
wirklich, sehr nett ist. Ja. Ich weiß, dass einiges von dem
Zeug
etwas verwirrend sein kann , wenn man es sich das erste Mal
anschaut. Es dauert einige Zeit, um mit einigen
dieser Dinge
herumzuspielen . Nehmen Sie sich etwas Zeit, um mit
diesem Band
herumzuspielen und zu
verstehen, was es bewirkt. Schauen Sie sich jedes der
Dinge an, die wir hier gemacht haben. Versuchen Sie vielleicht, einen weiteren
Build-Arc hinzuzufügen oder
die Benennung hier
zu ändern , nur um zu sehen, was passiert, um sicherzustellen, dass Sie sich damit
wohler fühlen. Aber mit der Zeit
werden Sie sich damit
wohler fühlen. Und auch hier liegt es daran, wenn wir
dieses Zeug aufbauen, viele dieser
Dinge aus offensichtlichen
Gründen ähnlich
aussehen werden . Sie werden es also im Allgemeinen auf die gleiche Weise
angehen. Und die meiste Zeit haben
Sie ähnliche Vorlagen, mit denen Sie arbeiten können, um diese Docker-Dateien zu haben. Und dann müssen Sie
nur noch anpassen, was Sie kopieren und wie Sie
die Installation durchführen und
so weiter, und so weiter. Aber vieles davon ist eigentlich wie Boilerplate-Template-Zeug. Sie wissen, dass Sie es wiederverwenden können. Und natürlich wollen wir es im Detail
durchgehen ,
nachdem wir ihr gerade beigebracht richtig
zu verstehen,
was vor sich geht ,
damit Sie wissen,
wenn Sie
es lesen oder Änderungen oder Ergänzungen vornehmen müssen ,
wenn Sie
es lesen oder Änderungen oder Ergänzungen vornehmen . wo man suchen muss,
man weiß, wonach man suchen muss. Aber ja, die meiste Zeit haben
Sie eine
Vorlage, an der Sie arbeiten können. Sie haben
jetzt eine Vorlage, vielleicht haben Sie eine Vorlage und Organisation
und Sie können online
Vorlagen finden , mit
denen Sie dieses
Endergebnis viel schneller erreichen können .
6. Makefile: Ordnung, also haben
wir einen langen Weg zurückgelegt und
es tatsächlich geschafft, einen Punkt zu erreichen,
was ziemlich nett
ist, wenn wir nicht so viel Zeug schreiben müssen , um die Dinge zum Laufen zu
bringen. Aber im Laufe der Zeit werden Sie
wahrscheinlich auch damit frustriert sein, immer wieder dieselben Dinge schreiben zu
müssen . Und es gibt noch mehr
Möglichkeiten, dies zu verkürzen. Um im Wesentlichen Verknüpfungen
für Befehle zu haben , die wir regelmäßig
ausführen. Nun, das wird
auf einem Mac und Linux funktionieren.
Ich denke, für Windows müssen
Sie ein
zusätzliches Setup durchführen , damit
diese Makefiles funktionieren, was wir uns jetzt ansehen werden. Aber im Allgemeinen ist
es unwahrscheinlich, dass
Sie in Windows arbeiten, wenn Sie
irgendwo in einer
Organisation arbeiten? Nicht ja, nicht dass es
unmöglich wäre, es ist nur viel
wahrscheinlicher , dass Sie
an einem Mac oder einem Mac oder Linux arbeiten. Also ja, ich
behalte das einfach im Hinterkopf. Wir werden das jetzt durchgehen,
weil es üblich ist , entweder Makefiles für
sich selbst zu erstellen oder sie
in einem anderen Repository zu sehen. Denn wie wir in einer Sekunde
sehen werden, wird
es Ihr
Leben viel einfacher machen. Auch für Windows gibt es
einige andere Dinge, die Sie
installieren müssen, damit
diese Befehle tatsächlich funktionieren. Gesucht, super wichtig
um das zum Laufen zu bringen. Seien Sie sich dessen bewusst,
dass diese Dinge existieren und
wir sie so betreiben können. Und du kannst sie erstellen, wenn
du willst, oder du kannst
sie weglassen , weil es
einfach
nette Dinge sind , die du einfach machen kannst. Kurz. Die Syntax ist noch kürzer. Aber ja, jedenfalls. Ordnung, also lass uns hier
eine neue Datei erstellen , die wir eine
Make-Datei wie diese nennen werden. Und in diesem Makefile werden
wir jetzt eine Reihe von
Befehlen
definieren , die es uns ermöglichen,
im Wesentlichen das zu
tun , was
wir hier hatten, wie der Docker,
dash minus d, nur damit wir das nicht
jedes Mal
aufschreiben müssen . Wir werden eine Abkürzung machen , die das für uns erledigt. Nun, eine sehr
wichtige Sache hier ist in: Wenn Sie in PyCharm sind, wie ich hier in dieser Datei bin, wollen
wir nach unten gehen und auf diese
vier Felder klicken und Ausdauer
für einfach
konfigurieren und verwenden Sie stattdessen Tabulatorzeichen. Weil das Makefile einen sehr, sehr spezifischen Unterschied zwischen
vier Leerzeichen und einem Tab hat. Während
es in anderen Fällen,
wie in Python, z. B. nicht
wirklich, wirklich einen großen
Unterschied macht. Es ist also in Ordnung, es so zu
benutzen. Aber in PyCharm werden Sie
feststellen, dass ich es hier gemacht habe Wenn Sie Visual Code verwenden, wenn Sie keinen
visuellen PyCharm-Code oder irgendetwas anderes verwenden, finden
Sie es wahrscheinlich an einem
ähnlichen Ort. Aber im Allgemeinen, wenn Sie
auf Probleme stoßen, besagen, dass ein Trennzeichen fehlt
oder was auch immer. Sehr wahrscheinlich ist das
Problem, auf das Sie stoßen, das, was wir wollen. Du hast vergessen, einen Doppelpunkt zu setzen,
was auch passiert. Aber zu den anderen sehr
häufigen Problemen, dass Sie Leerzeichen
anstelle von Taps verwenden. Okay. Ich zeige es Ihnen auch auf einem
zweiten kurzen Weg, um das zu sehen. Ich kann
das dafür tatsächlich ausschalten, nur um dir zu zeigen
, wie das aussehen würde. Ordnung, also das
erste, was wir
tun wollen , ist, dass wir hier einen Befehl
definieren
, den ich einfach
start aufrufen werde , weil er
kurz ist und ich ihn mag. Aber du kannst es wie auch immer nennen, wie rennen, drehen, was auch immer. Ich nenne es Start. Wenn wir diesen Befehl ausführen, wollen wir
diesen abzüglich des
Build-Teils haben , wie folgt. Jetzt werden Sie feststellen,
dass ich gerade
Leerzeichen verwende ,
denn wenn ich zurückkehre hierher
zurückkehre, werden Sie feststellen,
dass es viermal zurückgeht. Das sind also Leerzeichen. Und wenn ich dies von
vier Leerzeichen auf ein
Tabulatorzeichen ändere ,
lösche es und drücke erneut die Tabulatortaste. Jetzt, wenn ich von rechts nach
links gehe. Das ist also der Top-Charakter. Sehr großer Unterschied
bei der Verwendung von Leerzeichen hier. Du wirst auf Probleme stoßen
und es ist frustrierend. Ordnung, also müssen wir anfangen. Eine andere Sache, die wir sehr
häufig verwenden , ist Start mit Build. Also nenne ich das
start underscore build. Und hier
setze ich diesen Befehl einfach so ein. Eine andere Sache, die wir tun
wollen, ist es abzunehmen. Also benutzt du entweder Takedown, aber das ist ein langes Wort,
hör auf damit einfacher. Und wir machen Docker, komponieren so. Und eine andere Sache, die
wir wahrscheinlich
regelmäßig machen wollen , ist unsere Unit-Tests durchzuführen. Wir können sagen, dass
Komponententests Unit-Tests sind , um Plural zu verwenden, weil wir wahrscheinlich mehrere Tests ausführen. Und der Befehl, den
wir hier ausführen werden, wird der Befehl sein
, den wir zuvor gesehen haben. Also Docker Compose x minus t und es wird geeignet sein
zu testen, was gegen
diesen Container hier ist. Der Befehl, den
wir ausführen, ist pi test, Tests wie dieser. Okay? Das sind also
vier Befehle, die wir ziemlich regelmäßig verwenden werden. Und hier
haben wir unser Makefile. Es gibt eine Sache, die wir
oben hinzufügen möchten, nämlich
eine Liste der Straftaten bereitzustellen. Was dem Makefile im Wesentlichen
mitteilt , dass dies Befehle sind. Und wenn wir jemals
Dateien mit diesen Namen haben
, wenn wir sie
mit dem Befehl make verwenden, was wir in
einer Sekunde sehen werden, dass es diese als Befehle behandeln
sollte. Wir werden
all diese Befehle hier platzieren , die wir verwenden wollen. fange einfach an, dass wir anfangen müssen, Build
zu unterstreichen. Wir haben Stopp, wir
haben Unit-Tests. Ordnung, lass mich sehen,
ob irgendwas läuft. Ist es. Also mache ich, nun,
lass uns unseren Hauptbefehl benutzen. Also habe ich diese beiden
noch vom letzten Mal laufen lassen. Was ich tun werde ist jetzt make stop einzugeben, wodurch
dieser Befehl hier ausgeführt wird. Wenn ich die Eingabetaste drücke. Und wir können sehen, dass es
diesen Befehl ausführt und
alles abschaltet. Wir können damit beginnen , das zu betreiben, und es wird die
Dinge für uns wieder in Schwung bringen. Also sieh hier, wenn ich
es aktualisiere, ist es Hold on 1 s. Da geht's. Ordnung, nehmen wir
es wieder runter und hören auf. Und los geht's. Wenn ich mich jetzt erfrische, los geht's. Also nicht mehr rennen.
Eine Sache zu beachten: Wenn Sie diese Befehle nicht
sehen möchten, können
wir vor allem At-Symbole
hinzufügen. Nun, wenn wir aufhören,
oder führe ich das schon durch? Entschuldigung, mic, fang an. Jetzt werden wir nicht sehen, dass
der Befehl es ausdruckt. Das ist also nur ein bisschen
, um Sachen auch hier zu bekommen. Wenn wir unsere Komponententests,
Unit-Tests, ausführen möchten, die sie für
unsere Testanwendung hier ausführen , einfach diesen Befehl aus,
wie wir ihn zuvor gesehen haben. Bam, los geht's.
Ein weiterer Befehl, den wir vielleicht ausführen möchten, ist unsere Eingabe zu
überprüfen. Damit wir die Eingabe überprüfen können. Und ich werde
diesen Befehl hier ausführen oder gegen
unseren Testcontainer laufen. Ich werde
meinen Kuchen so laufen lassen,
wie wir es zuvor getan haben. Und dann können wir überprüfen, ob wir das falsch
eingeben. Und wir sagen, mach check typing, was jetzt die Typisierung mit unserem
Testcontainer hier
überprüfen sollte . Während das läuft, lassen Sie uns eine Abkürzung
machen, denn manchmal möchten wir vielleicht Komponententests hier
in unserem Container
durchführen. Aber in einigen Fällen, wenn Ihr Container Docker Compose sehr groß wird
und Sie nicht möchten all diese Dinge ausgeführt dass all diese Dinge ausgeführt
werden, wird möglicherweise auch etwas
ausgeführt, das Sie
stattdessen tun könnten . Dinge vor Ort. Vielleicht möchte man manchmal einfach keinen Container
hochschleudern, weil vielleicht auch der Container
einfach viel kostet. Was wir stattdessen tun können,
ist auch einfach Aliase dafür hinzuzufügen und sie dann wiederzuverwenden. Also lasst uns z.B.
einen Unit-Test-Alias erstellen. Und das hier wird,
tut mir leid, es sollte ein Gleiches geben. Es werden
Pi-Testtests wie dieser sein. Und wenn wir uns jetzt auf Pi-Testtests beziehen
möchten, können
wir stattdessen
auf diesen Alias verweisen indem wir
hier das 1-Dollar-Symbol verwenden und dann
Klammern um ihn herum öffnen und schließen. Und so können wir unsere Unit-Tests wie
zuvor durchführen. So wie das. Wir können auch
einen anderen haben, der Unit-Tests sein wird . Lokal wie dieses, das gerade
unsere Unit-Tests durchführen wird. Und das
wird wahrscheinlich scheitern, weil ich mich gerade nicht in meiner virtuellen
Umgebung befinde. Aber mal sehen. Ja. Also lass uns
weitermachen und Penn Shell auswählen. Und lassen Sie uns wieder
Unit-Tests lokal durchführen. Ich werde hier ein
neues Terminal eröffnen und mich in einen seltsamen Zustand versetzen. Führen Sie lokale Unit-Tests durch. Ordnung, also los geht's.
Das ist also ein netter Weg wie wir dieses
und ähnliche Dinge wiederverwenden können, insbesondere dort, wo
Befehle länger werden. Sundance ist auch so,
wie Sie Befehle haben , die
über mehrere Zeilen gehen, die wir wiederum trennen
können, solche
Zeilenumbrüche verwenden. Wenn das z.B. auf eine neue Zeile
übergehen würde, könnte
ich das stattdessen trennen. Aber wenn wir längere
Befehle haben und es manchmal
auch schöner ist , nur einen Alias
für sie erscheinen zu lassen, auf den wir hier unten verweisen
können. Nur damit, weißt du,
dieses Zeug
lesbarer wird und nicht so
verstopft wird. Und ja, das ist es,
was wir zum Tippen machen. Und mehr, tut mir leid, nicht fürs Tippen. Das können wir hier
für unsere Makefiles tun, was wiederum nur ein
bisschen mehr Einfachheit hinzufügt und ihre
Befehle etwas
kürzer macht als make
stopped to take down oder Container stattdessen
von Docker Compose down. Wenn ich bauen will, beginne
ich mit dem Build. Einfach nochmal gekürzt gesagt. Nur ein bisschen. Und ja, so etwas schließt
das ab. Es gibt noch eine Sache
, die ich erwähnen wollte, nichts mit unseren Makefiles zu tun hat, die sich nur die Logs ansehen
werden. Etwas, das ich ziemlich einfach
finde wenn wir wie
ein Docker-Container läuft, ist, wenn ich hier oben
in unseren Docker-Desktop gehe , kannst
du in diese klicken und die Logs direkt hier
sehen. Aber nur eine kurze Nebensache, weil wir das nicht
wirklich gemacht haben,
ist, wenn Sie sich die
Protokolle ansehen möchten und
dies über das Terminal tun möchten, dann gibt es den Befehl
docker logs. Wenn wir also auf eine
Container-ID verweisen, z. B. unsere Hauptanwendung, und wir
wollen uns die Logs ansehen. Wir können es so betrachten. Phi one, um in
unsere Testanwendung zu schauen und diesen
Befehl einfach hier rein zu geben. Da haben wir's. haben
wir momentan nicht
viele Logs. Aber nur für den Fall, dass Sie dies jemals tun
möchten und Docker
Desktop dafür
nicht verwenden möchten, können Sie
dies auch
über die Befehlszeile tun. Da machen wir eine Menge
Sachen für die Kommandozeile. Und manchmal kann das auch einfach einfacher für diesen Prozess sein. Also, ja, hoffentlich findest
du es auch nützlich,
diese Makefiles zu haben. Sie werden
sie wahrscheinlich auch sehen und
in welcher Organisation auch immer
Sie beitreten werden, verwendet , dass sie
dort Makefiles haben, um nur
eine Liste von Befehlen zu haben , die einen bestimmten Prozess ausführen,
machen es
einfach Alles sehr einfach, nur Makefiles dafür
zu haben
, damit es noch einfacher auszuführen ist und Sie niemand anderem sagen müssen, was der Befehl ist. Sie können einfach
den Befehl make ausführen und sind sehr einfach zu schreiben. Und wieder eine sehr schöne Möglichkeit, diese
reproduzierbaren Dinge zu bekommen. Und offensichtlich machen sie unser Leben viel schöner, weil wir noch weniger
schreiben müssen.