Esercizio - Compilare un'immagine del contenitore per il microservizio .NET

5 minuti

In questo esercizio si crea un endpoint di microservizio e lo si containera usando .NET SDK e Docker.

Annotazioni

È possibile completare questo esercizio in un'istanza di GitHub Codespaces con Docker e .NET SDK preinstallato. Quando si usano questi strumenti e tecniche nel proprio ambiente di sviluppo, assicurarsi di avere questi prerequisiti installati.

Aprire l'ambiente di sviluppo

Si può scegliere di ospitare l'esercizio in un codespace GitHub oppure di completarlo in locale in Visual Studio Code.

Per usare uno spazio di codice, creare uno spazio di codice GitHub preconfigurato con questo collegamento alla creazione di Codespace.

GitHub richiede alcuni minuti per creare e configurare lo spazio di codice. Al termine del processo, viene visualizzato il file di codice per l'esercizio. Il codice usato per il resto di questo modulo si trova nella directory /dotnet-docker .

Per usare Visual Studio Code, clonare il https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative repository nel computer locale. Quindi:

Installare tutti i requisiti di sistema per eseguire Dev Container in Visual Studio Code.
Verificare che Docker sia in esecuzione.
In una nuova finestra di Visual Studio Code, aprire la cartella del repository clonato
Premere CTRL+MAIUSC+P per aprire il riquadro comandi.
Ricerca: >Contenitori di sviluppo: Ricompilare e riaprire nel contenitore
Selezionare eShopLite - dotnet-docker dall'elenco a discesa. Visual Studio Code crea il contenitore di sviluppo in locale.

Usare il comando di pubblicazione di .NET per creare l'immagine del back-end Products

La versione più recente di .NET 8 migliora il supporto per la containerizzazione. È possibile usare il dotnet publish comando per creare un'immagine Docker per i microservizi. Il comando crea un'immagine del contenitore senza privilegi di root che esegue i servizi in un app account. L'esecuzione di contenitori senza radice è ideale per la sicurezza e le prestazioni. Il comando sa come selezionare l'immagine di base migliore controllando le impostazioni nel file di progetto.

Per creare le immagini per tutti i eShopLite servizi, passare alla scheda TERMINALE ed eseguire questo comando:

cd ./dotnet-docker 
 dotnet publish /p:PublishProfile=DefaultContainer

Viene visualizzato un output simile ai messaggi seguenti:

DataEntities -> /workspaces/mslearn-dotnet-cloudnative/dotnet-docker/DataEntities/bin/Release/net8.0/publish/
Products -> /workspaces/mslearn-dotnet-cloudnative/dotnet-docker/Products/bin/Release/net8.0/Products.dll
Products -> /workspaces/mslearn-dotnet-cloudnative/dotnet-docker/Products/bin/Release/net8.0/publish/
Store -> /workspaces/mslearn-dotnet-cloudnative/dotnet-docker/Store/bin/Release/net8.0/Store.dll
Store -> /workspaces/mslearn-dotnet-cloudnative/dotnet-docker/Store/bin/Release/net8.0/publish/
Building image 'store' with tags 'latest' on top of base image 'mcr.microsoft.com/dotnet/aspnet:8.0'.
Building image 'products' with tags 'latest' on top of base image 'mcr.microsoft.com/dotnet/aspnet:8.0'.
Pushed image 'store:latest' to local registry via 'docker'.
Pushed image 'products:latest' to local registry via 'docker'.

Il comando legge il file della soluzione, ha determinato che conteneva tre progetti, li ha compilati e ha creato le immagini per i progetti di negozio e di prodotti. Le immagini sono denominate in base ai progetti e pubblicate nel registro Docker locale.

Verificare che le immagini siano disponibili in Docker:

docker images

Viene visualizzato un output simile ai messaggi seguenti:

REPOSITORY                          TAG       IMAGE ID       CREATED              SIZE
products                            latest    63614e340088   About a minute ago   293MB
store                               latest    e9458c3abdb1   About a minute ago   218MB

Usare un Dockerfile per creare l'immagine del back-end di Products

Se si vuole un maggiore controllo sulla modalità di compilazione delle immagini, è possibile usare un Dockerfile per creare un'immagine per il servizio Web Products.

