Oracle Cloud Infrastructure-Dokumentation

Kubernetes: Node Express-Anwendung bereitstellen

In diesem Tutorial richten Sie mit einem Oracle Cloud Infrastructure-Account ein Kubernetes-Cluster ein. Anschließend stellen Sie eine Node Express-Anwendung in Ihrem Cluster bereit.

Zu den wichtigsten Aufgaben gehören:

  • Richten Sie ein Kubernetes-Cluster in OCI ein.
  • Richten Sie die OCI-CLI für den Zugriff auf das Cluster ein.
  • Erstellen Sie eine Node Express-Anwendung und ein Docker-Image.
  • Übertragen Sie das Image per Push an OCIR.
  • Stellen Sie Ihre Node.js-Docker-Anwendung in Ihrem Cluster bereit.
  • Stellen Sie eine Verbindung zur Anwendung über das Internet her.
Ein Diagramm der Komponenten, die zum Ausführen einer NodeJS Express-Anwendung auf der Oracle Cloud Infrastructure Kubernetes Engine erforderlich sind

Weitere Informationen finden Sie hier:

Bevor Sie beginnen

Für eine erfolgreiche Ausführung des Tutorials benötigen Sie Folgendes:

Anforderungen
  • Für Container Registry, Kubernetes und Load Balancer:
  • So erstellen Sie Anwendungen und Docker-Images:
    • Eine der folgenden lokalen Umgebungen:
    • Die folgenden Anwendungen in Ihrer lokalen Umgebung:
      • JDK 11 und JAVA_HOME in .bashrc festlegen.
      • Python 3.6.8+ und Pip-Installationsprogramm für Python 3
      • Kubernetes-Client 1.11.9+
      • Apache Maven 3.0+
      • Docker 19.0.3+
      • Git 1.8+
      • Node.js 10+
Hinweis

Wenn Sie die erforderlichen Anwendungen nicht in Ihrer lokalen Umgebung einrichten möchten, können Sie stattdessen Oracle Cloud Infrastructure Cloud Shell verwenden. Der Vorteil der Verwendung von Cloud Shell besteht darin, dass alle erforderlichen Tools zur Verwaltung Ihrer Anwendung bereits installiert und einsatzbereit sind. Befolgen Sie die Schritte 1 und 2 in:

Kubernetes mit Cloud Shell: Spring Boot-Anwendung bereitstellen

Anwendungen für Linux auf OCI Free Tier herunterladen

Wenn Sie eine OCI Free Tier-Linux-Compute-Instanz zur Verwaltung des Deployments verwenden möchten, erhalten Sie in den folgenden Abschnitten Anweisungen zur Installation der erforderlichen Software.

Linux-Instanz installieren
  • Installieren Sie eine Linux-VM mit einer Compute-Ausprägung vom Typ Immer kostenlos auf Oracle Cloud Infrastructure. Sie benötigen einen Rechner mit SSH-Unterstützung, um eine Verbindung zu Ihrer Linux-Instanz herzustellen.
    • Oracle Linux-VM installieren
      • Befolgen Sie die Abschnitte 2 und 3.
      • Wenn Sie über einen kostenpflichtigen Account verfügen, wählen Sie für Abschnitt 2 die Compute-Optionen basierend auf Ihren Angeboten aus.
      • Sie stellen eine Verbindung zur Instanz her, indem Sie die in Abschnitt 4 genannten Schritte 1-5 ausführen.
      • Überspringen Sie die Apache-Anweisungen.
    • Ubuntu-VM installieren
      • Befolgen Sie die Abschnitte 2 und 3.
      • Wenn Sie über einen kostenpflichtigen Account verfügen, wählen Sie für Abschnitt 2 die Compute-Optionen basierend auf Ihren Angeboten aus.
      • Sie stellen eine Verbindung zur Instanz her, indem Sie die in Abschnitt 4 genannten Schritte 1-5 ausführen.
      • Überspringen Sie die Apache-Anweisungen.
      • Befolgen Sie zum Aktualisieren der Firewalleinstellungen Schritt 8 in Abschnitt 4.
Node.js installieren

Installieren Sie Node.js auf Ihrem System.

Installationsbefehle ausführen

Um Node.js und NPM zu installieren, führen Sie die folgenden Befehle aus:

  1. Oracle Linux: 
    sudo yum update

    Richten Sie das Yum-Repository für Node.js ein. Installieren Sie dann das Package nodejs.

    sudo yum install -y oracle-nodejs-release-el7
sudo yum install -y nodejs
  2. Ubuntu: 
    sudo apt update

    Installieren Sie die Packages nodejs und npm.

    sudo apt install -y nodejs
sudo apt install -y npm
  3. Prüfen Sie die Installation. 
    node -v
npm -v
Firewall konfigurieren (optional)

Wenn Sie browserbasierte Tests der Node-Anwendung durchführen möchten, machen Sie Port 3000 auf Ihrer Linux-Instanz verfügbar.

  • Oracle Linux 
    sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-service=https --permanent
sudo firewall-cmd --reload
  • Ubuntu Linux 
    sudo iptables -I INPUT 6 -m state --state NEW -p tcp --dport 3000 -j ACCEPT
