Waarom een microservices-benadering voor het bouwen van toepassingen?Why a microservices approach to building applications?

Software-ontwikkelaars is er niets nieuws in de manier waarop we denken over het kiezen van een toepassing in onderdelen.As software developers, there is nothing new in how we think about factoring an application into component parts. Een gelaagde benadering wordt meestal gebruikt met een back-end-store, bedrijfslogica middelste laag en een front-end-gebruikersinterface (UI).Typically, a tiered approach is taken with a back-end store, middle-tier business logic, and a front-end user interface (UI). Wat heeft gewijzigd in de afgelopen jaren is dat we ontwikkelaars, gedistribueerde toepassingen bouwen voor de cloud.What has changed over the last few years is that we, as developers, are building distributed applications for the cloud.

De wisselende bedrijfsbehoeften van uw zijn:The changing business needs are:

  • Een service die ingebouwd en werkt op grote schaal om klanten in nieuwe geografische regio's te bereiken.A service that's built and operates at scale to reach customers in new geographical regions.
  • Snellere levering van functies en mogelijkheden om te kunnen reageren op verzoeken van klanten op flexibele wijze inzetten.Faster delivery of features and capabilities to be able to respond to customer demands in an agile way.
  • Verbeterde Resourcegebruik om kosten te verlagen.Improved resource utilization to reduce costs.

Deze behoeften van uw bedrijf van invloed zijn op hoe we bij het bouwen van toepassingen.These business needs are affecting how we build applications.

Lees voor meer informatie over de aanpak van Azure om microservices Microservices: een toepassing revolution mogelijk gemaakt door de cloud.For more information about the approach of Azure to microservices, read Microservices: An application revolution powered by the cloud.

Monolithische versus microservice-benadering voor ontwerpMonolithic vs. microservice design approach

Toepassingen loop der tijd veranderen.Applications evolve over time. Succesvolle toepassingen veranderen door handig voor gebruikers.Successful applications evolve by being useful to people. Mislukte toepassingen niet doen ontwikkelen en uiteindelijk zijn afgeschaft.Unsuccessful applications do not evolve and eventually are deprecated. De vraag is: hoeveel wist u dat u over de vereisten voor vandaag en wat ze worden in de toekomst?The question is: How much do you know about your requirements today, and what will they be in the future? Stel dat het bouwen van een reporting-toepassing voor een afdeling.For example, let's say that you are building a reporting application for a department. U bent of de toepassing is alleen van toepassing binnen het bereik van uw bedrijf en of de rapporten tijdelijke zijn.You are sure that the application only applies within the scope of your company and that the reports are short-lived. Uw keuze van benadering wijkt af van, zeg, video-inhoud bouwen van een service die voorziet in tientallen miljoenen klanten.Your choice of approach is different from, say, building a service that delivers video content to tens of millions of customers.

Soms iets uit de deur krijgen als bewijs van concept is de drijvende factor, terwijl u weet dat de toepassing later kan worden ontworpen.Sometimes, getting something out the door as proof of concept is the driving factor, while you know that the application can be redesigned later. Er is weinig punt in iets te veel engineering die nooit wordt gebruikt.There is little point in over-engineering something that never gets used. Het is de gebruikelijke engineering verhouding.It’s the usual engineering trade-off. Wanneer bedrijven over het bouwen van voor de cloud praten, is de verwachting dat aan de andere kant groei en het gebruik.On the other hand, when companies talk about building for the cloud, the expectation is growth and usage. Het probleem is dat groei en de schaal onvoorspelbaar zijn.The issue is that growth and scale are unpredictable. Willen we snel prototypen kunnen worden terwijl u ook weten dat er zich op een pad bevinden naar het omgaan met succes in de toekomst.We would like to be able to prototype quickly while also knowing that we are on a path to deal with future success. Dit is de methode lean opstarten: bouwen, meten, leren en herhalen.This is the lean startup approach: build, measure, learn, and iterate.

Tijdens het tijdperk client / server-uitbreiden we richten op het gelaagde toepassingen bouwen met behulp van specifieke technologieën in elke laag.During the client-server era, we tended to focus on building tiered applications by using specific technologies in each tier. De term monolithische toepassing geworden voor deze methoden.The term monolithic application has emerged for these approaches. De interfaces uitbreiden moet tussen de lagen en ontwerp voor een meer nauw gekoppelde tussen onderdelen binnen elke laag is gebruikt.The interfaces tended to be between the tiers, and a more tightly coupled design was used between components within each tier. Ontwikkelaars die zijn ontworpen en gewogen klassen die zijn gecompileerd in bibliotheken en aan elkaar gekoppeld in een paar uitvoerbare bestanden en .dll-bestanden.Developers designed and factored classes that were compiled into libraries and linked together into a few executables and DLLs.

