Erstellen eines virtuellen Express.js-Computer mit der Azure CLI

Artikel
08/30/2024

In diesem Tutorial wird ein virtueller Linux-Computer (virtual machine, VM) für eine Express.js-App erstellt. Der virtuelle Computer wird mit einer cloud-init-Konfigurationsdatei konfiguriert und enthält NGINX sowie ein GitHub-Repository für eine Express.js-App. Stellen Sie eine SSH-Verbindung mit dem virtuellen Computer her, ändern Sie die Web-App, um sie mit Ablaufverfolgungsprotokollierung zu versehen, und zeigen Sie die öffentliche Express.js-Server-App in einem Webbrowser an.

Dieses Lernprogramm enthält die folgenden Aufgaben:

Anmelden bei Azure mit der Azure CLI
Erstellen einer Azure-Ressource in Form eines virtuellen Linux-Computers mithilfe der Azure CLI
- Öffnen des öffentlichen Ports 80
- Installieren der Express.js-Demo-Web-App aus einem GitHub-Repository
- Installieren von Web-App-Abhängigkeiten
- Starten der Web-App
Erstellen einer Azure Monitor-Ressource mithilfe der Azure CLI
- Herstellen einer SSH-Verbindung mit dem virtuellen Computer
- Installieren der Azure SDK-Clientbibliothek mit npm
- Hinzufügen von Application Insights-Clientbibliothekscode zum Erstellen einer benutzerdefinierten Ablaufverfolgung
Anzeigen der Web-App über den Browser
- Anfordern der Route /trace, um eine benutzerdefinierte Ablaufverfolgung im Application Insights-Protokoll zu generieren
- Anzeigen der Anzahl im Protokoll gesammelter Ablaufverfolgungen mithilfe der Azure CLI
- Anzeigen der Liste der Ablaufverfolgungen mithilfe des Azure-Portals
Entfernen von Ressourcen mithilfe der Azure CLI

Voraussetzungen

Ein Azure-Benutzerkonto und -Abonnement: Kostenloses Abonnement erstellen
Herstellen einer SSH-Verbindung mit dem virtuellen Computer: Verwenden Sie Azure Cloud Shell oder ein modernes Terminal (z. B. Bash-Shell), das SSH beinhaltet.

Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Schnellstart für Bash in Azure Cloud Shell.
Wenn Sie CLI-Referenzbefehle lieber lokal ausführen, installieren Sie die Azure CLI. Wenn Sie Windows oder macOS ausführen, sollten Sie die Azure CLI in einem Docker-Container ausführen. Weitere Informationen finden Sie unter Ausführen der Azure CLI in einem Docker-Container.
- Wenn Sie eine lokale Installation verwenden, melden Sie sich mithilfe des Befehls az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.
- Installieren Sie die Azure CLI-Erweiterung beim ersten Einsatz, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.
- Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen.

1. Erstellen einer Application Insights-Ressource für Webseiten

Hier erfahren Sie, wie Sie eine Azure-Ressourcengruppe für alle Ihre Azure-Ressourcen sowie eine Monitor-Ressource erstellen, um die Protokolldateien Ihrer Web-App in der Azure-Cloud zu sammeln. Durch die Erstellung einer Ressourcengruppe können Sie Ressourcen ganz einfach finden und wieder löschen, wenn Sie sie nicht mehr benötigen. Azure Monitor ist der Name des Azure-Diensts. Application Insights ist der Name der im Tutorial verwendeten Clientbibliothek.

Wenn Sie mehrere Abonnement besitzen, verwenden Sie optional az account set, um das Standardabonnement festzulegen, bevor Sie die übrigen Befehle ausführen.
```
az account set \
    --subscription "ACCOUNT NAME OR ID" 
```
Erstellen Sie mit dem Befehl az group create eine Azure-Ressourcengruppe. Verwenden Sie den Namen rg-demo-vm-eastus:
```
az group create \
    --location eastus \
    --name rg-demo-vm-eastus 
```

Erstellen einer Azure Monitor-Ressource mithilfe der Azure CLI

Installieren Sie die Application Insights-Erweiterung für die Azure CLI.
```
az extension add -n application-insights
```

