Oefening: een service in de monolithische omgeving herstructureren als een microservice
Nu Fabrikam klaar is met het analyseren van hun toepassing, zijn ze klaar om het herstructureringsproces te starten om services uit hun monolithische architectuur te verplaatsen naar microservices. We gaan de toepassing wijzigen om de pakketverwerkingsservice naar een microservice te verplaatsen.
De toepassing herstructureren
Voordat we de bijgewerkte toepassing implementeren, bekijken we hoe deze is bijgewerkt. De monolithische app heeft een service voor het verwerken van pakketten, PackageProcessor.cs. Nadat de prestaties van de toepassing zijn geanalyseerd, is deze service geïdentificeerd als een prestatieknelpunt. Naarmate klanten de vraag naar leveringen per drone verhogen, wordt deze service zwaar belast terwijl deze de planning en logistiek voor leveringen per drone afhandelt. Een speciaal team beheert deze service volledig, dus het verplaatsen naar een microservice helpt bij de prestaties en biedt verbeterde ontwikkelingsflexibiliteit.
Laten we eens kijken naar de wijzigingen die zijn aangebracht.
Levering met drones vóór
De PackageProcessor klasse verwerkt de kernfunctionaliteit van de pakketverwerking in het PackageProcessor.cs-bestand. In dit voorbeeld wordt werk uitgevoerd dat resource-intensief is. Een praktijkscenario kan bestaan uit het berekenen van levertijden en leveringsroutes en het bijwerken van gegevensbronnen met deze informatie.
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 });
}
}
Naarmate aanvragen voor deze service toenemen, wordt het resourcegebruik verhoogd en beperkt tot de fysieke resources die zijn toegewezen aan de monolithische toepassing. Als deze service is geïmplementeerd in Azure App Service, kunnen we deze omhoog en uitschalen. Idealiter wilt u dat deze intensief gebruikte resource onafhankelijk kan worden geschaald om de prestaties en kosten te optimaliseren. In dit scenario gebruiken we Azure Functions om dat te doen.
Dronelevering na
Laten we eens kijken naar de DroneDelivery-na toepassingscode voordat we deze implementeren. U kunt zien dat de PackageProcessor-klasse is gewijzigd in een PackageServiceCaller-klasse. De IPackageProcessor-interface wordt nog steeds geïmplementeerd, maar in plaats daarvan wordt er een HTTP-aanroep naar de microservice uitgevoerd.
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 };
}
}
De microservice wordt geïmplementeerd in een Azure-functie. De code is te vinden in PackageServiceFunction.cs en bevat de volgende code.
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));
}
}
Wanneer u deze code op Azure Functions plaatst, kan deze service onafhankelijk worden geschaald naarmate de gebruikersbelasting toeneemt. U kunt de services voor de resterende toepassingscode geoptimaliseerd houden voor de rest van de toepassing. De pakketservice wordt uitgeschaald naarmate er meer aanvragen voor leveringen per drone binnenkomen in het systeem.
Nu gaan we de toepassing opnieuw implementeren. Eerst implementeren we onze geherstructureerde service in Azure Functions. Vervolgens implementeren we de geherstructureerde toepassing in App Service en wijzen we deze naar de functie.
De functie-app implementeren
Voer het volgende commando uit om omgevingsvariabelen in te stellen die naar onze services wijzen.
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)"Laten we de toepassingscode voor de functie-app maken en in een zip-bestand verpakken.
cd ~/mslearn-microservices-architecture/src/after dotnet build ./PackageService/PackageService.csproj -c Release cd PackageService/bin/Release/netcoreapp2.2 zip -r PackageService.zip .Voer de volgende opdracht uit om de code naar de functie-app te pushen.
az functionapp deployment source config-zip \ --resource-group "<rgn>[sandbox resource group]</rgn>" \ --name $FUNCTIONAPPNAME \ --src PackageService.zip
De bijgewerkte Drone Delivery-toepassing implementeren
Nu onze service wordt uitgevoerd in Azure Functions, moeten we onze dronetoepassing naar die functie-app laten verwijzen.
We moeten eerst de toegangscode voor de functie-app ophalen, zodat we deze vanuit de toepassing kunnen aanroepen. Voer de volgende opdrachten uit om deze code op te halen. U geeft de naam en code van de functie-app weer voor gebruik in de volgende stappen.
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"Voer in Azure Cloud Shell de volgende opdrachten uit om appsettings.json te openen in de code-editor.
cd ~/mslearn-microservices-architecture/src/after code ./DroneDelivery-after/appsettings.jsonVervang in de code-editor de waarden
PackageServiceUrienPackageServiceFunctionCode. Vervang inPackageServiceUri<FunctionName>door de naam van uw functie-app.Vervang in
PackageServiceFunctionCodede<FunctionCode>door de functiecode die u hebt opgehaald. Uw appsettings.json-bestand moet er ongeveer uitzien als in dit voorbeeld:{ "Logging": { "LogLevel": { "Default": "Warning" } }, "AllowedHosts": "*", "PackageServiceUri": "https://packageservicefunction-abc.azurewebsites.net/api/packages/", "PackageServiceFunctionCode": "SvrbiyhjXJUdTPXrkcUtY6bQaUf7OXQjWvnM0Gq63hFUhbH2vn6qYA==" }Druk op Ctrl+S- om het bestand op te slaan en Ctrl+Q- om de code-editor te sluiten.
Voer de volgende opdracht uit om de bijgewerkte toepassing in uw App Service te implementeren.
zip -r DroneDelivery-after.zip . -x \*/obj/\* \*/bin/\* az webapp deploy \ --resource-group "<rgn>[sandbox resource group]</rgn>" \ --name $APPSERVICENAME \ --src-path DroneDelivery-after.zipVernieuw de pagina wanneer de site opnieuw is geïmplementeerd. Deze moet nu worden bijgewerkt.
De prestaties van de nieuwe architectuur testen
Nu de resourcebeperkingsservice is verplaatst naar een microservice die wordt uitgevoerd in Azure Functions, gaan we kijken hoe deze wijziging van invloed is op de prestaties van de toepassing.
Selecteer op de startpagina van uw website Aanvragen verzenden. Met deze actie worden aanvragen van uw monolithische app verzonden naar de microservice die wordt uitgevoerd op een Azure-functie.
De eerste poging kan vergelijkbare resultaten opleveren voor de monolithische toepassing. Vernieuw de pagina en verzend de aanvraag opnieuw als hierom wordt gevraagd. Voer deze stap meerdere keren uit en u ziet 100 berichten die zijn verzonden in 1 seconde.
De eerste poging was langzamer toen de functieapp opstartte. Nadat het systeem operationeel was, was de reactietijd beter dan toen deze code draaide in de monolithische architectuur.
Dit deel van de architectuur kan nu bijna oneindig worden uitgeschaald, terwijl deze nog steeds dezelfde prestaties biedt. Door deze toepassingscode naar een microservice te verplaatsen, hebben we de prestaties 5 tot 10 keer verbeterd. Omdat Fabrikam een speciaal ontwikkelteam voor deze service heeft, kunnen ze deze microservice ook herhalen en de voordelen van verbeterde flexibiliteit en functiereleases realiseren.