Er zijn voordelen van deze benadering van een monolithisch ontwerp.There are benefits to such a monolithic design approach. Het is vaak eenvoudiger te ontwerpen en er sneller aanroepen tussen onderdelen omdat deze aanroepen vaak over interprocess communication (IPC zijn).It's often simpler to design, and it has faster calls between components because these calls are often over interprocess communication (IPC). Bovendien iedereen één enkel product, doorgaans meer mensen-resource-efficiënt worden getest.Also, everyone tests a single product, which tends to be more people-resource efficient. Het nadeel is dat er een hechte koppeling tussen de lagen van gelaagde, en u afzonderlijke componenten niet schalen.The downside is that there's a tight coupling between tiered layers, and you cannot scale individual components. Als u nodig hebt om uit te voeren voor problemen of upgrades worden uitgevoerd, moet u wachten op anderen tests voltooid.If you need to perform fixes or upgrades, you have to wait for others to finish their testing. Het is moeilijker flexibel zijn.It is more difficult to be agile.

Microservices adres deze aantal nadelen en meer nauw zijn afgestemd op de voorgaande zakelijke vereisten, maar ze hebben ook zowel de voordelen en de verplichtingen.Microservices address these downsides and more closely align with the preceding business requirements, but they also have both benefits and liabilities. De voordelen van microservices zijn dat elke doorgaans ingekapseld eenvoudiger bedrijfsfunctionaliteit, die u kunt omhoog of omlaag schalen, testen, implementeren en afzonderlijk beheren.The benefits of microservices are that each one typically encapsulates simpler business functionality, which you can scale up or down, test, deploy, and manage independently. Een belangrijk voordeel van een microservice-benadering is dat teams meer bedrijfsscenario's dan worden aangedreven door technologie, waardoor de gelaagde benadering.One important benefit of a microservice approach is that teams are driven more by business scenarios than by technology--which the tiered approach encourages. In de praktijk kleinere teams ontwikkelen van een microservice op basis van een klant scenario en ze ervoor kiezen eventuele-technologieën gebruiken.In practice, smaller teams develop a microservice based on a customer scenario and use any technologies they choose.

Met andere woorden, hoeft de organisatie te standaardiseren tech om bij te houden van microservice-toepassingen.In other words, the organization doesn’t need to standardize tech to maintain microservice applications. Afzonderlijke teams die eigen services doen kunnen wat zinvol voor hen op basis van team kennis of wat is het meest geschikt is om het probleem te verhelpen.Individual teams that own services can do what makes sense for them based on team expertise or what’s most appropriate to solve the problem. In de praktijk moet een set van aanbevolen technologieën, zoals een bepaalde NoSQL opslaan of framework voor webtoepassingen, is het beter.In practice, a set of recommended technologies, such as a particular NoSQL store or web application framework, is preferable.

Het nadeel van microservices wordt geleverd bij het beheren van het grotere aantal afzonderlijke entiteiten en omgaan met complexere implementaties en versiebeheer.The downside of microservices comes in managing the increased number of separate entities and dealing with more complex deployments and versioning. Netwerkverkeer tussen de microservices wordt verhoogd en de bijbehorende netwerklatenties.Network traffic between the microservices increases as well as the corresponding network latencies. Veel van intensieve, gespecialiseerde services zijn een recept voor een nachtmerrie prestaties.Lots of chatty, granular services are a recipe for a performance nightmare. Zonder hulpprogramma's weergeven waarmee deze afhankelijkheden, het is moeilijk te 'Zie"het hele systeem.Without tools to help view these dependencies, it is hard to “see” the whole system.

Standaarden maken de microservice-benadering werk door als u akkoord gaat over het communiceren en gevoelig voor alleen de dingen die u een service moet wordt in plaats van Star contracten.Standards make the microservice approach work by agreeing on how to communicate and being tolerant of only the things you need from a service, rather than rigid contracts. Het is belangrijk dat deze opdrachten een definiëren in het ontwerp, omdat services onafhankelijk van elkaar werken.It is important to define these contracts up front in the design, because services update independently of each other. Een andere beschrijving lang geleden bedacht voor het ontwerpen met een microservices-benadering is "fijnmazig service oriented architecture (SOA)."Another description coined for designing with a microservices approach is “fine-grained service-oriented architecture (SOA).”

De eenvoudigste, wordt de microservices ontwerpen-aanpak is over een losgekoppelde federation Services met onafhankelijke wijzigingen aan elk en overeengekomen standaarden voor communicatie.At its simplest, the microservices design approach is about a decoupled federation of services, with independent changes to each, and agreed-upon standards for communication.