Verwenden Sie den folgenden Befehl, um eine Überwachungsressource mit az monitor app-insights component create zu erstellen:

az monitor app-insights component create \
  --app demoWebAppMonitor \
  --location eastus \
  --resource-group rg-demo-vm-eastus \
  --query instrumentationKey --output table

Kopieren Sie das Ergebnis aus der Ausgabe. Sie benötigen diesen Wert später als instrumentationKey.
Lassen Sie das Terminal für den nächsten Schritt geöffnet.

2. Erstellen eines virtuellen Linux-Computers mithilfe der Azure CLI

Hier wird eine cloud-init-Konfigurationsdatei verwendet, um sowohl den NGINX-Reverseproxyserver als auch den Express.js-Server zu erstellen. NGINX wird verwendet, um den Express.js-Port (3000) an den öffentlichen Port (80) weiterzuleiten.

Erstellen Sie eine lokale Datei namens cloud-init-github.txt, und speichern Sie den folgenden Inhalt in der Datei, oder speichern Sie die Datei des Repositorys auf Ihrem lokalen Computer. Die formatierte Datei vom Typ cloud-init muss sich im gleichen Ordner befinden, der auch im Terminalpfad für Ihre Azure CLI-Befehle verwendet wird.

#cloud-config
package_upgrade: true
packages:
  - nginx
write_files:
  - owner: www-data:www-data
    path: /etc/nginx/sites-available/default
    content: |
      server {
        listen 80 default_server;
        server_name _;
        location / {
          # First, try if the file exists locally, otherwise request it from the app
          try_files $uri @app;
        }
        location @app {
          proxy_pass http://localhost:3000;
          proxy_http_version 1.1;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection 'upgrade';
          proxy_set_header X-Forwarded-For $remote_addr;
          proxy_set_header Host $host;
          proxy_cache_bypass $http_upgrade;
        }
      }
runcmd:
  # install Node.js
  - 'curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -'
  - 'sudo apt-get install -y nodejs'
  # clone GitHub Repo into myapp directory
  - 'cd /home/azureuser'
  - git clone "https://github.com/Azure-Samples/js-e2e-vm" myapp
  # Start app
  - 'cd myapp && npm install && npm start'
  # restart NGINX
  - systemctl restart nginx

Sehen Sie sich den Abschnitt runcmd der Datei an, um die Funktionsweise zu verstehen.

runcmd hat verschiedene Aufgaben:
- Herunterladen und Installieren von Node.js
- Klonen des Express.js-Beispielrepositorys aus GitHub in das Verzeichnis myapp
- Installieren der Anwendungsabhängigkeiten
- Starten der Express.js-App mit PM2

Erstellen einer VM-Ressource

Geben Sie den Azure CLI-Befehl az vm create an einem Terminal ein, um eine Azure-Ressource eines virtuellen Linux-Computers zu erstellen. Der Befehl erstellt den virtuellen Computer auf der Grundlage der cloud-init-Datei und generiert die SSH-Schlüssel für Sie. Der Speicherort der Schlüssel wird bei der Befehlsausführung angezeigt.
```
az vm create \
  --resource-group rg-demo-vm-eastus \
  --name demo-vm \
  --location eastus \
  --public-ip-sku Standard \
  --image UbuntuLTS \
  --admin-username azureuser \
  --generate-ssh-keys \
  --custom-data cloud-init-github.txt
```
Warten Sie, bis der Prozess abgeschlossen ist. Dies kann einige Minuten dauern.
Notieren Sie sich den Wert für publicIpAddress aus der Antwort. Er wird benötigt, um die Web-App in einem Browser anzuzeigen und eine Verbindung mit dem virtuellen Computer herzustellen. Wenn Sie diese IP-Adresse verlieren, verwenden Sie den Azure CLI-Befehl az vm list-ip-addresses, um sie erneut abzurufen.
Der Prozess hat SSH-Schlüssel erstellt und an einem in der Antwort angegebenen Speicherort abgelegt.
Wechseln Sie zu diesem Speicherort, und erstellen Sie die authorized_keys-Datei:
```
cd <SSH-KEY-LOCATION> && cat id_rsa >> authorized_keys
```

