Udostępnij za pośrednictwem

Tworzenie maszyny wirtualnej Express.js przy użyciu interfejsu wiersza polecenia platformy Azure

  • Artykuł

W tym samouczku utwórz maszynę wirtualną z systemem Linux dla aplikacji Express.js. Maszyna wirtualna jest skonfigurowana przy użyciu pliku konfiguracji cloud-init i zawiera serwer NGINX oraz repozytorium GitHub dla aplikacji Express.js. Nawiąż połączenie z maszyną wirtualną za pomocą protokołu SSH, zmień aplikację internetową, aby włączyć rejestrowanie śledzenia i wyświetlić publiczną aplikację serwera Express.js w przeglądarce internetowej.

W tym samouczku opisano następujące zadania:

  • Logowanie się do platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure
  • Tworzenie zasobu maszyny wirtualnej z systemem Linux platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure
    • Otwórz publiczny port 80
    • Instalowanie demonstracyjnej aplikacji internetowej Express.js z repozytorium GitHub
    • Instalowanie zależności aplikacji internetowej
    • Uruchamianie aplikacji internetowej
  • Tworzenie zasobu monitorowania platformy Azure za pomocą interfejsu wiersza polecenia platformy Azure
    • Nawiązywanie połączenia z maszyną wirtualną przy użyciu protokołu SSH
    • Instalowanie biblioteki klienta zestawu Azure SDK za pomocą narzędzia npm
    • Dodawanie kodu biblioteki klienta usługi Application Insights w celu utworzenia śledzenia niestandardowego
  • Wyświetlanie aplikacji internetowej z przeglądarki
    • Kierowanie żądania /trace do generowania śledzenia niestandardowego w dzienniku usługi Application Insights
    • Wyświetlanie liczby śladów zebranych w dzienniku za pomocą interfejsu wiersza polecenia platformy Azure
    • Wyświetlanie listy śladów za pomocą witryny Azure Portal
  • Usuwanie zasobów za pomocą interfejsu wiersza polecenia platformy Azure

Wymagania wstępne

  • Konto użytkownika i subskrypcja platformy Azure: utwórz bezpłatną subskrypcję.
  • Połącz się z maszyną wirtualną za pomocą protokołu SSH: użyj usługi Azure Cloud Shell lub nowoczesnego terminalu, takiego jak powłoka Bash, która obejmuje protokół SSH.

1. Tworzenie zasobu usługi Application Insights dla stron internetowych

Utwórz grupę zasobów platformy Azure dla wszystkich zasobów platformy Azure i zasób Monitor, aby zebrać pliki dziennika aplikacji internetowej w chmurze platformy Azure. Utworzenie grupy zasobów umożliwia łatwe znajdowanie zasobów i usuwanie ich po zakończeniu. Azure Monitor to nazwa usługi platformy Azure, a usługa Application Insights jest nazwą biblioteki klienta używanej w samouczku.

  1. Opcjonalnie, jeśli masz więcej niż jedną subskrypcję, użyj polecenia az account set , aby ustawić domyślną subskrypcję przed ukończeniem pozostałych poleceń.

    az account set \
    --subscription "ACCOUNT NAME OR ID"

  2. Utwórz grupę zasobów platformy Azure za pomocą polecenia az group create. Użyj nazwy rg-demo-vm-eastus:

    az group create \
    --location eastus \
    --name rg-demo-vm-eastus

Tworzenie zasobu usługi Azure Monitor za pomocą interfejsu wiersza polecenia platformy Azure

  1. Zainstaluj rozszerzenie usługi Application Insights w interfejsie wiersza polecenia platformy Azure.

    az extension add -n application-insights

  2. Użyj następującego polecenia, aby utworzyć zasób monitorowania za pomocą polecenia az monitor app-insights component create:

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

  3. Skopiuj wynik z danych wyjściowych, ponieważ będzie potrzebna ta wartość późniejinstrumentationKey.

  4. Pozostaw otwarty terminal, użyjesz go w następnym kroku.

2. Tworzenie maszyny wirtualnej z systemem Linux przy użyciu interfejsu wiersza polecenia platformy Azure

Używa pliku konfiguracji cloud-init do utworzenia zarówno serwera zwrotnego serwera proxy NGINX, jak i serwera Express.js. Serwer NGINX służy do przekazywania portu Express.js (3000) do portu publicznego (80).

  1. Utwórz plik lokalny o nazwie cloud-init-github.txt i zapisz następującą zawartość w pliku lub możesz zapisać plik repozytorium na komputerze lokalnym. Plik sformatowany w chmurze musi istnieć w tym samym folderze co ścieżka terminalu dla poleceń interfejsu wiersza polecenia platformy Azure.

    #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

  2. Przejrzyj sekcję runcmd pliku, aby dowiedzieć się, co robi.

    Element runcmd ma kilka zadań:

    • Pobierz Node.js i zainstaluj go
    • Sklonuj przykładowe repozytorium Express.js z usługi GitHub do myapp katalogu
    • Instalowanie zależności aplikacji
    • Uruchamianie aplikacji Express.js przy użyciu narzędzia PM2