sudo netfilter-persistent save
Ingress-Regel für das VCN erstellen (optional)

Führen Sie die folgenden Schritte aus, um das öffentliche Subnetz des VCN auszuwählen und die Ingress-Regel hinzuzufügen.

  1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Networking, Virtuelle Cloud-Netzwerke.
  2. Wählen Sie das VCN aus, das Sie mit Ihrer Compute-Instanz erstellt haben.
  3. Wenn das neue VCN angezeigt wird, klicken Sie auf den Link für das Subnetz <your-subnet-name>.

    Die Informationen zum öffentlichen Subnetz werden unten auf der Seite mit den Sicherheitslisten angezeigt. Ein Link zur Standardsicherheitsliste für Ihr VCN wird angezeigt.

  4. Klicken Sie auf den Link Standardsicherheitsliste.

    Die Standard-Ingress-Regeln für das VCN werden angezeigt.

  5. Klicken Sie auf Ingress-Regeln hinzufügen.

    Das Dialogfeld Ingress-Regeln hinzufügen wird angezeigt.

  6. Geben Sie die folgenden Informationen für die Ingress-Regel ein.

    Geben Sie die Ingress-Regel wie folgt ein:

    • zustandslos: Aktiviert
    • Quelltyp: CIDR
    • Quell-CIDR: 0.0.0.0/0
    • IP-Protokoll: TCP
    • Quellportbereich: (leer lassen)
    • Zielportbereich: 3000
    • Beschreibung: HTTP-Verbindungen zulassen
  7. Klicken Sie auf Ingress-Regel hinzufügen.

    Jetzt sind HTTP-Verbindungen zulässig. Das VCN ist für Node Express konfiguriert.

Sie haben erfolgreich eine Ingress-Regel erstellt, die Ihre Instanz über das Internet verfügbar macht.

Python 3 und Pip 3 installieren
  1. Prüfen Sie die aktuelle Version.
    python3 --version
  2. Führen Sie für Python 3 die folgenden Befehle aus:
    • Oracle Linux: 
      sudo yum update
      sudo yum install -y python3
    • Ubuntu:
      sudo apt update
      sudo apt install -y python3
  3. Prüfen Sie die Pip-Installation für Python3.
    pip3 -V

    Beispielausgabe, wenn Pip für Python3 installiert ist:

    pip <version> from xxx/lib/python3.x/site-packages/pip (python 3.x)
  4. Führen Sie zum Installieren von Pip für Python 3 die folgenden Befehle aus:
    • Oracle Linux: 
      sudo yum update
      sudo yum install -y python3-pip
    • Ubuntu:
      sudo apt update
      sudo apt install -y python3-pip
  5. Prüfen Sie die Installation von Pip für Python 3.
    pip3 -V