Öffnen eines Ports für den virtuellen Computer

Nach der Erstellung verfügt der virtuelle Computer zunächst über keine geöffneten Ports. Öffnen Sie Port 80 mithilfe des folgenden Azure CLI-Befehls (az vm open-port), um die Web-App öffentlich verfügbar zu machen:

az vm open-port \
  --port 80 \
  --resource-group rg-demo-vm-eastus \
  --name demo-vm

Öffnen der Website im Browser

Verwenden Sie die öffentliche IP-Adresse in einem Webbrowser, um sich zu vergewissern, dass der virtuelle Computer verfügbar ist und ausgeführt wird. Ändern Sie die URL so, dass der Wert von publicIpAddressverwendet wird.
```
http://YOUR-VM-PUBLIC-IP-ADDRESS
```
Sollte für die Ressource ein Gatewayfehler auftreten, warten Sie eine Minute, und versuchen Sie es dann erneut. (Unter Umständen dauert es etwas, bis die Web-App gestartet wurde.)
Die Web-App des virtuellen Computers gibt die folgenden Informationen zurück:
- Name des virtuellen Computers
- Ihre Client-ID
- Aktuelles Datum/aktuelle Uhrzeit

Die anfängliche Codedatei für die Web-App verfügt über eine einzelne Route, die über den NGINX-Proxy geleitet wird.

const os = require('os');
const express = require('express')
const app = express()

app.use('/public', express.static('public'))
app.get('/', function (req, res) {

    const clientIP = req.headers['x-forwarded-for'];
    const msg = `HostName: ${os.hostname()}<br>ClientIP: ${clientIP}<br>DateTime: ${new Date()}<br><img width='200' height='200' src='/public/leaves.jpg' alt='flowers'>`
    console.log(msg)

    res.send(msg)
})
app.listen(3000, function () {
    console.log(`Hello world app listening on port 3000! ${Date.now()}`)
})

3. Herstellen einer SSH-Verbindung mit einem virtuellen Linux-Computer

In diesem Abschnitt des Tutorials wird SSH in einem Terminal verwendet, um eine Verbindung mit Ihrem virtuellen Computer herzustellen. SSH ist ein gängiges Tool, das mit vielen modernen Shells bereitgestellt wird. Dazu zählt auch Azure Cloud Shell.

Herstellen einer SSH-Verbindung und Ändern der Web-App

Stellen Sie mithilfe des folgenden Befehls eine Verbindung mit Ihrem virtuellen Computer her.

Ersetzen Sie YOUR-VM-PUBLIC-IP durch die öffentliche IP-Adresse Ihres eigenen virtuellen Computers.
```
ssh azureuser@YOUR-VM-PUBLIC-IP
```
Bei diesem Prozess wird davon ausgegangen, dass der verwendete SSH-Client Ihre SSH-Schlüssel finden kann, die im Rahmen der VM-Erstellung erstellt und auf Ihrem lokalen Computer platziert wurden.
Wenn Sie gefragt werden, ob Sie eine Verbindung herstellen möchten, antworten Sie mit y oder yes, um den Vorgang fortzusetzen.
Verwenden Sie den folgenden Befehl, um zu prüfen, wo Sie sich auf dem virtuellen Computer befinden. Sie sollten sich im Stammverzeichnis von „azureuser“ befinden: /home/azureuser.
```
pwd
```
Nach Abschluss der Verbindungsherstellung ändert sich die Eingabeaufforderung des Terminals, um den Benutzernamen und den Ressourcennamen des virtuellen Remotecomputers anzugeben.
```
azureuser@demo-vm:
```
Ihre Web-App befindet sich im Unterverzeichnis myapp. Wechseln Sie zum Verzeichnis myapp, und listen Sie den Inhalt auf:
```
cd myapp && ls -l
```

Der Inhalt sollte das auf dem virtuellen Computer geklonte GitHub-Repository sowie die npm-Paketdateien darstellen:

