Esercizio - Effettuare il refactoring di un servizio all'interno di un'applicazione monolitica come microservizio

Completato

Dopo aver completato l'analisi dell'applicazione, Fabrikam è pronto per avviare il processo di refactoring per spostare i servizi dall'architettura monolitica in microservizi. Modificare l'applicazione per spostare il servizio di elaborazione pacchetti in un microservizio.

Eseguire il refactoring dell'applicazione

Prima di distribuire l'applicazione aggiornata, si esaminerà il modo in cui è stato aggiornato. L'app monolitica ha un servizio per elaborare i pacchetti PackageProcessor.cs. Dopo che le prestazioni dell'applicazione sono state analizzate, questo servizio è stato identificato come un ostacolo alle prestazioni. Man mano che i clienti aumentano la domanda di consegne tramite drone, questo servizio viene caricato pesantemente mentre gestisce la pianificazione e la logistica per le consegne tramite drone. Un team dedicato gestisce completamente questo servizio, quindi lo spostamento in un microservizio consente di ottenere prestazioni e offre una maggiore agilità di sviluppo.

Esaminiamo più in dettaglio le modifiche apportate.

Consegna tramite drone prima

La PackageProcessor classe gestisce la funzionalità di base dell'elaborazione del pacchetto nel file PackageProcessor.cs . In questo esempio esegue alcune operazioni che richiedono un utilizzo intensivo delle risorse. Uno scenario reale può includere il calcolo dei tempi di recapito e delle route di recapito e l'aggiornamento delle origini dati con queste informazioni.

public class PackageProcessor : IPackageProcessor
    {
        public Task<PackageGen> CreatePackageAsync(PackageInfo packageInfo)
        {
            //Uses common data store e.g. SQL Azure tables
            Utility.DoWork(100);
            return Task.FromResult(new PackageGen { Id = packageInfo.PackageId });
        }
    }

Man mano che le richieste per questo servizio aumentano, l'utilizzo delle risorse aumenta e viene limitato alle risorse fisiche allocate all'applicazione monolitica. Se questo servizio viene implementato nel Servizio app di Azure, possiamo scalarlo verso l'alto e verso l'esterno. Idealmente, si vuole che questa risorsa utilizzata intensamente sia scalabile in modo indipendente per ottimizzare le prestazioni e i costi. In questo scenario si usa Funzioni di Azure per eseguire questa operazione.

Consegna con drone dopo

Esaminiamo ora il codice dell'applicazione DroneDelivery-after prima di distribuirlo. Si noterà che la PackageProcessor classe è stata modificata in una PackageServiceCaller classe . Implementa ancora l'interfaccia IPackageProcessor, ma esegue invece una chiamata HTTP al microservizio.

public class PackageServiceCaller : IPackageProcessor
    {
        private readonly HttpClient httpClient;

        public static string FunctionCode { get; set; }

        public PackageServiceCaller(HttpClient httpClient)
        {
            this.httpClient = httpClient;
        }

        public async Task<PackageGen> CreatePackageAsync(PackageInfo packageInfo)
        {
            var result = await httpClient.PutAsJsonAsync($"{packageInfo.PackageId}?code={FunctionCode}", packageInfo);
            result.EnsureSuccessStatusCode();

            return new PackageGen { Id = packageInfo.PackageId };
        }
    }

Il microservizio viene distribuito in una funzione di Azure. Il codice è disponibile in PackageServiceFunction.cs e contiene il codice seguente.

public static class PackageServiceFunction
    {
        [FunctionName("PackageServiceFunction")]
        public static Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "put", Route = "packages/{id}")] HttpRequest req,
            string id, ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            //Uses common data store e.g. SQL Azure tables
            Utility.DoWork(100);
            return Task.FromResult((IActionResult)new CreatedResult("http://example.com", null));
        }
    }

Quando si inserisce questo codice in Funzioni di Azure, questo servizio può essere ridimensionato in modo indipendente man mano che aumenta il carico utente. È possibile mantenere i servizi per il codice dell'applicazione rimanente ottimizzati per il resto dell'applicazione. Il servizio di consegna si espande man mano che aumentano le richieste di consegne tramite drone nel sistema.

Ora, ridistribuiamo l'applicazione. Per prima cosa, distribuiamo il nostro servizio rifattorizzato su Azure Functions. Quindi, distribuiamo l'applicazione refattorizzata su App Service e la colleghiamo alla funzione specifica.

Distribuire app per le funzioni

1. Esegui il comando seguente per configurare le variabili di ambiente in modo che facciano riferimento ai nostri servizi.

   APPSERVICENAME="$(az webapp list \
                       --resource-group "<rgn>[sandbox resource group]</rgn>" \
                       --query '[].name' \
                       --output tsv)"
   FUNCTIONAPPNAME="$(az functionapp list \
                       --resource-group "<rgn>[sandbox resource group]</rgn>" \
                       --query '[].name' \
                       --output tsv)"
   

