Modulo 3: API Web .NET su AWS App Runner
LABORATORIO PRATICO
Obiettivi del laboratorio
In questo laboratorio pratico ci occuperemo di creare un'API Web .NET che utilizza una tabella DynamoDB, di containerizzarla e di ospitarla in AWS App Runner. Puoi eseguire questo laboratorio su un PC Windows, macOS o Linux o su un ambiente Cloud9 nel cloud.
Inizierai creando una tabella DynamoDB e un progetto API Web .NET 6 che vi acceda. Dopo averlo testato in locale, utilizzerai Docker e lo Strumento di implementazione AWS per .NET CLI per containerizzare e distribuire il software in Amazon Elastic Container Registry (ECR). Quindi, creerai il servizio App Runner, insieme agli artefatti AWS necessari per comunicare con DynamoDB, che includeranno un ruolo IAM, un connettore VPC e un endpoint VPC per DynamoDB. Potrai testare la tua applicazione nel cloud e verificare che l'app sia in grado di recuperare dati da DynamoDB. Successivamente, avrai modo di monitorare l'applicazione nella console App Runner e di rivedere i log. Infine, aggiornerai il progetto, invierai un aggiornamento a ECR e vedrai come App Runner lo distribuirà automaticamente. Infine, eliminerai l'applicazione e le relative risorse.
Questo laboratorio prevede 12 passaggi:
- Configurare AWS
- Configurare l'ambiente di sviluppo
- Creare una tabella DynamoDB
- Creare un progetto API Web .NET
- Eseguire il test in locale
- Pubblicare il progetto API Web su ECR
- Creare il ruolo IAM
- Creare il servizio App Runner
- Creare un endpoint VPC per DynamoDB
- Eseguire il test nel cloud
- Distribuire un aggiornamento
- Chiusura
Tempo richiesto per il completamento
90 minuti
Implementazione
Passaggio 1: configurare AWS
In questo passaggio configurerai il tuo ambiente AWS.
Se stai già sviluppando e distribuendo su AWS App Runner e hai installato lo Strumento di implementazione AWS per .NET CLI, puoi passare rapidamente al passaggio 3.
1. Ottieni un account AWS
Usa un account AWS esistente o crea un account AWS. Non utilizzare un account di produzione.
2. Scegli la Regione AWS
Accedi alla console AWS e scegli una Regione AWS in cui lavorare che supporti AWS App Runner e DynamoDB.
3. Crea un ambiente di sviluppo
Se usi il computer locale per questo laboratorio, procedi con il passaggio 2.
Se usi Cloud9, continua di seguito.
Configura un ambiente Cloud9 dalla console AWS:
A. Nella console AWS, accedi a Cloud9 e fai clic su Create environment (Crea ambiente).
B. Assegna un nome all'ambiente AppRunnerLab.
C. Lascia le impostazioni predefinite e fai clic su Create (Crea).
D. Attendi la creazione dell'ambiente, operazione che richiederà alcuni minuti. Se la creazione dell'ambiente non riesce perché il tipo di istanza t2.micro non è disponibile nella Regione, ripeti i passaggi precedenti e seleziona un altro tipo di istanza di piccole dimensioni. Se il tipo di istanza non è incluso nel Piano gratuito, tieni presente la tariffa che ti verrà addebitata per tutta la durata del laboratorio.
Verifica il tuo lavoro
Ora dovresti:
✓ Avere un account AWS
✓ Sapere come accedere alla console di gestione AWS
✓ Aver selezionato una Regione in cui lavorare
✓ Disporre di una macchina locale o un ambiente Cloud9
Passaggio 2: configurare l'ambiente di sviluppo
In questo passaggio installerai il software per configurare un ambiente di sviluppo. Salta gli elementi che hai già installato.
1. Installa l'AWS CLI
Installa l'Interfaccia della linea di comando AWS (CLI).
2. Configura l'AWS CLI
Configura l'AWS CLI in modo che sia collegata a un utente nel tuo account AWS.
In una finestra di comando/terminale, configura la Regione con questo comando: aws configure
3. Installa l'SDK .NET
Installa l'SDK .NET 6. Scarica e installa l'SDK per il tuo sistema operativo.
Se usi Cloud9, puoi eseguire questi comandi in Install Required Tools (Installa strumenti richiesti), Passaggi 1 e 2. Quindi, esegui il seguente comando: ./dotnet-install.sh -c LTS.
4. Installa lo strumento di sviluppo AWS per .NET CLI
In una finestra di comando/terminale, installa lo Strumento di implementazione AWS per .NET CLI con questo comando:
dotnet tool install -g aws.deploy.tools
5. Installa Docker
Installa Docker Desktop. Se disponi già di Docker, tieni presente che è necessaria la versione 17.05 o successiva.
6. Installa un IDE
Installa un IDE come Microsoft Visual Studio 2022 (Windows), Visual Studio Code (Linux, macOS, Windows) o JetBrains Rider (Linux, macOS, Windows). Assicurati di aver installato le opzioni o le estensioni per lo sviluppo Web .NET in C#.
Verifica il tuo lavoro
Ora dovresti:
✓ Avere tutti i software prerequisiti installati
✓ Aver configurato l'AWS CLI per il tuo utente e la tua Regione AWS
Passaggio 3: creare una tabella DynamoDB
In questo passaggio creerai una tabella DynamoDB denominata Weather (Meteo) e alcuni record di dati.
1. Crea una tabella DynamoDB nella console AWS
Nella console AWS, accedi ad Amazon DynamoDB e fai clic su Create table (Crea tabella):
A. Nome della tabella: Weather (Meteo)
B. Chiave di partizione: Location (Posizione)
C. Chiave di ordinamento: Timestamp
D. Fai clic su Create table (Crea tabella)
2. Compila la tabella con gli elementi
Fai clic sul nome della tabella Weather (Meteo) per accedere alla pagina dei dettagli, quindi fai clic su Explore table items (Esplora gli elementi della tabella). Aggiungi questi elementi:
A. Fai clic su Create item (Crea elemento) e JSON view (Visualizzazione JSON). Inserisci il JSON qui sotto (Dallas, mattina) e fai clic su Create item (Crea elemento).
{
"Location": {
"S": "Dallas"
},
"Timestamp": {
"S": "2022-07-23T06:00:00"
},
"Summary": {
"S": "Hot"
},
"TempC": {
"N": "33"
},
"TempF": {
"N": "92"
}
}B. Allo stesso modo, aggiungi il secondo elemento (Dallas, mezzogiorno) con questo JSON:
{
"Location": {
"S": "Dallas"
},
"Timestamp": {
"S": "2022-07-23T12:00:00"
},
"Summary": {
"S": "Scorching"
},
"TempC": {
"N": "43"
},
"TempF": {
"N": "109"
}
}C. Aggiungi il terzo elemento (Dallas, sera) con questo JSON:
{
"Location": {
"S": "Dallas"
},
"Timestamp": {
"S": "2022-07-23T18:00:00"
},
"Summary": {
"S": "Hot"
},
"TempC": {
"N": "36"
},
"TempF": {
"N": "97"
}
}D. Aggiungi il quarto elemento (Minneapolis, mattina) con questo JSON:
{
"Location": {
"S": "Minneapolis"
},
"Timestamp": {
"S": "2022-07-23T06:00:00"
},
"Summary": {
"S": "Cool"
},
"TempC": {
"N": "13"
},
"TempF": {
"N": "56"
}
}E. Aggiungi il quinto elemento (Minneapolis, mezzogiorno) con questo JSON:
{
"Location": {
"S": "Minneapolis"
},
"Timestamp": {
"S": "2022-07-23T12:00:00"
},
"Summary": {
"S": "Balmy"
},
"TempC": {
"N": "22"
},
"TempF": {
"N": "72"
}
}F. Aggiungi il sesto elemento (Minneapolis, sera) con questo JSON:
{
"Location": {
"S": "Minneapolis"
},
"Timestamp": {
"S": "2022-07-23T18:00:00"
},
"Summary": {
"S": "Balmy"
},
"TempC": {
"N": "19"
},
"TempF": {
"N": "67"
}
}Verifica il tuo lavoro
Ora dovresti:
✓ Disporre di una tabella DynamoDB denominata Weather (Meteo), popolata da 6 elementi.
Passaggio 4: creare un progetto API Web .NET
In questo passaggio, utilizzerai il comando dotnet new per creare un progetto API Web e aggiornarne il codice per recuperare i dati dalla tabella DynamoDB.
1. CD a una cartella di sviluppo
Apri una finestra di comando/terminale e CD a una cartella di sviluppo:
2. Crea un progetto API Web .NET
Esegui il comando dotnet new di seguito per creare un nuovo progetto API Web denominato HelloAppRunnerVpc.
dotnet new webapi -n HelloAppRunnerVpc --framework net6.0
3. Apri il progetto nel tuo IDE
Apri il progetto HelloAppRunnerVpc nel tuo IDE.
Se hai installato un kit di strumenti AWS per il tuo IDE, imposta la Regione in Esploratore AWS sulla Regione selezionata al passaggio 1.
4. Esamina il progetto generato
Il progetto generato è un'API WeatherForecast, molto comunemente utilizzata negli esempi .NET.
Per provarla, premi F5 e testala con Swagger. Vedrai che il servizio ha un'azione /WeatherForecast che restituisce dati meteorologici simulati JSON.
Arresta l'esecuzione del programma.
5. Aggiungi il pacchetto NuGet dell'AWS SDK
Nella finestra di comando/terminale, CD alla cartella del progetto. Esegui il comando dotnet add package riportato di seguito per aggiungere il pacchetto NuGet dell'AWS SDK: AWSSDK.DynamoDBv2 al progetto:
cd HelloAppRunnerVpc
dotnet add package AWSSDK.DynamoDBv26. Modifica Program.cs
Apri Program.cs nell'editor di codice e rimuovi o imposta come commenta questa istruzione, che non sarà necessaria con App Runner:
//app.UseHttpsRedirection();7. Codifica la classe WeatherForecast
Apri WeatherForecast.cs e sostituiscilo con il codice seguente. Questa classe contiene un elemento recuperato dalla tabella Weather (Meteo):
namespace HelloAppRunnerVpc;
public class WeatherForecast
{
public DateTime Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF { get; set; }
public string? Summary { get; set; }
}8. Codifica la classe WeatherForecastController
using Amazon;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
using Microsoft.AspNetCore.Mvc;
namespace HelloAppRunnerVpc.Controllers;
[ApiController]
[Route("")]
public class WeatherForecastController : ControllerBase
{
static readonly RegionEndpoint region = RegionEndpoint.USEast1;
private readonly ILogger _logger;
public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
_logger = logger;
}
[HttpGet("")]
public string GetHealthcheck()
{
return "Healthcheck: Healthy";
}
[HttpGet("WeatherForecast")]
public async Task<IEnumerable<WeatherForecast>> GetWeatherForecast(string location = "Dallas")
{
List<WeatherForecast> forecasts = new List<WeatherForecast>();
try
{
_logger.LogInformation($"00 enter GET, location = {location}");
var client = new AmazonDynamoDBClient(region);
Table table = Table.LoadTable(client, "Weather");
var filter = new ScanFilter();
filter.AddCondition("Location", ScanOperator.Equal, location);
var scanConfig = new ScanOperationConfig()
{
Filter = filter,
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List<string> { "Location", "Timestamp", "TempC", "TempF", "Summary" }
};
_logger.LogInformation($"10 table.Scan");
Search search = table.Scan(scanConfig);
List<Document> matches;
do
{
_logger.LogInformation($"20 table.GetNextSetAsync");
matches = await search.GetNextSetAsync();
foreach (var match in matches)
{
forecasts.Add(new WeatherForecast
{
Date = Convert.ToDateTime(match["Timestamp"]),
TemperatureC = Convert.ToInt32(match["TempC"]),
TemperatureF = Convert.ToInt32(match["TempF"]),
Summary = Convert.ToString(match["Summary"])
});
}
} while (!search.IsDone);
_logger.LogInformation($"30 exited results loop");
}
catch (Exception ex)
{
_logger.LogError(ex, "90 Exception");
}
_logger.LogInformation($"99 returning {forecasts.Count} results");
return forecasts.ToArray();
}
}9. Salva le modifiche e crea
Salva le modifiche e assicurati che il progetto venga compilato.
Verifica il tuo lavoro
Ora dovresti:
✓ Avere un progetto di API Web denominato HelloAppRunnerVpc
✓ Aver impostato la tua Regione in WeatherForecastController.cs
Passaggio 5: eseguire il test in locale
In questo passaggio testerai l'API Web in locale e confermerai il recupero dei dati da DynamoDB.
1. Esegui il debug del progetto
Premi F5 nel tuo IDE e attendi che l'app venga creata e avviata in un browser.
2. Verifica l'azione di controllo dell'integrità
Nel browser, rimuovi il percorso Swagger dall'URL per accedere alla root del servizio; dovresti visualizzare un messaggio di controllo dell'integrità. App Runner eseguirà regolarmente il ping del sito per verificarne l'integrità.
3. Verifica l'azione Previsioni meteo per Dallas
Aggiungi /WeatherForecast?location=Dallas alla fine del percorso URL. Dovresti vedere apparire i dati JSON delle previsioni meteo, con i valori che hai creato nella tabella DynamoDB nel passaggio 1.
4. Verifica l'azione Previsioni meteo per Minneapolis
Modifica il percorso dell'URL in modo che termini con /WeatherForecast?location=Minneapolis. Ora vedi i dati relativi a quella città.
5. Verifica l'azione Previsioni meteo per una posizione non valida
Prova un nome di posizione diverso e non avrai alcuna risposta perché nella tabella non sono presenti dati relativi a quella posizione.
6. Arresta il programma
Arresta l'esecuzione del programma.
Sebbene sia stato semplice per la nostra app accedere a DynamoDB durante i test in locale, non sarà così nel cloud, perché App Runner è limitato agli endpoint pubblici per impostazione predefinita. Dovremo eseguire ulteriori passaggi per aggiungere un connettore VPC per App Runner e un endpoint VPC corrispondente per DynamoDB.
Verifica il tuo lavoro
Ora dovresti:
✓ Aver testato il tuo progetto di API Web in locale.
✓ Aver confermato il recupero dei dati DynamoDB.
Passaggio 6: pubblicare il progetto API Web su ECR
1. Crea un Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["HelloAppRunnerVpc.csproj", "."]
RUN dotnet restore "./HelloAppRunnerVpc.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "HelloAppRunnerVpc.csproj" -c Release -o /app/build
FROM build AS publish
RUN dotnet publish "HelloAppRunnerVpc.csproj" -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "HelloAppRunnerVpc.dll"]2. Distribuisci su ECR
Distribuisci il tuo progetto come immagine di container su ECR:
a. Nella finestra di comando/terminale, esegui questo comando per avviare la distribuzione, specificando la tua Regione preferita. (Figura 1)
dotnet aws deploy --region us-west-2
b. Seleziona l'opzione per inviare le immagini di container ad Amazon Elastic Container Registry (ECR)
c. Nel prompt Current Settings (Impostazioni correnti) inserisci il numero per modificare il tag immagine e impostalo su latest (più recente). (Figura 2)
d. Conferma la distribuzione premendo Enter (Invio).
3. Attendi la distribuzione
Attendi il completamento della distribuzione.
4. Conferma la distribuzione nella console AWS
Verifica il tuo lavoro
Ora dovresti:
✓ Aver containerizzato il tuo progetto con un Dockerfile.
✓ Aver implementato un'immagine di container su Amazon ECR.
Passaggio 7: creare un ruolo IAM
In questo passaggio utilizzerai la console AWS per creare un ruolo IAM denominato AppRunnerInstanceDynamoDB. Questo ruolo consentirà alle istanze EC2 di App Runner di accedere alla tabella DynamoDB.
1. Crea una policy per l'accesso alle tabelle DynamoDB
Crea una policy che consenta l'accesso alla tabella Weather (Meteo) di DynamoDB:
a. Vai a Identity and Access Management (IAM).
b. Seleziona Policies (Policy) dal riquadro a sinistra e fai clic su Create policy (Crea policy).
c. Crea la policy e inserisci il file JSON qui sotto, sostituendo [account] con il tuo numero di account AWS a 12 cifre e [region] con la tua Regione.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "arn:aws:dynamodb:[region]:[account]:table/Weather"
}
]
} d. Fai clic su Next: Tags (Avanti: Tag) e poi su Next: Review (Avanti: Rivedi). Assegna un nome alla policy ddb-Weather e fai clic su Create policy (Crea policy).
2. Crea un ruolo per le istanze EC2
Crea un ruolo per le istanze EC2 di App Runner:
a. Seleziona Roles (Ruoli) dal riquadro a sinistra e fai clic su Create role (Crea ruolo).
b. Per Trusted entity type (Tipo di entità affidabile), seleziona AWS service (servizio AWS). (Figura 1)
c. Nella sezione Use case (Caso d'uso), seleziona EC2 e fai clic su Next (Avanti). (Figura 1)
d. Cerca e seleziona queste autorizzazioni: ddb-Weather, AmazonDynamoDBFullAccess e AWSAppRunnerFullAccess. Quindi fai clic su Next (Avanti). (Figura 2)
e. Nella scheda Trust relationships (Relazioni di attendibilità), fai clic su Edit trust policy (Modifica policy di attendibilità). Sostituiscila con questo file JSON e fai clic su Update policy (Aggiorna policy). (Figura 5)
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"ec2.amazonaws.com",
"tasks.apprunner.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
} f. Assegna un nome al ruolo AppRunnerInstanceDynamoDB e fai clic su Create role (Crea ruolo). (Figura 3)
Verifica il tuo lavoro
Ora dovresti:
✓ Avere un ruolo IAM denominato AppRunnerInstanceDynamoDB con 3 policy.
Passaggio 8: creare il servizio App Runner
In questo passaggio creerai il servizio App Runner e un connettore VPC.
1. Crea servizio
Nella console AWS, accedi ad AWS App Runner e fai clic su Create service (Crea servizio).
a. Tipo di repository: Container registry (Registro di container). (Figura 1)
b. Fornitore: Amazon ECR.
c. Fai clic su Browse (Sfoglia) e seleziona il container distribuito su ECR nel passaggio 6. (Figura 2)
d. Nella sezione Deployment settings trigger (Impostazioni trigger di distribuzione), seleziona Automatic (Automatico).
e. Nella sezione ECR access role (Ruolo di accesso ECR), seleziona Create new service role (Crea un nuovo ruolo di servizio).
f. Fai clic su Next (Avanti).
2. Configura il servizio
Nella pagina Configure service (Configura servizio),
a. Nome del servizio HelloAppRunnerVpc.
b. b. Porta: 80.
3. Configura il ruolo dell'istanza
Espandi la sezione Security (Sicurezza) e imposta il ruolo dell'istanza su AppRunnerInstanceDynamoDB.
4. Crea connettore VPC
Espandi la sezione Networking (Rete) e crea un connettore VPC:
a. In Networking (Rete), seleziona Custom VPC (VPC personalizzato).
b. Nella sezione VPC connector (Connettore VPC), fai clic su Add new (Aggiungi nuovo).
c. Sezione VPC connector name (Nome del connettore VPC): AppRunnerDynamoDB. (Figura 1)
d. Nella sezione VPC: seleziona il tuo VPC predefinito.
e. Nella sezione Subnets (Sottoreti): seleziona tutte le sottoreti.
f. Nella sezione Security groups (Gruppi di sicurezza): seleziona il tuo gruppo di sicurezza predefinito. (Figura 2)
g. Fai clic su Add (Aggiungi). Se ricevi un messaggio di errore che indica che una delle tue sottoreti non supporta i servizi App Runner, rimuovila dall'elenco delle sottoreti e fai nuovamente clic su Add (Aggiungi). (Figura 2)
h. Fai clic su Next (Avanti) e poi su Create & deploy (Crea e distribuisci).
5. Attendi la distribuzione
Attendi il completamento della distribuzione, che richiederà alcuni minuti. Questo è il momento giusto per fare una pausa.
6. URL del servizio di registrazione
Una volta completata la distribuzione del servizio, verrà visualizzato il messaggio Create service succeeded (Creazione del servizio riuscita).
Registra l'URL del dominio predefinito. Questo è l'URL del tuo servizio.
Aggiorna Event log (Log degli eventi) e dovresti vedere la conferma che il servizio è in esecuzione.
7. Vai all'URL del servizio
Vai all'URL e dovresti vedere il tuo controllo dell'integrità. Il nostro servizio è ospitato in App Runner, ma non è ancora in grado di accedere a DynamoDB. Abbiamo creato il connettore VPC per App Runner, ma dobbiamo ancora creare un endpoint VPC corrispondente per DynamoDB.
Verifica il tuo lavoro
Ora dovresti:
✓ Avere un servizio AWS App Runner in esecuzione denominato HelloAppRunnerVpc.
✓ Avere l'URL dell'endpoint del servizio.
✓ Aver confermato che l'URL del controllo dell'integrità risponde in un browser.
Passaggio 9: creare un endpoint VPC per DynamoDB
In questo passaggio creerai un endpoint VPC per DynamoDB.
1. Nella console AWS, accedi a VPC
2. Crea endpoint
Seleziona Endpoint dal pannello a sinistra e fai clic su Create endpoint (Crea endpoint).
a. Nome: vpc-endpoint-dynamodb. (Figura 1)
b. b. Nella sezione Service category (Categoria di servizio) seleziona AWS services (Servizi AWS).
c. Nella sezione Services (Servizi): inserisci DynamoDB nella casella di ricerca e seleziona com.amazonaws.region.dynamodb.
d. Nella sezione VPC: seleziona il tuo VPC predefinito.
e. Tabelle di routing: seleziona la Tabella di routing principale.
f. Fai clic su Create endpoint (Crea endpoint). (Figura 2)
Verifica il tuo lavoro
Ora dovresti:
✓ Avere un endpoint VPC per DynamoDB denominato vpc-endpoint-dynamodb.
Passaggio 10: eseguire il test nel cloud
Ora siamo pronti a mettere tutto insieme e testare l'API Web nel cloud.
1. Visita l'URL del servizio
In un browser, visita l'URL del servizio che hai registrato nel passaggio 6. Viene visualizzata la risposta del controllo di integrità.
2. Verifica l'azione Previsioni meteo per Dallas
Aggiungi /WeatherForecast?location=Dallas alla fine del percorso. Ora puoi vedere i record di Dallas che hai inserito nel passaggio 1
3. Verifica l'azione Previsioni meteo per Minneapolis
3. Modifica la fine del percorso in /WeatherForecast?location=Minneapolis e vedrai i record per quella posizione.
Congratulazioni! La tua API Web è ospitata in AWS App Runner e il servizio comunica con DynamoDB.
Verifica il tuo lavoro
Ora dovresti:
✓ Aver confermato che il servizio AWS App Runner è in grado di recuperare dati dalla tabella DynamoDB.
Passaggio 11: distribuire un aggiornamento
In questo passaggio aggiornerai la tua API Web, eseguirai il push di un container aggiornato e vedrai come App Runner lo distribuisce automaticamente al servizio. La distribuzione avviene automaticamente perché abbiamo configurato le Distribuzioni automatiche nel passaggio 8, quando abbiamo creato il servizio.
1. Modifica il servizio
2. Crea e testa in locale
Crea e testa il progetto in locale per assicurarti che funzioni come previsto.
3. Ridistribuisci il container
4. Monitora la ridistribuzione del servizio
Nella console AWS App Runner, verifica il tuo servizio. Poco dopo la distribuzione del nuovo container, App Runner distribuirà automaticamente l'aggiornamento.
5. Testa il servizio aggiornato
Attendi il completamento dell'aggiornamento, quindi testa il servizio accedendovi come hai fatto nel passaggio 10. Conferma che ora vedi la nuova versione dell'output del servizio.
Verifica il tuo lavoro
Ora dovresti:
✓ Aver aggiornato il tuo progetto API Web con una modifica.
✓ Aver distribuito un container aggiornato su ECR.
✓ Aver confermato che App Runner ha distribuito automaticamente l'aggiornamento.
Passaggio 12: chiusura
Ti invitiamo a sperimentare liberamente modifiche al tuo progetto per testare le tue conoscenze.
Quando hai finito con il progetto, chiudilo. Non conviene accumulare costi per qualcosa che non utilizzi più.
1. Elimina il servizio App Runner
Nella console AWS, accedi ad App Runner ed elimina il servizio HelloAppRunnerVpc
2. Elimina la tabella DynamoDB
Accedi a DynamoDB ed elimina la tabella Weather (Meteo)
3. Elimina l'immagine di container
Vai a ECR ed elimina l'immagine di container helloapprunnervpc.
4. Elimina l'ambiente Cloud9
Se utilizzi Cloud9, accedi a Cloud9 ed elimina l'ambiente AppRunnerLab.
Verifica il tuo lavoro
Ora dovresti:
✓ Aver eliminato il servizio App Runner.
✓ Aver eliminato la tabella DynamoDB.
✓ Aver eliminato l'immagine del container in ECR.
Riepilogo
In questo laboratorio hai creato una tabella DynamoDB e l'hai popolata con dati. Hai generato un progetto di applicazione Web .NET con il comando dotnet new. Hai codificato un'API Web che recupera i dati meteorologici dalla tabella DynamoDB. Hai distribuito un container su ECR. Hai creato un servizio App Runner per ospitare l'API Web. Hai creato un connettore VPC per App Runner e un endpoint VPC per DynamoDB in modo da connettere i due servizi. Hai testato l'applicazione, ora ospitata su AWS, e l'hai vista funzionare. Hai distribuito un container aggiornato su ECR e l'hai visto distribuito automaticamente nel servizio App Runner. Infine, hai deallocato la tua applicazione da AWS.