-rw-r--r--   1 root root   891 Nov 11 20:23 cloud-init-github.txt
-rw-r--r--   1 root root  1347 Nov 11 20:23 index-logging.js
-rw-r--r--   1 root root   282 Nov 11 20:23 index.js
drwxr-xr-x 190 root root  4096 Nov 11 20:23 node_modules
-rw-r--r--   1 root root 84115 Nov 11 20:23 package-lock.json
-rw-r--r--   1 root root   329 Nov 11 20:23 package.json
-rw-r--r--   1 root root   697 Nov 11 20:23 readme.md

Installieren eines SDK für die Überwachung

Installieren Sie im SSH-Terminal, das mit Ihrem virtuellen Computer verbunden ist, die Azure SDK-Clientbibliothek für Application Insights.
```
sudo npm install --save applicationinsights
```
Warten Sie, bis der Befehl abgeschlossen ist, bevor Sie fortfahren.

Hinzufügen des Instrumentierungsschlüssels für die Überwachung

Installieren Sie im SSH-Terminal, das mit Ihrem virtuellen Computer verbunden ist, den Nano-Editor, um die Datei package.json zu öffnen.
```
sudo nano package.json
```
Fügen Sie am Anfang des Startskripts die Umgebungsvariable APPINSIGHTS_INSTRUMENTATIONKEY hinzu. Ersetzen Sie im folgenden Beispiel REPLACE-WITH-YOUR-KEY durch den Wert Ihres Instrumentierungsschlüssels.
```
"start": "APPINSIGHTS_INSTRUMENTATIONKEY=REPLACE-WITH-YOUR-KEY pm2 start index.js --watch --log /var/log/pm2.log"
```
Speichern Sie im SSH-Terminal die Datei im Nano-Editor mit STRG + X.
Geben Sie bei entsprechender Aufforderung im Nano-Editor Y zum Speichern ein.
Akzeptieren Sie bei entsprechender Aufforderung im Nano-Editor den Dateinamen.

Beenden des virtuellen Computers zum Ändern der Anwendung

Die Azure-Clientbibliothek befindet sich nun im Verzeichnis node_modules, und der Schlüssel wird als Umgebungsvariable an die App übergeben. Im nächsten Schritt wird Application Insights programmgesteuert verwendet.

Beenden Sie PM2, einen Manager für den Produktionsprozess für Node.js-Anwendungen, mit den folgenden Befehlen:
```
sudo npm run-script stop 
```
Ersetzen Sie die ursprüngliche Datei index.js durch eine Datei mit Application Insights.
```
sudo npm run-script appinsights
```

Der Clientbibliotheks- und Protokollierungscode wird für Sie bereitgestellt.

const express = require('express')
const app = express()
const os = require('os');

console.log(JSON.stringify(process.env));

const AppInsights = require('applicationinsights');

if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
    console.log(`AppInsights configured with key ${process.env.APPINSIGHTS_INSTRUMENTATIONKEY}`);
} else{
    console.log(`AppInsights not configured`);
}

AppInsights.setup(process.env.APPINSIGHTS_INSTRUMENTATIONKEY)
    .setAutoDependencyCorrelation(true)
    .setAutoCollectRequests(true)
    .setAutoCollectPerformance(true, true)
    .setAutoCollectExceptions(true)
    .setAutoCollectDependencies(true)
    .setAutoCollectConsole(true)
    .setUseDiskRetryCaching(true)
    .setSendLiveMetrics(false)
    .setDistributedTracingMode(AppInsights.DistributedTracingModes.AI)
    .start();

const AppInsightsClient = AppInsights.defaultClient;


app.get('/trace', (req, res) => {

    const clientIP = req.headers['x-forwarded-for'];
    const msg = `trace route ${os.hostname()} ${clientIP} ${new Date()}`;

    console.log(msg)

    if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
        AppInsightsClient.trackPageView();
        AppInsightsClient.trackTrace({ message: msg })
        AppInsightsClient.flush();
    } else {
        msg += ' AppInsights not configured';
    }

    res.send(`${msg}`)
})

app.get('/', function (req, res) {

    const clientIP = req.headers['x-forwarded-for'];
    const msg = `root route ${os.hostname()} ${clientIP} ${new Date()}`

    console.log(msg)

    res.send(msg)

})
app.listen(3000, function () {
    console.log(`Hello world app listening on port 3000! ${os.hostname()}`)
})