Omdat er meer cloud-apps zijn gemaakt, hebben mensen gedetecteerd dat deze ontleding van de algehele app in onafhankelijke, zeer sterk gericht op scenario services een beter op de lange termijn benadering is.As more cloud apps are produced, people have discovered that this decomposition of the overall app into independent, scenario-focused services is a better long-term approach.

Vergelijking van de ontwikkeling van toepassingen nadertComparison between application development approaches

Toepassingsontwikkeling voor service Fabric-platform

1) Een monolithische app domeinspecifieke functionaliteit bevat en normaal gesproken wordt gedeeld door functionele lagen, zoals web-, bedrijfs- en gegevens.A monolithic app contains domain-specific functionality and is normally divided by functional layers such as web, business, and data.

2) U een monolithische app schalen door deze te klonen op meerdere servers/virtuele machines/containers.You scale a monolithic app by cloning it on multiple servers/virtual machines/containers.

3) Een microservice-toepassingen gescheiden functionaliteit in afzonderlijke, kleinere services.A microservice application separates functionality into separate smaller services.

4) De microservices-benadering schalen uit door het implementeren van elke service onafhankelijk van elkaar, exemplaren van deze services te maken over servers/virtuele machines/containers.The microservices approach scales out by deploying each service independently, creating instances of these services across servers/virtual machines/containers.

Het ontwerpen van een microservice benadering is niet een wondermiddel voor alle projecten, maar deze beter aansluiten uitgelijnd met de zakelijke doelstellingen die eerder zijn beschreven.Designing with a microservice approach is not a panacea for all projects, but it does align more closely with the business objectives described earlier. Beginnen met een monolithische aanpak mogelijk acceptabel als u weet dat u de mogelijkheid hebt om de code later bijwerken naar een microservice-ontwerp.Starting with a monolithic approach might be acceptable if you know that you will have the opportunity to rework the code later into a microservices design. Meer over het algemeen u beginnen met een monolithische toepassing en langzaam splits deze in fasen, beginnen met het functionele aspecten die moeten worden schaalbare of meer flexibele.More commonly, you begin with a monolithic application and slowly break it up in stages, starting with the functional areas that need to be more scalable or agile.

De microservice-benadering betekent dat u uw toepassing van veel kleine services samenstellen.The microservice approach means that you compose your application of many small services. De services in containers die zijn geïmplementeerd in een computercluster worden uitgevoerd.The services run in containers that are deployed across a cluster of machines. Kleinere teams ontwikkelen van een service die is gericht op een scenario en onafhankelijk van elkaar, versie testen, implementeren en schalen van elke service, zodat de gehele toepassing kunt ontwikkelen.Smaller teams develop a service that focuses on a scenario and independently test, version, deploy, and scale each service so that the entire application can evolve.

Wat is een microservice?What is a microservice?