Tworzenie zasobu maszyny wirtualnej

  1. Wprowadź polecenie interfejsu wiersza polecenia platformy Azure az vm create w terminalu, aby utworzyć zasób platformy Azure maszyny wirtualnej z systemem Linux. Polecenie tworzy maszynę wirtualną z pliku cloud-init i generuje klucze SSH. Uruchomione polecenie wyświetla miejsce przechowywania kluczy.

    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

  2. Poczekaj, aż proces może potrwać kilka minut.

  3. Zachowaj wartość publicIpAddress z odpowiedzi, konieczne jest wyświetlenie aplikacji internetowej w przeglądarce i nawiązanie połączenia z maszyną wirtualną. Jeśli utracisz ten adres IP, użyj polecenia interfejsu wiersza polecenia platformy Azure, az vm list-ip-addresses, aby go ponownie pobrać.

  4. Proces utworzył klucze SSH, ale w lokalizacji określonej w odpowiedzi.

  5. Przejdź do tej lokalizacji i utwórz authorized_keys plik:

    cd <SSH-KEY-LOCATION> && cat id_rsa >> authorized_keys

Otwieranie portu dla maszyny wirtualnej

Po utworzeniu maszyna wirtualna nie ma otwartych portów. Otwórz port 80 za pomocą następującego polecenia interfejsu wiersza polecenia platformy Azure, az vm open-port, aby aplikacja internetowa jest publicznie dostępna:

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

Przechodzenie do witryny sieci Web

  1. Użyj publicznego adresu IP w przeglądarce internetowej, aby upewnić się, że maszyna wirtualna jest dostępna i uruchomiona. Zmień adres URL, aby użyć wartości z publicIpAddress.

    http://YOUR-VM-PUBLIC-IP-ADDRESS

  2. Jeśli zasób ulegnie awarii z powodu błędu bramy, spróbuj ponownie za minutę, uruchomienie aplikacji internetowej może potrwać minutę.

  3. Aplikacja internetowa maszyny wirtualnej zwraca następujące informacje:

    • Nazwa maszyny wirtualnej
    • Adres IP klienta
    • Bieżąca data/godzina

    Zrzut ekranu przedstawiający przeglądarkę internetową z prostą aplikacją obsługiwaną z maszyny wirtualnej Linus na platformie Azure.

  4. Początkowy plik kodu aplikacji internetowej ma jedną trasę, która została przekazana przez serwer proxy NGINX.

    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. Nawiązywanie połączenia z maszyną wirtualną z systemem Linux przy użyciu protokołu SSH

W tej sekcji samouczka użyj protokołu SSH w terminalu, aby nawiązać połączenie z maszyną wirtualną. Protokół SSH to popularne narzędzie dostarczane z wieloma nowoczesnymi powłokami, w tym usługą Azure Cloud Shell.

Nawiązywanie połączenia za pomocą protokołu SSH i zmienianie aplikacji internetowej

  1. Połącz się ze zdalną maszyną wirtualną za pomocą następującego polecenia.

    Zastąp YOUR-VM-PUBLIC-IP element publicznym adresem IP własnej maszyny wirtualnej.

    ssh azureuser@YOUR-VM-PUBLIC-IP

    W tym procesie przyjęto założenie, że klient SSH może znaleźć klucze SSH utworzone w ramach tworzenia maszyny wirtualnej i umieszczone na komputerze lokalnym.

  2. Jeśli zostanie wyświetlony monit, czy na pewno chcesz nawiązać połączenie, odpowiedzieć y lub yes kontynuować.

  3. Użyj następującego polecenia, aby dowiedzieć się, gdzie jesteś na maszynie wirtualnej. Powinien być w katalogu głównym azureuser: /home/azureuser.

    pwd

  4. Po zakończeniu połączenia w wierszu polecenia terminalu powinien zostać zmieniony, aby wskazać nazwę użytkownika i nazwę zasobu zdalnej maszyny wirtualnej.

    azureuser@demo-vm:

  5. Twoja aplikacja internetowa znajduje się w podkatalogu myapp. Przejdź do myapp katalogu i wyświetl zawartość:

    cd myapp && ls -l

  6. Powinna zostać wyświetlona zawartość reprezentująca repozytorium GitHub sklonowane na maszynę wirtualną i pliki pakietów npm:

    -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

Instalowanie zestawu SDK monitorowania

  1. W terminalu SSH połączonym z maszyną wirtualną zainstaluj bibliotekę klienta zestawu Azure SDK dla usługi Application Insights.

    sudo npm install --save applicationinsights

  2. Przed kontynuowaniem poczekaj na zakończenie polecenia.