Starten Sie die App mit PM2 neu, um die nächste Umgebungsvariable zu übernehmen.
```
sudo npm start
```

Verwenden der App zum Überprüfen der Protokollierung

Testen Sie die App mit der neuen Route trace in einem Webbrowser:
```
http://YOUR-VM-PUBLIC-IP-ADDRESS/trace
```
Im Browser wird die Antwort trace route demo-vm YOUR-CLIENT-IP VM-DATE-TIME mit Ihrer IP-Adresse angezeigt.

Anzeigen des Protokolls für NGINX

Der virtuelle Computer (VM) erfasst Protokolle für NGINX, die angezeigt werden können.

Dienst	Speicherort des Protokolls
NGINX	/var/log/nginx/access.log

Zeigen Sie im SSH-Terminal das VM-Protokoll für den NGINX-Proxydienst mit dem folgenden Befehl an, um das Protokoll einzusehen:

cat /var/log/nginx/access.log

Das Protokoll enthält den Aufruf Ihres lokalen Computers.

"GET /trace HTTP/1.1" 200 10 "-"

Anzeigen des Protokolls für PM2

Der virtuelle Computer sammelt Protokolle für PM2, die angezeigt werden können.

Dienst	Speicherort des Protokolls
PM2	/var/log/pm2.log

Zeigen Sie das VM-Protokoll für den PM2-Dienst an. Dabei handelt es sich um Ihre Express.js-Node-Web-App. Verwenden Sie in der gleichen Bash-Shell den folgenden Befehl, um das Protokoll anzuzeigen:
```
cat /var/log/pm2.log
```

Das Protokoll enthält den Aufruf Ihres lokalen Computers.

grep "Hello world app listening on port 3000!" /var/log/pm2.log

Das Protokoll enthält außerdem Ihre Umgebungsvariablen (einschließlich Ihres ApplicationInsights-Schlüssels), die im npm-Startskript übergeben werden. Verwenden Sie den folgenden grep-Befehl, um zu überprüfen, ob Ihr Schlüssel in den Umgebungsvariablen enthalten ist:
```
grep APPINSIGHTS_INSTRUMENTATIONKEY /var/log/pm2.log
```
Dadurch wird Ihr PM2-Protokoll mit dem in einer anderen Farbe hervorgehobenen Instrumentierungsschlüssel (APPINSIGHTS_INSTRUMENTATIONKEY) angezeigt.

VM-Protokollierung und Cloudprotokollierung

In dieser Anwendung werden unter Verwendung von console.log die Nachrichten nur in die auf dem virtuellen Computer gefundenen PM2-Protokolle geschrieben. Wenn Sie die Protokolle oder den virtuellen Computer löschen, gehen diese Informationen verloren.

Wenn Sie die Protokolle über die Lebensdauer Ihres virtuellen Computers hinaus beibehalten möchten, verwenden Sie Application Insights.

5. Bereinigen von Ressourcen

Nach Abschluss dieses Tutorials müssen Sie die Ressourcengruppe entfernen, in der alle Ressourcen enthalten sind, um sicherzustellen, dass Ihnen hierfür keine weiteren Nutzungskosten in Rechnung gestellt werden.

Verwenden Sie im gleichen Terminal den Azure CLI-Befehl az group delete, um die Ressourcengruppe zu löschen:

az group delete --name rg-demo-vm-eastus -y

Die Ausführung dieses Befehls dauert einige Minuten.

Problembehandlung

Verwenden Sie bei Problemen die folgende Tabelle, um zu verstehen, wie Sie Ihr Problem beheben können:

Problem	Lösung
Gatewayfehler 502	Dieser Fehler kann darauf hindeuten, dass die Datei „index.js“ oder „package.js“ einen Fehler enthält. Weitere Informationen finden Sie in Ihren PM2-Protokollen unter `/var/log/pm2.log`. Der zuletzt aufgetretene Fehler befindet sich am Ende der Datei. Wenn Sie sicher sind, dass diese Dateien korrekt sind, beenden und starten Sie PM2 mithilfe der npm-Skripts in `package.json`.

Beispielcode

Beispielcode für einen virtuellen Express.js-Computer

Teilen über