Er zijn verschillende definities van microservices.There are different definitions of microservices. Echter, de meeste van de volgende kenmerken van microservices zijn veel overeengekomen:However, most of the following characteristics of microservices are widely agreed upon:

  • Een klant of scenario bevatten.Encapsulate a customer or business scenario. Wat is het probleem dat u het oplossen van?What is the problem you are solving?
  • Ontwikkeld door een kleine IT-team.Developed by a small engineering team.
  • Geschreven in elke programmeertaal en elk gewenst framework gebruiken.Written in any programming language and use any framework.
  • Bestaan uit code en (optioneel) staat, die beide zijn onafhankelijke versies, geïmplementeerd en geschaald.Consist of code and (optionally) state, both of which are independently versioned, deployed, and scaled.
  • Communiceren met andere microservices via goed gedefinieerde interfaces en protocollen.Interact with other microservices over well-defined interfaces and protocols.
  • Een unieke naam (URL's) gebruikt voor het omzetten van hun locatie hebben.Have unique names (URLs) used to resolve their location.
  • Consistente en geval van problemen beschikbaar blijven.Remain consistent and available in the presence of failures.

Samenvatting:In summary:

Microservice-toepassingen worden samengesteld uit kleine, onafhankelijke versies en schaalbare klantgerichte services die met elkaar via standaardprotocollen met goed gedefinieerde interfaces communiceren.Microservice applications are composed of small, independently versioned, and scalable customer-focused services that communicate with each other over standard protocols with well-defined interfaces.

Geschreven in elke programmeertaal en elk gewenst framework gebruikenWritten in any programming language and use any framework

Ontwikkelaars willen we kiezen een andere taal of framework dat we, afhankelijk van onze vaardigheden of de behoeften van de service willen.As developers, we want to be free to choose a language or framework that we want, depending on our skills or the needs of the service. In sommige services, kunt u de prestatievoordelen van C++ boven alle andere waarde.In some services, you might value the performance benefits of C++ above all else. In andere services, kan het gemak van beheerde ontwikkeling in C# of Java belangrijkste zijn.In other services, the ease of managed development in C# or Java might be most important. In sommige gevallen moet u mogelijk gebruikmaken van een specifieke partner-bibliotheek, technologie voor gegevensopslag of betekent dat de service aan clients.In some cases, you may need to use a specific partner library, data storage technology, or means of exposing the service to clients.

Nadat u hebt ervoor gekozen een technologie, keert u naar de operationele of lifecycle management en schalen van de service.After you have chosen a technology, you come to the operational or lifecycle management and scaling of the service.

Kan code en de status onafhankelijke versies, geïmplementeerd en geschaaldAllows code and state to be independently versioned, deployed, and scaled

U wilt echter uw microservices, schrijft de code en (optioneel) de status moeten onafhankelijk van elkaar implementeren, bijwerken en schalen.However you choose to write your microservices, the code, and optionally the state, should independently deploy, upgrade, and scale. Dit is een van de problemen moeilijker op te lossen omdat het gaat naar beneden om uw eigen keuze aan technologieën.This is one of the harder problems to solve because it comes down to your choice of technologies. Voor vergroten/verkleinen, inzicht in hoe u partitie (of shard) de code en de status uitdagingen met zich mee.For scaling, understanding how to partition (or shard) both the code and state is challenging. Wanneer de code en de status van afzonderlijke technologieën, dit komt veel voor vandaag, moeten de implementatiescripts voor uw microservices worden ze allebei schalen.When the code and state use separate technologies, which is common today, the deployment scripts for your microservice need to be able to scale them both. Dit is ook over de wendbaarheid en flexibiliteit, zodat u enkele van de microservices bijwerken kunt zonder dat ze allemaal in één keer te upgraden.This is also about agility and flexibility, so you can upgrade some of the microservices without having to upgrade all of them at once.

Terugkeren naar de monolithische ten opzichte van microservice-benadering voor even de tijd, toont het volgende diagram de verschillen in de aanpak voor het opslaan van status.Returning to the monolithic versus microservice approach for a moment, the following diagram shows the differences in the approach to storing state.

Status opslag tussen toepassing stijlenState storage between application styles

Service Fabric-platform status opslag

De monolithische aanpak aan de linkerkant heeft een individuele database en lagen van specifieke technologieën.The monolithic approach on the left has a single database and tiers of specific technologies.

De microservices-benadering aan de rechterkant heeft een grafiek met elkaar verbonden microservices waarin staat doorgaans is afgestemd op de microservices en verschillende technologieën worden gebruikt.The microservices approach on the right has a graph of interconnected microservices where state is typically scoped to the microservice and various technologies are used.

De toepassing in een monolithische aanpak gebruikt doorgaans een individuele database.In a monolithic approach, the application typically uses a single database. Het voordeel is dat het een enkele locatie, waardoor het eenvoudig te implementeren.The advantage is that it is a single location, which makes it easy to deploy. Elk onderdeel kan één tabel voor het opslaan van de status hebben.Each component can have a single table to store its state. Teams moeten strikt scheiden staat, die een hele uitdaging.Teams need to strictly separate state, which is a challenge. Er zijn onvermijdelijk temptations een nieuwe kolom toevoegen aan een bestaande klantentabel, een koppeling tussen tabellen en afhankelijkheden maken in de storage-laag.Inevitably there are temptations to add a new column to an existing customer table, do a join between tables, and create dependencies at the storage layer. Als dit gebeurt, kunt u afzonderlijke onderdelen kan niet schalen.After this happens, you can't scale individual components.

In de microservices-benadering, elke service beheert en slaat de eigen staat.In the microservices approach, each service manages and stores its own state. Elke service is verantwoordelijk voor het schalen van zowel de code en de status samen om te voldoen aan de eisen van de service.Each service is responsible for scaling both code and state together to meet the demands of the service. Een nadeel is dat wanneer een hoeft te maken van weergaven of query's van gegevens van uw toepassing, moet u query's uitvoeren voor meerdere archieven van de status.A downside is that when there is a need to create views, or queries, of your application’s data, you need to query across multiple state stores. Dit is meestal opgelost door een afzonderlijke microservice dat een weergave in een verzameling van microservices.Typically, this is solved by having a separate microservice that builds a view across a collection of microservices. Als u meerdere ad hoc-query's uitvoeren voor de gegevens wilt, elke microservice moet rekening houden met de gegevens schrijven naar een service voor gegevensopslag voor offline analyse.If you need to perform multiple impromptu queries on the data, each microservice should consider writing its data to a data warehousing service for offline analytics.

Microservices zijn samengesteld en is het mogelijk dat verschillende versies van een microservice side-by-side mogelijk uitgevoerd.Microservices are versioned and it is possible that different versions of a microservice may be running side-by-side. Een nieuwere versie van een microservice kan mislukken tijdens de upgrade en moet worden teruggezet naar een eerdere versie.A newer version of a microservice may fail during upgrade and need to be rolled back to an earlier version. Versiebeheer is ook nuttig voor het testen van A/B-stijl, waarbij verschillende gebruikers verschillende versies van de service ondervindt.Versioning is also helpful for A/B-style testing, where different users experience different versions of the service. Het is bijvoorbeeld gebruikelijk om te upgraden van een microservice voor een bepaalde set klanten naar de nieuwe functionaliteit testen voordat u veel meer rolling.For example, it is common to upgrade a microservice for a specific set of customers to test new functionality before rolling it out more widely.

Communiceert met andere microservices via goed gedefinieerde interfaces en protocollenInteracts with other microservices over well-defined interfaces and protocols

Uitgebreide documentatie over service oriented architecture is gepubliceerd in de afgelopen 10 jaar met een beschrijving van communicatiepatronen.Extensive literature about service-oriented architecture has been published over the past 10 years describing communication patterns. Over het algemeen servicecommunicatie een REST-benadering met HTTP- en TCP-protocollen en XML of JSON gebruikt als de serialisatie-indeling.Generally, service communication uses a REST approach with HTTP and TCP protocols, and XML or JSON as the serialization format. Vanuit het perspectief van een interface draait de aanpak voor het ontwerp van web overstappen.From an interface perspective, it is about embracing the web design approach. Maar niets stopt u binaire protocollen of de opmaak van uw eigen gegevens te gebruiken.But nothing stops you from using binary protocols or your own data formats. Worden voorbereid voor personen een moeilijker tijdstip met behulp van uw microservices als deze protocollen en indelingen niet openlijk beschikbaar zijn.Be prepared for people to have a harder time using your microservices if these protocols and formats are not openly available.

Heeft een unieke naam (URL) gebruikt voor het omzetten van de locatieHas a unique name (URL) used to resolve its location

Uw microservice moet worden gebruikt wanneer deze wordt uitgevoerd.Your microservice needs to be addressable wherever it is running. Als u denkt u over virtuele machines en welke een bepaalde microservice wordt uitgevoerd, gaat ongeldige snel.If you are thinking about machines and which one is running a particular microservice, things go bad quickly.

Uw microservice moet een unieke naam op dezelfde manier dat er een bepaalde URL op DNS wordt omgezet naar een bepaalde machine, zodat de huidige locatie kan worden gedetecteerd.In the same way that DNS resolves a particular URL to a particular machine, your microservice needs a unique name so that its current location is discoverable. Microservices moet adresseerbare namen die onafhankelijk zijn van de infrastructuur waarop ze worden uitgevoerd.Microservices need addressable names that are independent of the infrastructure they are running on. Dit betekent dat er een interactie tussen hoe de service is geïmplementeerd en hoe deze wordt gedetecteerd, is omdat er moet een service-register.This implies that there is an interaction between how your service is deployed and how it is discovered, because there needs to be a service registry. Wanneer een virtuele machine is mislukt, de registry-service moet laat u weten waar de service is verplaatst naar.When a machine fails, the registry service must tell you where the service was moved to.

Consistente en geval van problemen beschikbaar blijftRemains consistent and available in the presence of failures

Omgaan met onverwachte fouten is een van de moeilijkst problemen op te lossen, met name in een gedistribueerd systeem.Dealing with unexpected failures is one of the hardest problems to solve, especially in a distributed system. Veel van de code die we als ontwikkelaars schrijven afhandeling van uitzonderingen en dit is ook waar de meeste tijd is besteed aan het testen.Much of the code that we write as developers is handling exceptions, and this is also where the most time is spent in testing. Het probleem is meer betrokken dan het schrijven van code voor het afhandelen van fouten.The problem is more involved than writing code to handle failures. Wat gebeurt er wanneer de computer waarop de microservice is uitgevoerd mislukt?What happens when the machine where the microservice is running fails? Niet alleen hebt u nodig voor het detecteren van de fout (een vaste probleem op een eigen), maar u moet ook opnieuw opstarten van uw microservice.Not only do you need to detect the failure (a hard problem on its own), but you also need to restart your microservice.

Omwille van de beschikbaarheid van moet een microservice tegen uitvallen en opnieuw te starten op een andere computer.For availability reasons, a microservice needs to be resilient to failures and able to restart on another machine. Naast de programmacode wordt flexibel, al dan niet mogen worden er verlies van gegevens en de gegevens nodig om consistent te blijven.In addition to the running code being resilient, there shouldn't be any data loss and the data needs to remain consistent.

Flexibiliteit is moeilijk te bereiken als er fouten optreden tijdens de upgrade van een toepassing.Resiliency is hard to achieve when failures happen during an application upgrade. De microservice, werken met het implementatiesysteem hoeft niet te herstellen.The microservice, working with the deployment system, doesn't need to recover. Nodig om te bepalen of u kunt doorgaan te gaan naar de nieuwste versie in plaats daarvan terugdraaien naar een eerdere versie om te kunnen handhaven een consistente status.It needs to decide whether it can continue to move forward to the newer version or instead roll back to a previous version in order to maintain a consistent state. Vragen zoals of voldoende machines zijn beschikbaar zijn voor houden naar voren verplaatsen en het herstellen van eerdere versies van de microservice moeten worden overwogen.Questions such as whether enough machines are available to keep moving forward and how to recover previous versions of the microservice need to be considered. Hiervoor moet de microservice om te verzenden van gegevens over de servicestatus om deze beslissingen te maken.This requires the microservice to emit health information to make these decisions.

Rapporten status en diagnoseReports health and diagnostics

Er lijken misschien overduidelijk, en het is vaak over het hoofd gezien, maar een microservice moet de status en diagnostische gegevens worden gerapporteerd.It may seem obvious, and it is often overlooked, but a microservice must report its health and diagnostics. Anders wordt er weinig inzicht in de status van een operations-perspectief.Otherwise, there is little insight into its health from an operations perspective. Correleren van diagnostische gebeurtenissen in een set onafhankelijke services en omgaan met machine tijdsverschillen te zinvol in de volgorde van de gebeurtenissen, is het lastig om.Correlating diagnostic events across a set of independent services, and dealing with machine clock skews to make sense of the event order, is challenging. Op dezelfde manier dat u met een microservice via overeengekomen protocollen en opmaak van gegevens communiceren, moet u standaardiseren hoe u zich aanmeldt status en diagnostische gebeurtenissen die uiteindelijk wordt terechtkomen in een gebeurtenissenarchief voor het uitvoeren van query's en weergeven.In the same way that you interact with a microservice over agreed-upon protocols and data formats, you need to standardize how to log health and diagnostic events that will ultimately end up in an event store for querying and viewing. In een microservices-benadering is het belangrijkste die verschillende teams eens zijn over een één-indeling.In a microservices approach, it's key that different teams agree on a single logging format. Er moet een consistent benadering voor het bekijken van diagnostische gebeurtenissen in de toepassing als geheel.There needs to be a consistent approach to viewing diagnostic events in the application as a whole.

Status wijkt af van diagnostische gegevens.Health is different from diagnostics. De status is over de microservices rapportage van de huidige status juiste acties te ondernemen.Health is about the microservice reporting its current state to take appropriate actions. Een goed voorbeeld werkt samen met de upgrade en implementatie mechanismen om beschikbaarheid te houden.A good example is working with upgrade and deployment mechanisms to maintain availability. Hoewel een service kan momenteel niet in orde vanwege het vastlopen van een proces of opnieuw opstarten van de computer, de service mogelijk nog steeds operationeel zijn.Although a service may be currently unhealthy due to a process crash or machine reboot, the service might still be operational. Het laatste wat dat u nodig is om te slechter maken door een upgrade uit te voeren.The last thing you need is to make this worse by performing an upgrade. De aanbevolen aanpak is het eerst een onderzoek doen of wacht totdat de microservice om te herstellen.The best approach is to do an investigation first or allow time for the microservice to recover. Statusgebeurtenissen van een microservice help ons gefundeerde beslissingen te nemen en van kracht te maken van de zelf-herstellende services.Health events from a microservice help us make informed decisions and, in effect, help create self-healing services.

Service Fabric als een microservices-platformService Fabric as a microservices platform

Azure Service Fabric naar voren gekomen als Microsoft is overgegaan van dergelijke producten die doorgaans monolithische in stijl zijn, leveren aan het leveren van services.Azure Service Fabric emerged when Microsoft transitioned from delivering boxed products, which were typically monolithic in style, to delivering services. De ervaring van het bouwen en gebruiken van grote services, zoals Azure SQL Database en Azure Cosmos DB, vorm van Service Fabric.The experience of building and operating large services, such as Azure SQL Database and Azure Cosmos DB, shaped Service Fabric. Het platform zich na verloop van tijd ontwikkeld als meer services genomen.The platform evolved over time as more and more services adopted it. Service Fabric had om uit te voeren in Azure maar in standalone Windows Server-implementaties.Service Fabric had to run not only in Azure but also in standalone Windows Server deployments.

Het doel van Service Fabric is op te lossen de moeilijke problemen van het bouwen en uitvoeren van een service en gebruikmaken van beschikken over infrastructurele resources efficiënt, zodat teams met behulp van een microservices-benadering bedrijfsproblemen kunnen oplossen.The aim of Service Fabric is to solve the hard problems of building and running a service and utilize infrastructure resources efficiently, so that teams can solve business problems using a microservices approach.

Service Fabric kunt u toepassingen die gebruikmaken van een microservices-benadering door te geven:Service Fabric helps you build applications that use a microservices approach by providing:

  • Een platform waarmee systeemservices te implementeren, upgraden, detecteren, en start de mislukte services, services detecteren, routeren van berichten, status beheren en status controleren.A platform that provides system services to deploy, upgrade, detect, and restart failed services, discover services, route messages, manage state, and monitor health.
  • De mogelijkheid om toepassingen te implementeren een van beide wordt uitgevoerd in containers of processen.Ability to deploy applications either running in containers or as processes. Service Fabric is een container en het proces orchestrator.Service Fabric is a container and process orchestrator.
  • Productieve programming API's, voor informatie over het bouwen van toepassingen, zoals microservices: ASP.NET Core en Reliable Actors, Reliable Services.Productive programming APIs, to help you build applications as microservices: ASP.NET Core, Reliable Actors, and Reliable Services. Bijvoorbeeld, krijgt u gegevens over status en diagnostische gegevens, of kunt u profiteren van de ingebouwde hoge beschikbaarheid.For example, you can get health and diagnostics information, or you can take advantage of built-in high availability.

Service Fabric is agnostisch op hoe u uw service ontwikkelen en kunt u elke technologie. Het biedt echter ingebouwde programmeertaal API's die het eenvoudiger om te bouwen van microservices.Service Fabric is agnostic on how you build your service, and you can use any technology. However, it does provide built-in programming APIs that make it easier to build microservices.

Migreren van bestaande toepassingen naar Service FabricMigrating existing applications to Service Fabric

Service Fabric kunt u bestaande code, die vervolgens kan worden gemoderniseerd met nieuwe microservices.Service Fabric allows you to reuse existing code, which can then be modernized with new microservices. Er zijn vijf fasen modernisering van toepassingen, en u kunt starten en stoppen op een van de fasen.There are five stages to application modernization, and you can start and stop at any of the stages. Dit zijn:These are:

1) Beginnen met een traditionele monolithische toepassing.Start with a traditional monolithic application.
2) Lift en Shift - containers of uitvoerbare gastbestanden gebruiken voor het hosten van bestaande code in Service Fabric.Lift and Shift - Use containers or guest executables to host existing code in Service Fabric.
3) Modernisering - nieuwe microservices toegevoegd naast de bestaande beperkte code.Modernization - New microservices added alongside existing containerized code.
4) Innovatie - in microservices uitsluitend op basis van de monolithische opsplitsen.Innovate - Break the monolithic into microservices purely based on need.
5) Omgezet in microservices - de transformatie van bestaande monolithische toepassingen of het bouwen van nieuwe greenfield-toepassingen.Transformed into microservices - the transformation of existing monolithic applications or building new greenfield applications.