Dodawanie klucza instrumentacji monitorowania

  1. W terminalu SSH połączonym z maszyną wirtualną otwórz plik za pomocą edytora package.json Nano.

    sudo nano package.json

  2. Dodaj zmienną środowiskową APPINSIGHTS_INSTRUMENTATIONKEY na początku skryptu uruchamiania. W poniższym przykładzie zastąp REPLACE-WITH-YOUR-KEY element wartością klucza instrumentacji.

    "start": "APPINSIGHTS_INSTRUMENTATIONKEY=REPLACE-WITH-YOUR-KEY pm2 start index.js --watch --log /var/log/pm2.log"

  3. Nadal w terminalu SSH zapisz plik w edytorze Nano za pomocą kontrolki + X.

  4. Jeśli zostanie wyświetlony monit w edytorze Nano, wprowadź wartość Y , aby zapisać.

  5. Jeśli zostanie wyświetlony monit w edytorze Nano, po wyświetleniu monitu zaakceptuj nazwę pliku.

Zatrzymywanie maszyny wirtualnej w celu zmiany aplikacji

Biblioteka klienta platformy Azure znajduje się teraz w katalogu node_modules , a klucz jest przekazywany do aplikacji jako zmienna środowiskowa. W następnym kroku programowo jest używana usługa Application Insights.

  1. Zatrzymaj PM2, czyli menedżera procesów produkcyjnych dla aplikacji Node.js, za pomocą następujących poleceń:

    sudo npm run-script stop

  2. Zastąp oryginalny index.js plikiem przy użyciu usługi Application Insights.

    sudo npm run-script appinsights

  3. Udostępniono bibliotekę klienta i kod rejestrowania.

    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()}`)
})

  4. Uruchom ponownie aplikację z pm2, aby pobrać następną zmienną środowiskową.

    sudo npm start

Weryfikowanie rejestrowania przy użyciu aplikacji

  1. W przeglądarce internetowej przetestuj aplikację przy użyciu nowej trace trasy:

    http://YOUR-VM-PUBLIC-IP-ADDRESS/trace

    W przeglądarce zostanie wyświetlona odpowiedź trace route demo-vm YOUR-CLIENT-IP VM-DATE-TIME z adresem IP.

Wyświetlanie dziennika dla serwera NGINX

Maszyna wirtualna zbiera dzienniki dla serwera NGINX, które są dostępne do wyświetlenia.

Usługa Lokalizacja dziennika
NGINX /var/log/nginx/access.log
  1. Nadal w terminalu SSH wyświetl dziennik maszyny wirtualnej dla usługi serwera proxy NGINX za pomocą następującego polecenia, aby wyświetlić dziennik:
cat /var/log/nginx/access.log
  1. Dziennik zawiera wywołanie z komputera lokalnego.
"GET /trace HTTP/1.1" 200 10 "-"

Wyświetlanie dziennika dla PM2

Maszyna wirtualna zbiera dzienniki dla pm2, które są dostępne do wyświetlenia.

Usługa Lokalizacja dziennika
PM2 /var/log/pm2.log

  1. Wyświetl dziennik maszyny wirtualnej dla usługi PM2, która jest twoją aplikacją internetową Express.js Node. W tej samej powłoce powłoki bash użyj następującego polecenia, aby wyświetlić dziennik:

    cat /var/log/pm2.log

  2. Dziennik zawiera wywołanie z komputera lokalnego.

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

  3. Dziennik zawiera również zmienne środowiskowe, w tym klucz applicationInsights, przekazany w skrycie uruchamiania narzędzia npm. Użyj następującego polecenia grep, aby sprawdzić, czy klucz znajduje się w zmiennych środowiskowych.

    grep APPINSIGHTS_INSTRUMENTATIONKEY /var/log/pm2.log

    Spowoduje to wyświetlenie dziennika PM2 z APPINSIGHTS_INSTRUMENTATIONKEY wyróżnionym innym kolorem.

Rejestrowanie maszyn wirtualnych i rejestrowanie w chmurze

W tej aplikacji przy użyciu zapisywania console.log komunikatów w dziennikach PM2 znalezionych tylko na maszynie wirtualnej. Jeśli usuniesz dzienniki lub maszynę wirtualną, utracisz te informacje.

Jeśli chcesz zachować dzienniki poza cyklem życia maszyny wirtualnej, użyj usługi Application Insights.

5. Czyszczenie zasobów

Po ukończeniu tego samouczka musisz usunąć grupę zasobów zawierającą wszystkie jej zasoby, aby upewnić się, że nie są naliczane opłaty za więcej użycia.

W tym samym terminalu użyj polecenia interfejsu wiersza polecenia platformy Azure, az group delete, aby usunąć grupę zasobów:

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

To polecenie trwa kilka minut.

Rozwiązywanie problemów

Jeśli masz problemy, skorzystaj z poniższej tabeli, aby dowiedzieć się, jak rozwiązać problem:

Problem Rozwiązanie
Błąd bramy 502 Może to wskazywać, że plik index.js lub package.js zawiera błąd. Aby uzyskać więcej informacji, wyświetl dzienniki PM2 pod /var/log/pm2.log adresem. Najnowszy błąd znajduje się w dolnej części pliku. Jeśli masz pewność, że te pliki są poprawne, zatrzymaj i uruchom pm2 przy użyciu skryptów npm w pliku package.json.

Przykładowy kod

Następne kroki