Nel riquadro EXPLORER creare un file denominato Dockerfile in ./dotnet-docker/Products. Il file è vuoto.
Immettere il codice seguente:
```
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build

WORKDIR /DataEntities
COPY "DataEntities/DataEntities.csproj" .
RUN dotnet restore
COPY "DataEntities" .
RUN dotnet publish -c release -o /app
```
Dopo aver completato i passaggi seguenti, questo codice configurerà la libreria DataEntities nell'immagine Docker Products:
- Eseguire il pull dell'immagine mcr.microsoft.com/dotnet/sdk:8.0 e denominare l'immagine build.
- Impostare la directory di lavoro all'interno dell'immagine su /DataEntities.
- Copiare il file denominato DataEntities.csproj trovato localmente nella /DataEntities directory creata.
- Chiamare dotnet restore sul progetto.
- Copiare tutti gli elementi nella directory DataEntities locale nell'immagine.
- Chiamare dotnet publish sul progetto.
Direttamente sotto l'ultima riga immettere questo codice:
```
 WORKDIR /src
 COPY Products/Products.csproj .
 RUN dotnet restore
 COPY Products .
 RUN dotnet publish -c release -o /app
```
Questo codice esegue i passaggi seguenti in sequenza quando viene richiamato:
- Impostare la directory di lavoro all'interno dell'immagine su /src.
- Copiare il file denominato Products.csproj trovato in locale nella /src directory creata.
- Chiamare dotnet restore sul progetto.
- Copiare tutto il contenuto della directory Products locale nell'immagine.
- Chiamare dotnet publish sul progetto.
Direttamente sotto l'ultima riga immettere questo codice:
```
 FROM mcr.microsoft.com/dotnet/aspnet:8.0
 WORKDIR /app
 EXPOSE 80
 EXPOSE 443
 COPY --from=build /app .
 ENTRYPOINT ["dotnet", "Products.dll"]
```
Questo codice esegue i passaggi seguenti in sequenza quando viene richiamato:
- Esegue il pull dell'immagine mcr.microsoft.com/dotnet/aspnet:8.0.
- Impostare la directory di lavoro all'interno dell'immagine su /app.
- Esporre le porte 80 e 443.
- Copiare tutti gli elementi dalla directory app dell'immagine build creata nella directory app di questa immagine.
- Impostare il punto di ingresso di questa immagine su dotnet e passare Products.dll come argomento.

Creare l'immagine Docker

Dopo aver completato il Dockerfile, il passaggio successivo consiste nell'usarlo per creare un'immagine Docker:

Per creare l'immagine per il servizio back-end Products, passare alla scheda TERMINALE ed eseguire questo comando:
```
cd ./dotnet-docker 
 docker build -t productsbackend:latest -f Products/Dockerfile .
```
Vengono eseguiti i comandi in Dockerfile nella directory corrente e viene applicato il tag productsbackend:latest all'immagine risultante.

Dopo una grande quantità di output, verrà creata l'immagine. L'immissione docker images mostra un elenco di tutte le immagini nello spazio di codice, inclusi productsbackend. L'altra immagine è quella per lo spazio di codice stesso.

Viene visualizzato un output simile ai messaggi seguenti:

REPOSITORY                          TAG       IMAGE ID       CREATED              SIZE
products                            latest    63614e340088   10 minutes ago       293MB
store                               latest    e9458c3abdb1   10 minutes ago       218MB
productsbackend                     latest   190783f7e06f    About a minute ago   293MB

Considerare la differenza tra l'uso dotnet publish e la necessità di creare manualmente i Dockerfile per ogni microservizio nelle app.

Eseguire il contenitore e testare il servizio

È ora possibile usare l'immagine per eseguire e ospitare il servizio Prodotti.

Per creare ed eseguire un contenitore dall'immagine dei nuovi prodotti ed esporre il servizio sulla porta 32001, eseguire questo comando:
```
docker run -it --rm -p 32001:8080  products
```
In alternativa, se si vuole eseguire l'immagine creata usando il Dockerfile, eseguire:
```
docker run -it --rm -p 32001:8080 productsbackend
```
Per testare il servizio, passare alla scheda PORTE e quindi a destra dell'indirizzo locale per la porta Back-End selezionare l'icona del globo. Il browser apre una nuova scheda in corrispondenza di tale indirizzo.

Per eseguire query su alcuni prodotti, aggiungere l'indirizzo con /api/product e quindi premere INVIO. Verranno visualizzate alcune informazioni sul prodotto elencate in formato JSON.

[
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...
]

Commenti e suggerimenti

Questa pagina è stata utile?