Migratie naar Microservices

Het is belangrijk om te benadrukken opnieuw kunt u starten en stoppen bij elk van deze fasen.It is important to emphasize again that you can start and stop at any of these stages. U bent niet verplicht tot de volgende fase.You are not compelled to progress to the next stage. Laten we nu kijken voorbeelden voor elk van deze fasen.Let's now look at examples for each of these stages.

Lift- and -ShiftLift and Shift
Groot aantal bedrijven zijn via lift- and verschuiven van bestaande monolithische toepassingen in containers om twee redenen:Large numbers of companies are lifting and shifting existing monolithic applications into containers for two reasons:

  • Kosten vermindering vanwege consolidatie en verwijderen van bestaande hardware of met toepassingen met hogere dichtheid.Cost reduction either due to consolidation and removal of existing hardware or running applications at higher density.
  • Consistente implementatie contract tussen ontwikkel- en bewerkingen.Consistent deployment contract between development and operations.

Kosten kortingen zijn opgebouwd uit overzichtelijke en binnen Microsoft, groot aantal bestaande toepassingen zijn die wordt opgenomen in een container gewoon om miljoenen dollars te besparen.Cost reductions are understandable, and within Microsoft, large numbers of existing applications are being containerized simply to save millions of dollars. Consistente implementatie is het moeilijker om te evalueren, maar als belangrijk.Consistent deployment is harder to evaluate, but equally as important. Dit betekent dat ontwikkelaars nog steeds kiezen van de technologie die bij u past worden kunnen, maar de bewerkingen accepteert alleen een één manier om te implementeren en beheren van deze toepassingen.It means that developers can still be free to choose the technology that suits them, however the operations will only accept a single way to deploy and manage these applications. Dit vermindert de bewerkingen van dat u hoeft te bekommeren om de complexiteit van veel verschillende technologieën of ontwikkelaars kunnen alleen bepaalde waarden kiezen forceren.It alleviates the operations from having to deal with the complexity of many different technologies or forcing developers to only choose certain ones. In wezen elke toepassing wordt opgenomen in een container in onafhankelijke implementatie-installatiekopieën.Essentially every application is containerized into self-contained deployment images.