Kubernetes-Client installieren
  1. Prüfen Sie die aktuelle Version: 
    kubectl version --client
    Wenn Sie Kubernetes verwenden, lautet die Version <major-version>.<minor-version>. Für Version 1.20 erhalten Sie beispielsweise Folgendes:
    version.Info{Major:"1", Minor:"20"...
  2. Informationen zur Installation des kubectl-Clients finden Sie unter folgenden Links:
  3. Prüfen Sie die Installation. 
    kubectl version --client
Docker installieren
  1. Prüfen Sie die aktuelle Version: 
    docker -v
  2. Oracle Linux

    Um Docker auf Oracle Linux zu installieren, führen Sie die folgenden Befehle aus.

    sudo yum install docker-engine
    sudo systemctl start docker
    sudo systemctl enable docker

    Hinweis: Mit dem letzten Befehl wird der Start von Docker bei Neustarts aktiviert.

  3. Ubuntu Linux

    Informationen zur Installation von Docker auf Ubuntu Linux finden Sie unter dem folgenden Link: Docker herunterladen

  4. Prüfen Sie die Installation. 
    docker -v

1. Vorbereiten

Bereiten Sie die Umgebung vor, um Ihre Anwendung zu erstellen und bereitzustellen.

Servicelimits prüfen
  1. Melden Sie sich bei der Oracle Cloud Infrastructure-Konsole an.
  2. Öffnen Sie das Navigationsmenü, und klicken Sie auf Governance und Administration. Klicken Sie unter Governance auf Limits, Quota und Nutzung.
  3. Suchen Sie nach dem Servicelimit für Regionen:
    • Filtern Sie nach den folgenden Optionen:
      • Service: Regionen
      • Geltungsbereich: Mandant
      • Ressource: Anzahl abonnierte Regionen
      • Compartment: <tenancy-name> (Root)
    • Servicelimit suchen:
      • Limitname: subscribed-region-count
      • Leistungslimit: Mindestens 2
  4. Suchen Sie nach der verfügbaren Compute-Coreanzahl für die Ausprägung VM.Standard.E3.Flex:
    • Filtern Sie nach den folgenden Optionen:
      • Service: Compute
      • Bereich: <first-availability-domain>. Beispiel: EMlr:US-ASHBURN-AD-1
      • Ressource: Cores für die Instanzen Standard.E3.Flex und BM.Standard.E3.128
      • Compartment: <tenancy-name> (Root)
    • Nach der verfügbaren Coreanzahl suchen:
      • Limitname: standard-e3-core-ad-count
      • Verfügbar: Mindestens 1
    • Wiederholen Sie den Vorgang für Geltungsbereich: <second-availability-domain> und <third-availability-domain>. In jeder Region muss mindestens ein Core für diese Ausprägung verfügbar sein.
  5. Überprüfen Sie, ob 50 GB Block-Volume-Speicher verfügbar sind:
    • Filtern Sie nach den folgenden Optionen:
      • Service: Block-Volume
      • Bereich: <first-availability-domain>. Beispiel: EMlr:US-ASHBURN-AD-1
      • Ressource: Volume-Größe (GB)
      • Compartment: <tenancy-name> (Root)
    • Nach verfügbarem Block-Volume-Speicher suchen:
      • Limitname: total-storage-gb
      • Verfügbar: Mindestens 50
    • Wiederholen Sie den Vorgang für Geltungsbereich: <second-availability-domain> und <third-availability-domain>. In jeder Region müssen mindestens 50 GB Block-Volume-Speicher verfügbar sein.
  6. Überprüfen Sie, wie viele flexible Load Balancer verfügbar sind:
    • Filtern Sie nach den folgenden Optionen:
      • Service: LbaaS
      • Bereich: <your-region>. Beispiel: us-ashburn-1
      • Ressource: <blank>
      • Compartment: <tenancy-name> (Root)
    • Nach der Anzahl der verfügbaren flexiblen Load Balancer suchen:
      • Limitname: lb-flexible-count
      • Verfügbar: Mindestens 1
Hinweis

In diesem Tutorial werden drei Compute-Instanzen mit einer VM.Standard.E3.Flex-Ausprägung für die Clusterknoten erstellt. Wenn Sie eine andere Ausprägung verwenden möchten, filtern Sie nach der Coreanzahl. Beispiel: Filtern Sie für VM.Standard2.4 nach Cores für Standard2-basierte VM- und BM-Instanzen, und rufen Sie die Anzahl ab.

Eine Liste aller Ausprägungen finden Sie unter VM-Standardausprägungen.

Hinweis

In diesem Tutorial erstellen Sie mithilfe des Workflows "Schnellerstellung" ein Cluster mit einem öffentlichen regionalen Subnetz, das einen flexiblen Load Balancer hostet. Um einen anderen Load Balancer zu verwenden, können Sie mit einem benutzerdefinierten Workflow explizit angeben, welche vorhandenen Netzwerkressourcen verwendet werden sollen. Dazu gehören etwa vorhandene Subnetze, in denen die Load Balancer erstellt werden sollen.

Wenn Sie für den Load Balancer eine andere Bandbreite verwenden möchten, filtern Sie nach ihrerAnzahl, z.B. 100 Mbit/s Bandbreite oder 400 Mbit/s Bandbreite.

Autorisierungstoken erstellen
  1. Wählen Sie in der Navigationsleiste das Menü Profil und dann die Option Benutzereinstellungen oder Mein Profil, je nach der angezeigten Option aus.
  2. Klicken Sie auf Authentifizierungstoken.
  3. Klicken Sie auf Token generieren.
  4. Geben Sie eine Beschreibung ein.
  5. Klicken Sie auf Token generieren.
  6. Kopieren Sie das Token, und speichern Sie es.
  7. Klicken Sie auf Schließen.
Hinweis

Speichern Sie das Token direkt nach dem Erstellen. Sie haben später keinen Zugriff mehr darauf.
Erforderliche Informationen erfassen
  1. Erfassen Sie die folgenden Zugangsdateninformationen aus der Oracle Cloud Infrastructure-Konsole.
    • Name des Mandanten: <tenancy-name>
      • Wählen Sie in der Navigationsleiste das Menü Profil und dann Mandant: <your_tenancy_name>.
    • Namespace für Mandanten: <tenancy-namespace>
      • Wählen Sie in der Navigationsleiste das Menü Profil und dann Mandant: <your_tenancy_name>.
      • Kopieren Sie den Wert für Object Storage-Namespace.
      Hinweis

      Bei einigen Accounts unterscheiden sich Mandantenname und Namespace. Stellen Sie sicher, dass Sie in diesem Tutorial einen Namespace verwenden.
    • Mandanten-OCID: <tenancy-ocid>
      • Wählen Sie in der Navigationsleiste das Menü Profil und dann Mandant: <your_tenancy_name>.
      • OCID kopieren.
    • Benutzername: <user-name>
      • Wählen Sie in der Navigationsleiste das Menü Profil und dann die Option Benutzereinstellungen oder Mein Profil, je nachdem, welche Option angezeigt wird.
    • Benutzer-OCID: <user-ocid>
      • Wählen Sie in der Navigationsleiste das Menü Profil und dann die Option Benutzereinstellungen oder Mein Profil, je nachdem, welche Option angezeigt wird.
      • OCID kopieren.
  2. Suchen Sie nach Ihren Regionsinformationen.
    • Region: <region-identifier>
      • Suchen Sie in der oberen Navigationsleiste der Konsole nach der Region. Beispiel: US East (Ashburn).
      • Suchen Sie in der Tabelle unter Regionen und Availability-Domains nach der Regions-ID.
      • Beispiel: us-ashburn-1.
    • Regionsschlüssel: <region-key>
  3. Kopieren Sie Ihr Authentifizierungstoken aus dem Abschnitt Authentifizierungstoken erstellen.
    • Auth-Token: <auth-token>
OCI-Befehlszeilenschnittstelle einrichten
Virtuelle Python-Umgebung und Wrapper installieren

Python virtualenv erstellt einen Ordner, der alle ausführbaren Dateien und Librarys für das Projekt enthält.

virtualenvwrapper ist eine Erweiterung von virtualenv. Er bietet eine Reihe von Befehlen, wodurch das Arbeiten mit virtuellen Umgebungen komfortabler wird. Außerdem werden alle virtuellen Umgebungen an einem Ort platziert. virtualenvwrapper ermöglicht die Tab-Vervollständigung von Umgebungsnamen.

  1. Installieren Sie virtualenv.
    pip3 install --user virtualenv
  2. Installieren Sie virtualenvwrapper.
    pip3 install --user virtualenvwrapper
  3. Suchen Sie nach dem Speicherort des Skripts virtualenvwrapper.sh.
    grep -R virtualenvwrapper.sh
    Beispielpfade:
    • Linux-Beispiel: /home/ubuntu/.local/bin/virtualenvwrapper.sh
    • MacOS-Beispiel: /usr/local/bin/virtualenvwrapper.sh
  4. Konfigurieren Sie den Wrapper der virtuellen Umgebung in .bashrc.
    sudo vi .bashrc

    Hängen Sie folgenden Text an.

    # set up Python env
export WORKON_HOME=~/envs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
source <path-to-virtualenvwrapper.sh>

    Ersetzen Sie <path-to-virtualenvwrapper.sh> durch seinen Wert.

    Ändern Sie /usr/bin/python3 basierend auf dem Speicherort der Python3-Binärdateien in Ihrer Umgebung in den richtigen Speicherort.

    Speichern Sie die Datei.

  5. Aktivieren Sie die Befehle im aktuellen Fenster.
    source ~/.bashrc
    Beispielausgabe:
    virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/initialize
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/prermvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postrmvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/predeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postdeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postactivate
OCI-CLI installieren
  1. Starten Sie eine virtuelle Umgebung.
    workon cli-app
  2. Vergewissern Sie sich, dass der Name der virtuellen Umgebung, cli-app, links neben der Eingabeaufforderung angezeigt wird.

    Beispiel: (cli-app) ubuntu@<ubuntu-instance-name>:~$

  3. Installieren Sie die OCI-CLI.
    pip3 install oci-cli
  4. Testen Sie die Installation.
    oci --version

    Falls die Einrichtung korrekt ist, erhalten Sie die Version.

    oci --help
OCI-CLI konfigurieren
  1. Geben Sie den folgenden Befehl in die virtuelle Umgebung ein:
    oci setup config
  2. Geben Sie Ihre Antworten aus dem Abschnitt Erforderliche Informationen erfassen ein:
    • Speicherort für die Konfiguration [$HOME/.oci/config]: <take-default>
    • Benutzer-OCID: <user-ocid>
    • Mandanten-OCID: <tenancy-ocid>
    • Region (Beispiel: us-ashburn-1): <region-identifier>
  3. Geben Sie die folgenden Informationen ein, um Ihre OpenSSL-API-Verschlüsselungsschlüssel einzurichten:
    • Neues RSA-Schlüsselpaar für API-Signatur generieren? [Y/n]: J
    • Verzeichnis für Ihre Schlüssel [$HOME/.oci]: <take-default>
    • Name für Ihren Schlüssel [oci_api_key] <take-default>
  4. Deaktivieren Sie die virtuelle Umgebung: 
    deactivate

    Das Präfix (cli-app) in Ihrer Umgebung wird nicht mehr angezeigt.

Hinweis

Ihr Private Key ist oci_api_key.pem, und Ihr Public Key ist oci_api_key_public.pem.
Fügen Sie Ihrem Benutzeraccount den Public Key hinzu.
  1. Aktivieren Sie die cli-app-Umgebung:
    workon cli-app
  2. Zeigen Sie den Public Key an.
    cat $HOME/.oci/oci_api_key_public.pem
  3. Kopieren Sie den Public Key.
  4. Fügen Sie den Public Key zu Ihrem Benutzeraccount hinzu:
    • Gehen Sie zur Konsole.
    • Wählen Sie in der Navigationsleiste das Menü Profil und dann die Option Benutzereinstellungen oder Mein Profil, je nachdem, welche Option angezeigt wird.
    • Klicken Sie auf API-Schlüssel.
    • Klicken Sie auf API-Schlüssel hinzufügen.
    • Klicken Sie auf Public Key einfügen.
    • Wert aus vorherigem Schritt einfügen, einschließlich der Zeilen mit BEGIN PUBLIC KEY und END PUBLIC KEY.
    • Klicken Sie auf Hinzufügen.
Hinweis

  • Wenn Sie die OCI-CLI verwenden möchten, aktivieren Sie sie mit: workon cli-app
  • Wenn Sie Projektnamen ändern, deaktiviert workon Ihre aktuelle Arbeitsumgebung. Auf diese Weise können Sie schnell zwischen Umgebungen wechseln.

2. Cluster einrichten

Installieren und konfigurieren Sie Verwaltungsoptionen für Ihr Kubernetes-Cluster. Stellen Sie die Anwendung später in diesem Cluster bereit.

Compartment-Policy hinzufügen

Wenn sich Ihr Benutzername in der Gruppe Administratoren befindet, überspringen Sie diesen Abschnitt. Andernfalls muss der Administrator Ihrem Mandanten die folgende Policy hinzufügen:

allow group <the-group-your-username-belongs> to manage compartments in tenancy

Mit dieser Berechtigung können Sie ein Compartment für alle Ressourcen in Ihrem Tutorial erstellen.

Schritte zum Hinzufügen der Policy
  1. Wählen Sie in der Navigationsleiste das Menü Profil und dann die Option Benutzereinstellungen oder Mein Profil, je nachdem, welche Option angezeigt wird.
  2. Klicken Sie im linken Fensterbereich auf Gruppen.
  3. Kopieren Sie den Gruppennamen, zu dem Ihr Benutzername gehört, in Notepad.
  4. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identität auf Policys.
  5. Wählen Sie Ihr Compartment in der Dropdown-Liste Compartment aus.
  6. Klicken Sie auf Policy erstellen.
  7. Geben Sie die folgenden Informationen ein:
    • Name: manage-compartments
    • Beschreibung: Allow the group <the-group-your-username-belongs> to list, create, update, delete and recover compartments in the tenancy.
    • Compartment: <your-tenancy>(root)
  8. Klicken Sie unter Policy Builder auf Manuellen Editor anzeigen.
  9. Fügen Sie die folgende Policy ein:
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  10. Klicken Sie auf Erstellen.

Referenz: Der Ressourcentyp compartments in Kombinationen aus Verben + Ressourcentyp für IAM

Compartment erstellen

Erstellen Sie ein Compartment für die Ressourcen, die Sie in diesem Tutorial erstellen.

  1. Melden Sie sich bei der Oracle Cloud Infrastructure-Konsole an.
  2. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identität auf Compartments.
  3. Klicken Sie auf Compartment erstellen.
  4. Geben Sie die folgenden Informationen ein:
    • Name: <your-compartment-name>
    • Beschreibung: Compartment für <your-description>.
    • Übergeordnetes Compartment: <your-tenancy>(Root)
  5. Klicken Sie auf Compartment erstellen.

Referenz: Compartment erstellen

Ressourcen-Policy hinzufügen

Wenn sich Ihr Benutzername in der Gruppe Administratoren befindet, überspringen Sie diesen Abschnitt. Andernfalls muss der Administrator Ihrem Mandanten die folgende Policy hinzufügen:

allow group <the-group-your-username-belongs> to manage all-resources in compartment <your-compartment-name>

Mit dieser Berechtigung können Sie alle Ressourcen im Compartment verwalten, was Ihnen im Wesentlichen Administratorrechte in diesem Compartment gewährt.

Schritte zum Hinzufügen der Policy
  1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identität auf Policys.
  2. Wählen Sie Ihr Compartment in der Dropdown-Liste Compartment aus.
  3. Klicken Sie auf Policy erstellen.
  4. Geben Sie die folgenden Informationen ein:
    • Name: manage-<your-compartment-name>-resources
    • Beschreibung: Auflisten, Erstellen, Aktualisieren und Löschen von Ressourcen in <your-compartment-name> durch Benutzer zulassen.
    • Compartment: <your-tenancy>(root)
  5. Wählen Sie unter Policy Builder die folgenden Optionen aus:
    • Policy-Anwendungsfälle: Compartment-Verwaltung
    • Allgemeine Policy-Vorlagen: Verwalten des Compartments durch Compartment-Administratoren zulassen
    • Gruppen: <the-group-your-username-belongs>
    • Speicherort: <your-tenancy>(root)
  6. Klicken Sie auf Erstellen.

Referenz: Standard-Policys

Cluster mit Schnellerstellung erstellen

Erstellen Sie ein Cluster mit Standardeinstellungen und neuen Netzwerkressourcen über den Workflow "Schnellerstellung".

  1. Melden Sie sich bei der Oracle Cloud Infrastructure-Konsole an.
  2. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter Container und Artefakte auf Kubernetes-Cluster (OKE).
  3. Klicken Sie auf Cluster erstellen.
  4. Wählen Sie Schnellerstellung aus.
  5. Klicken Sie auf Workflow starten.

    Das Dialogfeld Cluster schnell erstellen wird angezeigt.

  6. Geben Sie die folgenden Informationen ein.
    • Name: <your-cluster-name>
    • Compartment: <your-compartment-name>
    • Kubernetes-Version: <take-default>
    • Kubernetes-API-Endpunkt: Öffentlicher Endpunkt

      Das Kubernetes-Cluster wird in einem öffentlichen Subnetz mit einer automatisch zugewiesenen öffentlichen IP-Adresse gehostet.

    • Kubernetes-Worker-Knoten: Private Worker

      Die Kubernetes-Worker-Knoten werden in einem privaten Subnetz gehostet.

    • Ausprägung: VM.Standard.E3.Flex
    • Wählen Sie die Anzahl der OCPUs aus: 1
    • Arbeitsspeicher (GB): 16
    • Anzahl Knoten: 3
  7. Klicken Sie auf Erweiterte Optionen anzeigen.

    Behalten Sie die Standardwerte bei.

    • Benutzerdefinierte Boot-Volume-Größe angeben: Deaktivieren Sie das Kontrollkästchen.
    • Imageverifizierung: Deaktivieren Sie das Kontrollkästchen.
    • SSH-Schlüssel hinzufügen: Kein SSH-Schlüssel
  8. Klicken Sie auf Weiter.

    Alle Auswahlmöglichkeiten werden angezeigt. Prüfen Sie sie, um sicherzustellen, dass alle Konfigurationen korrekt sind.

  9. Klicken Sie auf Cluster erstellen.

    Die für Ihr Cluster eingerichteten Services werden angezeigt.

  10. Klicken Sie auf Schließen.
  11. Holen Sie sich eine Tasse Kaffee. Die Erstellung des Clusters dauert einige Minuten.
Sie haben erfolgreich ein Kubernetes-Cluster erstellt.
Lokalen Zugriff auf das Cluster einrichten

Nachdem Sie ein Kubernetes-Cluster erstellt haben, richten Sie das lokale System für den Zugriff auf das Cluster ein.

  1. Melden Sie sich bei der Oracle Cloud Infrastructure-Konsole an.
  2. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter Container und Artefakte auf Kubernetes-Cluster (OKE).
  3. Klicken Sie auf den Link zu <your-cluster>.

    Die Informationen zu Ihrem Cluster werden angezeigt.

  4. Klicken Sie auf Auf Cluster zugreifen.
  5. Klicken Sie auf Lokaler Zugriff.
  6. Befolgen Sie die im Dialogfeld angegebenen Schritte. Zu Referenzzwecken werden sie hier erneut aufgeführt.
    Hinweis

    Wenn Sie sich nicht in Ihrer virtuellen Umgebung befinden, geben Sie workon cli-app ein, bevor Sie kubectl-Befehle ausführen.

    Prüfen Sie die OCI-CLI-Version.

    oci -v

    Erstellen Sie das Verzeichnis .kube, falls es noch nicht vorhanden ist.

    mkdir -p $HOME/.kube

    Erstellen Sie eine kubeconfig-Datei für das Setup. Verwenden Sie die Informationen aus dem Dialogfeld Auf das Cluster zugreifen.

    oci ce cluster create-kubeconfig <use data from dialog>

    Exportieren Sie die Umgebungsvariable KUBECONFIG.

    export KUBECONFIG=$HOME/.kube/config
    Hinweis

    Wenn die Umgebungsvariable in einer neuen Shell beginnen soll, fügen Sie der Datei ~/.bashrc export KUBECONFIG=$HOME/.kube/config hinzu.
  7. Testen Sie die Clusterkonfiguration mit den folgenden Befehlen.

    Cluster auflisten:

    kubectl get service

    Deployment-Details abrufen:

    kubectl describe deployment

    Pods abrufen:

    kubectl get pods
    Hinweis

    Da keine Anwendung bereitgestellt wird, geben die beiden letzten Befehle Folgendes zurück: "Keine Ressourcen im Standard-Namespace gefunden."
    Hinweis

    Wenn Sie ein anderes Cluster anzeigen möchten, geben Sie in der Befehlszeile eine andere Konfigurationsdatei an. Beispiel:
    kubectl --kubeconfig=</path/to/config/file>

Wenn der Clusterzugriff eingerichtet ist, können Sie Ihre Anwendung jetzt auf das Deployment vorbereiten.

3. Lokale Anwendung erstellen

Erstellen Sie eine lokale Anwendung und ein Docker-Image für die Anwendung.

Lokale Anwendung erstellen

Erstellen Sie die Node.js-Anwendung.

  1. Starten Sie eine OCI-CLI-Session.
  2. Erstellen Sie ein Verzeichnis für Ihre Anwendung. 
    mkdir node-hello-app
cd node-hello-app
  3. Erstellen Sie die Datei package.json.

    Erstellen Sie die Datei:

    vi package.json

    Geben Sie in der Datei folgenden Text ein, aktualisieren Sie die optionalen Felder Autor und Repository, und speichern Sie die Datei:

    {
    "name": "node-hello-app",
    "version": "1.0.0",
    "description": "Node Express Hello application",
    "author": "Example User <username@example.com>",
    "main": "app.js",
    "scripts": {
        "start": "node app.js"
    },
    "repository": {
        "type": "git",
        "url": "git://github.com/username/repository.git"
    },
    "dependencies": {
        "express": "^4.0.0"
    },
    "license": "UPL-1.0"
}
  4. Installieren Sie die NPM-Packages. 
    npm install
  5. Erstellen Sie eine "Hello, World!"-Anwendung.

    Erstellen Sie die Datei:

    vi app.js

    Geben Sie in der Datei folgenden Text ein, und speichern Sie die Datei:

    const express = require('express')
const app = express()
port = 3000

app.get('/', function (req, res) {
    res.send('<h1>Hello World from Node.js!</h1>')
})

app.listen(port, function() {
    console.log('Hello World app listening on port ' + port);
})

Sie haben die Node.js-Anwendung erfolgreich eingerichtet.

Lokale Anwendung ausführen

Führen Sie die Node.js-Anwendung aus.

  1. Führen Sie die Node.js-Anwendung aus. 
    node app.js
    Der Node Express-Server wird gestartet und zeigt Folgendes an: 
    Hello World app listening on port 3000
  2. Testen Sie die Anwendung mit curl oder Ihrem Browser.
    • Um mit curl zu testen, geben Sie Folgendes ein: 
      curl -X GET http://localhost:3000
    • Um mit Ihrem Browser zu testen, stellen Sie in einem Browserfenster eine Verbindung zu Folgendem her: http://<your-ip-address>:3000 (optional).
    Die Anwendung gibt Folgendes zurück: 
    <h1>Hello World from Node.js!</h1>
  3. Stoppen Sie die Anwendung.

    Drücken Sie Strg+C, um die Anwendung in dem eingangs verwendeten Terminalfenster zu stoppen.

Sie haben erfolgreich eine "Hello World"-Anwendung mit Node.js und Express erstellt.

Referenzen:

Docker-Image erstellen

Erstellen Sie als Nächstes ein Docker-Image für Ihre Node.js-Express-Anwendung.

  1. Stellen Sie sicher, dass Sie sich im Verzeichnis node-hello-app befinden.
  2. Erstellen Sie ein Docker-Image. 
    docker build -t node-hello-app .

    Eine Erfolgsmeldung wird angezeigt.

    [INFO] BUILD SUCCESS
Successfully tagged node-hello-app:latest
  3. Führen Sie das Docker-Image aus: 
    docker run --rm -p 3000:3000 node-hello-app:latest
  4. Testen Sie die Anwendung. 
    curl -X GET http://localhost:3000
    Die Anwendung gibt Folgendes zurück: 
    <h1>Hello World from Node.js!</h1>
  5. Stoppen Sie die Anwendung.
Herzlichen Glückwunsch. Sie haben erfolgreich ein Node.js-Express-Image erstellt.

4. Docker-Image bereitstellen

Übertragen Sie das Node.js-Express-Image per Push an OCI Container Registry. Verwenden Sie dann das Image, um Ihre Anwendung bereitzustellen.

Docker-Repository erstellen
  1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter Container und Artefakte auf Container Registry.
  2. Wählen Sie in der linken Navigationsleiste <your-compartment-name> aus.
  3. Klicken Sie auf Repository erstellen.
  4. Erstellen Sie ein privates Repository mit einem Repository-Namen Ihrer Wahl: 
    <repo-name> = <image-path-name>/<image-name>

    Beispiel: node-apps/node-hello-app

    Sie können jetzt Ihr lokales Image per Push an Container Registry übertragen.
    Hinweis

    Bevor Sie ein Docker-Image per Push in ein Registry-Repository übertragen können, muss das Repository in Ihrem Compartment vorhanden sein. Wenn das Repository nicht vorhanden ist, funktioniert der Docker-Push-Befehl nicht ordnungsgemäß.
    Hinweis

    Der Schrägstrich in einem Repository-Namen gibt keine hierarchische Verzeichnisstruktur an. Mit dem optionalen <image-path-name> können Sie Ihre Repositorys organisieren.
Lokales Image per Push übertragen

Nachdem das lokale Docker-Image erstellt wurde, übertragen Sie das Image an die Container Registry.

Gehen Sie wie folgt vor.

  1. Öffnen Sie die OCI-CLI-Session.
  2. Melden Sie sich bei OCI Container Registry an: 
    docker login <region-key>.ocir.io

    Sie werden zur Eingabe Ihres Anmeldenamens und Kennwortes aufgefordert.

    • Benutzername: <tenancy-namespace>/<user-name>
    • Kennwort: <auth-token>
  3. Listen Sie die lokalen Docker-Images auf: 
    docker images

    Die Docker-Images in Ihrem System werden angezeigt. Identifizieren Sie das Image, das Sie im letzten Abschnitt erstellt haben: node-hello-app

  4. Taggen Sie Ihr lokales Image mit der URL für die Registry und dem Repository-Namen, damit Sie es per Push an dieses Repository übertragen können. 
    docker tag <your-local-image> <repo-url>/<repo-name>
    • Ersetzen Sie <repo-url> durch: 
      <region-key>.ocir.io/<tenancy-namespace>/
    • Ersetzen Sie <repo-name> durch:

      <image-folder-name>/<image-name> aus dem Abschnitt Docker-Repository erstellen.

    • Nachfolgend finden Sie ein Beispiel für die Kombination von beiden:
      docker tag node-hello-app iad.ocir.io/my-namespace/node-apps/node-hello-app

      In diesem Beispiel sind die Komponenten:

      • Repository-URL: iad.ocir.io/my-namespace/
      • Repository-Name: node-apps/node-hello-app
    Hinweis

    OCI Container Registry unterstützt jetzt das Erstellen eines Registry Repositorys in einem beliebigen Compartment und nicht nur im Root Compartment (Mandant). Um das Image per Push an das erstellte Repository zu übertragen, kombinieren Sie die Registry-URL mit dem exakten Repository-Namen. OCI Container Registry nimmt einen Abgleich mit dem eindeutigen Repository-Namen vor und überträgt das Image per Push.
  5. Prüfen Sie Ihre Docker-Images, um festzustellen, ob das Image kopiert wurde. 
    docker images
    • Das getaggte Image hat dieselbe Image-ID wie das lokale Image.
    • Der Name des getaggten Image lautet: 
      <region-key>.ocir.io/<tenancy-namespace>/<image-path-name>/<image-name>
  6. Übertragen Sie das Image per Push an Container Registry. 
    docker push <copied-image-name>:latest
    Beispiel:
    docker push iad.ocir.io/my-namespace/node-apps/node-hello-app:latest
  7. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter Container und Artefakte auf Container Registry.

Suchen Sie Ihr Image in Container Registry, nachdem der Push-Befehl abgeschlossen ist.

Image bereitstellen
Da sich Ihr Image in Container Registry befindet, können Sie jetzt Ihr Image und Ihre App bereitstellen.
  1. Erstellen Sie ein Registry Secret für die Anwendung. Dieses Secret authentifiziert das Image, wenn Sie es im Cluster bereitstellen.

    Geben Sie die Informationen in diese Vorlage ein, um das Secret zu erstellen.

    kubectl create secret docker-registry ocirsecret --docker-server=<region-key>.ocir.io  --docker-username='<tenancy-namespace>/<user-name>' --docker-password='<auth-token>'  --docker-email='<email-address>'

    Nach Ausführung des Befehls wird ungefähr folgende Meldung angezeigt: secret/ocirsecret created.

  2. Prüfen Sie, ob das Secret erstellt wurde. Geben Sie den folgenden Befehl aus: 
    kubectl get secret ocirsecret --output=yaml

    Die Ausgabe enthält Informationen zum Secret im YAML-Format.

  3. Legen Sie die Host-URL für das Registry-Image mit der folgenden Vorlage fest: 
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Beispiel:
    iad.ocir.io/my-namespace/node-apps/node-hello-app:latest
  4. Erstellen Sie auf Ihrem System eine Datei mit dem Namen node-app.yaml, die folgenden Text enthält:
    Ersetzen Sie die folgenden Platzhalter:
    • <your-image-url>
    • <your-secret-name>
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  selector:
    matchLabels:
      app: app
  replicas: 3
  template:
    metadata:
      labels:
        app: app
    spec:
      containers:
      - name: app
        image: <your-image-url>
        imagePullPolicy: Always
        ports:
        - name: app
          containerPort: 3000
          protocol: TCP
      imagePullSecrets:
        - name: <your-secret-name>
---
apiVersion: v1
kind: Service
metadata:
  name: node-app-lb
  labels:
    app: app
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 3000
  selector:
    app: app
  5. Stellen Sie die Anwendung mit dem folgenden Befehl bereit. 
    kubectl create -f node-app.yaml
    Ausgabe: 
    deployment.apps/node-app created
service/node-app-lb created
    Hinweis

    Mit dem Code, der in der Datei node-app.yaml auf die Bindestriche folgt, wird ein flexibler Load Balancer hinzugefügt.
Anwendung testen
Nach dem Deployment der Anwendung kann es einige Sekunden dauern, bis der Load Balancer geladen wird.
  1. Prüfen Sie, ob der Load Balancer aktiv ist: 
    kubectl get service

    Wiederholen Sie den Befehl, bis dem Load Balancer eine IP-Adresse zugewiesen ist.

    Hinweis

    Während Sie auf das Deployment des Load Balancers warten, können Sie den Status des Clusters mit den folgenden Befehlen prüfen:
    • Status der einzelnen Pods abrufen: kubectl get pods
    • Anwendungsstatus abrufen: kubectl get deployment
  2. Verwenden Sie die IP-Adresse des Load Balancers, um eine Verbindung zur Anwendung in einem Browser herzustellen: 
    http://<load-balancer-IP-address>:3000

    Im Browser wird Folgendes angezeigt: <h1>Hello World from Node.js!</h1>

  3. Heben Sie das Deployment der Anwendung im Cluster auf. (Optional) Führen Sie zum Entfernen der Anwendung den folgenden Befehl aus: 
    kubectl delete -f node-app.yaml
    Ausgabe:
    deployment.apps/node-app deleted
service "node-app-lb" deleted

    Ihre Anwendung wird jetzt aus dem Cluster entfernt.

Weitere Schritte

Sie haben mit dem Node Express-Framework erfolgreich eine "Hello World"-Anwendung erstellt, in einem Kubernetes-Cluster bereitgestellt und Internetzugriff darauf über das Node Express-Framework eingerichtet.

Auf diesen Sites finden Sie weitere Informationen zur Entwicklung mit Oracle-Produkten: