Esercizio: Personalizzare un'immagine Docker per eseguire la propria app Web

  • 12 minuti

Un Dockerfile contiene i passaggi per la creazione di un'immagine Docker personalizzata.

Si decide di distribuire una delle app Web dell'organizzazione usando Docker. Si seleziona un'app Web semplice che implementa un'API Web per un sito Web di prenotazioni di hotel. L'API Web espone le operazioni POST e GET HTTP che creano e recuperano le prenotazioni dei clienti.

Nota

In questa versione dell'app Web le prenotazioni in realtà non vengono mantenute e le query restituiscono dati fittizi.

In questo esercizio verrà creato un Dockerfile per un'app che non ne ha uno. Quindi, l'immagine verrà creata ed eseguita in locale.

Creare un Dockerfile per l'app Web

  1. Se non è già in esecuzione, avviare Docker sul computer.

  2. In una finestra del prompt dei comandi o nel computer locale eseguire il comando seguente per scaricare il codice sorgente per l'app Web.

    git clone https://github.com/MicrosoftDocs/mslearn-hotel-reservation-system.git

  3. Immettere il comando seguente per aprire la directory src.

    cd mslearn-hotel-reservation-system/src

  4. Nella directory src immettere i comandi seguenti per creare un nuovo file denominato Dockerfile e aprirlo in Blocco note:

    copy NUL Dockerfile
notepad Dockerfile

    Nota

    Per impostazione predefinita, il comando blocco note apre un file di testo. Assicurarsi di salvarlo come tipo di file Tutti i file senza estensione. Per verificare, aprire la cartella src in Esplora file, selezionare Visualizza > Mostra> Estensioni nomi file. Se necessario, rinominare il file e rimuovere .txt dal nome file.

  5. Aggiungere il codice seguente al Dockerfile:

    FROM mcr.microsoft.com/dotnet/core/sdk:2.2
WORKDIR /src
COPY ["/HotelReservationSystem/HotelReservationSystem.csproj", "HotelReservationSystem/"]
COPY ["/HotelReservationSystemTypes/HotelReservationSystemTypes.csproj", "HotelReservationSystemTypes/"]
RUN dotnet restore "HotelReservationSystem/HotelReservationSystem.csproj"

    Questo codice contiene comandi che recuperano un'immagine contenente l'SDK di .NET Core Framework. I file di progetto per l'app Web (HotelReservationSystem.csproj) e il progetto di libreria (HotelReservationSystemTypes.csproj) vengono copiati nella cartella /src nel contenitore. Il comando dotnet restore scarica le dipendenze richieste da questi progetti da NuGet.

  6. Aggiungere il codice seguente in fondo al Dockerfile:

    COPY . .
WORKDIR "/src/HotelReservationSystem"
RUN dotnet build "HotelReservationSystem.csproj" -c Release -o /app

    Questi comandi copiano il codice sorgente per l'app Web nel contenitore, quindi eseguono il comando dotnet build per compilare l'app. Le DLL risultanti vengono scritte nella cartella /app nel contenitore.

  7. Aggiungere il comando seguente in fondo al Dockerfile.

    RUN dotnet publish "HotelReservationSystem.csproj" -c Release -o /app

    Il comando dotnet publish copia i file eseguibili per il sito Web in una nuova cartella e rimuove eventuali file temporanei. I file presenti in questa cartella possono quindi essere distribuiti a un sito Web.

  8. Aggiungere i comandi seguenti in fondo al Dockerfile.

    EXPOSE 80
WORKDIR /app
ENTRYPOINT ["dotnet", "HotelReservationSystem.dll"]

    Il primo comando apre la porta 80 nel contenitore. Il secondo comando passa alla cartella /app che contiene la versione pubblicata dell'app Web. L'ultimo comando specifica che quando il contenitore è in esecuzione deve essere eseguito il comando dotnet HotelReservationSystem.dll. Questa libreria contiene il codice compilato per l'app Web.

  9. Salvare il file e chiudere l'editor di testo. Assicurarsi di salvarlo come tipo di file Tutti i file senza estensione.

Creare e distribuire l'immagine usando il Dockerfile

  1. Al prompt dei comandi eseguire il comando seguente per creare l'immagine per l'app di esempio usando il Dockerfile. Non dimenticare di aggiungere . alla fine del comando. Questo comando consente di creare l'immagine e di archiviarla in locale. All'immagine viene assegnato il nome reservationsystem. Verificare che l'immagine venga creata correttamente. Al termine del processo potrebbe essere visualizzato un avviso relativo alle autorizzazioni per file e directory. Ai fini di questo esercizio, è possibile ignorare questo avviso. La compilazione dell'immagine potrebbe richiedere qualche minuto.

    docker build -t reservationsystem .

  2. Eseguire il comando seguente per verificare che l'immagine sia stata creata e archiviata nel registro locale:

    docker image list

    Il nome dell'immagine sarà reservationsystem. Si otterrà anche un'immagine denominata microsoft/dotnet:

    REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
reservationsystem   latest              d2501f0f2ced        About a minute ago   1.76GB

Testare l'app Web

  1. Immettere il codice seguente per eseguire un contenitore che usa l'immagine reservationsystem. Docker restituirà una stringa lunga esadecimale. Il contenitore viene eseguito in background senza alcuna interfaccia utente. La porta 80 del contenitore è mappata alla porta 8080 del computer host. Il contenitore è denominato reservations.

    docker run -p 8080:80 -d --name reservations reservationsystem

  2. Aprire un Web browser e passare all'indirizzo http://localhost:8080/api/reservations/1. Verrà visualizzato un oggetto JSON contenente i dati per il numero di prenotazione 1 simile all'output seguente:

    Screenshot dell'app Web del sistema di prenotazione di hotel in esecuzione in un browser.

    Sostituire "1" alla fine dell'URL localhost con un numero di prenotazione diverso, ad esempio 2 o 20, per visualizzare i dettagli della prenotazione corrispondenti.

  3. Eseguire il comando seguente per visualizzare lo stato del contenitore:

    docker ps -a

    L'output elenca quanto segue per tutti i contenitori disponibili:

    • ID CONTENITORE
    • IMMAGINE
    • COMANDO
    • ORA DI CREAZIONE
    • STATO
    • PORTE
    • NAMES

    Verificare che STATUS del contenitore sia Attivo.

    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
07b0d1de4db7        reservationsystem   "dotnet HotelReserva…"   5 minutes ago       Up 5 minutes        0.0.0.0:8080->80/tcp   reservations

  4. Immettere il comando seguente per arrestare il contenitore reservations:

    docker container stop reservations

  5. Eliminare il contenitore reservations dal registro locale.

    docker rm reservations

  6. Lasciare il contenitore reservations nel registro locale. Questa immagine verrà usata nell'esercizio successivo.

Complimenti. È stata creata un'immagine per l'app Web ed è stata eseguita l'immagine usando un contenitore Docker.