Veel organisaties stoppen hier.Many organizations stop here. Ze al de voordelen van containers en Service Fabric biedt de volledige beheerervaring van implementatie, upgrades, versiebeheer, terugdraaiacties, health monitoring enzovoort.They already have the benefits of containers and Service Fabric provides the complete management experience from deployment, upgrades, versioning, rollbacks, health monitoring etc.

ModerniseringModernization
Het toevoegen van nieuwe services naast de bestaande App code in een container.The addition of new services alongside existing containerized code. Als u nieuwe code te schrijven, is het raadzaam te besluiten te nemen van kleine stappen in het pad van microservices.If you are going to write new code, it is best to decide to take small steps down the microservices path. Dit kan een nieuwe REST API-eindpunt of een nieuwe bedrijfsregels worden toegevoegd.This could be adding a new REST API endpoint, or new business logic. Op deze manier die u op de reis van nieuwe microservices bouwen en praktijk ontwikkelen en implementeren van deze starten.This way, you start on the journey of building new microservices and practice developing and deploying them.

InnoveerInnovate
Een microservices-benadering biedt plaats aan veranderende bedrijfsbehoeften.A microservices approach accomodates changing business needs. In dit stadium is de beslissing of u wilt beginnen met het splitsen van de monolithische app in de services of innoveren.At this stage the decision is whether you need to start splitting the monolithic app into services, or innovating. Hier een voorbeeld is wanneer een database die wordt gebruikt als een werkstroom-wachtrij een bottleneck in de verwerking wordt.An example here is when a database being used as a workflow queue becomes a processing bottleneck. Als het aantal werkstroom toeneemt aanvragen, moet het werk voor schaal worden gedistribueerd.As the number of workflow requests increases, the work needs to be distributed for scale. Dit scenario te splitsen in een microservice en Innoveer voor die bepaald onderdeel van de toepassing die niet wordt geschaald en moet die vaker worden bijgewerkt.For that particular piece of the application that is not scaling, or that needs to be updated more frequently, split this out into a microservice and innovate.