2. Compilare e comprimere il codice dell'applicazione per l'app per le funzioni.

   cd ~/mslearn-microservices-architecture/src/after
   dotnet build ./PackageService/PackageService.csproj -c Release
   cd PackageService/bin/Release/netcoreapp2.2
   zip -r PackageService.zip .
   

3. Eseguire il comando seguente per eseguire il push del codice nell'app per le funzioni.

   az functionapp deployment source config-zip \
       --resource-group "<rgn>[sandbox resource group]</rgn>" \
       --name $FUNCTIONAPPNAME \
       --src PackageService.zip
   

Distribuire l'applicazione aggiornata di recapito tramite drone

Ora che il servizio è in esecuzione in Funzioni di Azure, è necessario associare l'applicazione di gestione dei droni all'app per le funzioni.

1. È prima necessario ottenere il codice di accesso per l'app per le funzioni in modo che sia possibile chiamarlo correttamente dall'applicazione. Eseguire i comandi seguenti per recuperare questo codice. Visualizzi il nome e il codice dell'app per funzioni da utilizzare nei passaggi successivi.

   RESOURCEGROUPID=$(az group show \
                       --resource-group "<rgn>[sandbox resource group]</rgn>" \
                       --query id \
                       --output tsv)
   FUNCTIONCODE=$(az rest \
                       --method post \
                       --query default \
                       --output tsv \
                       --uri "https://management.azure.com$RESOURCEGROUPID/providers/Microsoft.Web/sites/$FUNCTIONAPPNAME/functions/PackageServiceFunction/listKeys?api-version=2018-02-01")
   echo "FunctionName - $FUNCTIONAPPNAME"
   echo "FunctionCode - $FUNCTIONCODE"
   

2. In Azure Cloud Shell eseguire i comandi seguenti per aprire appsettings.json nell'editor di codice.

   cd ~/mslearn-microservices-architecture/src/after
   code ./DroneDelivery-after/appsettings.json
   

3. Nell'editor di codice sostituire i valori PackageServiceUri e PackageServiceFunctionCode. In PackageServiceUrisostituire <FunctionName> con il nome dell'app per le funzioni.

   In PackageServiceFunctionCodesostituire con <FunctionCode> il codice della funzione recuperato. Il file appsettings.json dovrebbe essere simile a questo esempio:

   {
       "Logging": {
       "LogLevel": {
           "Default": "Warning"
       }
       },
       "AllowedHosts": "*",
       "PackageServiceUri": "https://packageservicefunction-abc.azurewebsites.net/api/packages/",
       "PackageServiceFunctionCode": "SvrbiyhjXJUdTPXrkcUtY6bQaUf7OXQjWvnM0Gq63hFUhbH2vn6qYA=="
   }
   

4. Premere CTRL+S per salvare il file e quindi CTRL+Q per chiudere l'editor di codice.

5. Eseguire il comando seguente per distribuire l'applicazione aggiornata nel servizio app.

   zip -r DroneDelivery-after.zip . -x \*/obj/\* \*/bin/\*
   az webapp deploy \
       --resource-group "<rgn>[sandbox resource group]</rgn>" \
       --name $APPSERVICENAME \
       --src-path DroneDelivery-after.zip
   

6. Dopo aver ridistribuito il sito, aggiornare la pagina. Dovrebbe ora essere aggiornato.

   

Testare le prestazioni della nuova architettura

Ora che il servizio con vincoli di risorse viene spostato in un microservizio eseguito in Funzioni di Azure, vediamo come questa modifica influisce sulle prestazioni dell'applicazione.

1. Nella home page del sito Web selezionare Invia richieste. Questa azione invia richieste dall'app monolitica al microservizio che gira su una funzione di Azure.

2. Il primo tentativo potrebbe restituire risultati simili all'applicazione monolitica. Aggiornare la pagina e inviare nuovamente la richiesta, se richiesto. Eseguire questo passaggio più volte e verranno visualizzati 100 messaggi inviati in 1 secondo.

   

Il tentativo iniziale è stato più lento durante l'avvio dell'app per le funzioni. Dopo l'esecuzione, il tempo di risposta era migliore rispetto a quando questo codice era in esecuzione nell'architettura monolitica.

Questa parte dell'architettura può ora essere ridimensionata quasi infinitamente, mentre offre comunque le stesse prestazioni. Spostando il codice dell'applicazione in un microservizio, le prestazioni sono migliorate da 5 a 10 volte. Poiché Fabrikam ha un team di sviluppo dedicato per questo servizio, può anche eseguire l'iterazione su questo microservizio e sfruttare i vantaggi di una maggiore agilità e delle versioni delle funzionalità.