Omgezet in microservicesTransformed into microservices
Dit is waar uw toepassing is volledig bestaat uit (of uit) microservices.This is where your application is fully composed of (or decomposed into) microservices. Als u wilt bereiken hier, kunt u het traject microservices hebt gemaakt.To reach here, you have made the microservices journey. U kunt hier beginnen, maar om dit te doen zonder een microservices-platform om u te helpen is een aanzienlijke investering.You can start here, but to do this without a microservices platform to help you is a significant investment.

Microservices zijn geschikt voor mijn toepassing?Are microservices right for my application?

Misschien.Maybe. Wat we ervaren is veel van deze de voordelen van een microservice-achtige benadering mogelijk als er steeds meer teams in Microsoft begon te bouwen voor de cloud voor zakelijke redenen, gerealiseerd.What we experienced was that as more and more teams in Microsoft began to build for the cloud for business reasons, many of them realized the benefits of taking a microservice-like approach. Bing, bijvoorbeeld, heeft zijn ontwikkelen met behulp van microservices jaar.Bing, for example, has been developing using microservices for years. De microservices-benadering is voor andere teams, nieuwe.For other teams, the microservices approach was new. Teams gevonden die moeilijke problemen op te lossen buiten hun kerngebieden van kracht zijn.Teams found that there were hard problems to solve outside of their core areas of strength. Dit is de reden waarom de Service Fabric opgedaan steun die krijgt als de technologie van uw voorkeur voor het bouwen van services.This is why Service Fabric gained traction as the technology of choice for building services.

Het doel van Service Fabric is om te beperken van de complexiteit van het bouwen van microservice-toepassingen die u geen hebt zo veel dure redesigns doorlopen.The objective of Service Fabric is to reduce the complexities of building microservice applications so that you do not have to go through as many costly redesigns. Begin klein, schalen wanneer dat nodig is, geen meer services, toevoegen van nieuwe oplossingen en ontwikkelen met gebruik van de klant.Start small, scale when needed, deprecate services, add new ones, and evolve with customer usage. Ook weten dat er tal van andere problemen nog moet worden opgelost zijn om microservices meer toegankelijk voor de meeste ontwikkelaars.We also know that there are many other problems yet to be solved to make microservices more approachable for most developers. Containers en de actor-programmeermodel zijn voorbeelden van kleine stappen in deze richting, en we ervoor dat er meer innovaties ontstaan als u wilt dit eenvoudiger maken.Containers and the actor programming model are examples of small steps in that direction, and we are sure that more innovations will emerge to make this easier.

Volgende stappenNext steps