skip to content
Building Microservices with .NET Core. Preview this item
ClosePreview this item
Checking...

Building Microservices with .NET Core.

Author: Gaurav Kumar Aroraa; Lalit Kale; Kanwar Manish
Publisher: Birmingham : Packt Publishing, 2017.
Edition/Format:   eBook : Document : EnglishView all editions and formats
Summary:
Architect your .NET applications by breaking them into really small pieces--microservices--using this practical, example-based guideAbout This Book* Start your microservices journey and understand a broader perspective of microservices development* Build, deploy, and test microservices using ASP.Net MVC, Web API, and Microsoft Azure Cloud* Get started with reactive microservices and understand the fundamentals  Read more...
Rating:

(not yet rated) 0 with reviews - Be the first.

Subjects
More like this

 

Find a copy online

Find a copy in the library

&AllPage.SpinnerRetrieving; Finding libraries that hold this item...

Details

Genre/Form: Electronic books
Additional Physical Format: Print version:
Aroraa, Gaurav Kumar.
Building Microservices with .NET Core.
Birmingham : Packt Publishing, ©2017
Material Type: Document, Internet resource
Document Type: Internet Resource, Computer File
All Authors / Contributors: Gaurav Kumar Aroraa; Lalit Kale; Kanwar Manish
ISBN: 9781785884962 1785884964
OCLC Number: 990671282
Notes: Component (service) testing.
Description: 1 online resource (267 pages)
Contents: Cover ; Copyright ; Credits; Foreword; About the Authors; About the Reviewers; www.PacktPub.com; Customer Feedback; Table of Contents; Preface; Chapter 1: What Are Microservices? ; Origin of microservices; Discussing microservices; Monolithic architecture; Service-oriented architecture; What is service?; Understanding the microservice architecture; Messaging in microservices; Synchronous messaging; Asynchronous messaging; Message formats; Why should we use microservices?; How does the microservice architecture work?; Advantages of microservices; SOA versus microservices. Prerequisites of the microservice architectureUnderstanding problems with the monolithic architecture style; Challenges in standardizing a .NET stack; Fault tolerance; Scaling; Vertical scaling or scale up; Horizontal scaling or scale out; Deployment challenges; Organizational alignment; Modularity; Big database; Prerequisites for microservices; Functional overview of the application; Solutions for current challenges; Handling deployment problems; Making much better monolithic applications; Introducing dependency injections; Database refactoring; Database sharding and partitioning. DevOps cultureAutomation; Testing; Versioning; Deployment; Identifying decomposition candidates within monolithic; Important microservices advantages; Technology independence; Interdependency removal; Alignment with business goals; Cost benefits; Easy scalability; Security; Data management; Integrating monolithic; Summary; Chapter 2: Building Microservices ; Size of microservices; What makes a good service?; DDD and its importance for microservices; Domain model design; Importance for microservices; The concept of Seam; Module interdependency; Technology; Team structure; Database; Master data. TransactionCommunication between microservices; Benefits of the API gateway for microservices; API gateway versus API management; Revisiting the case study --
Flix One; Prerequisites; Transitioning to our product service; Migrations; Code migration; Creating our project; Adding the model; Adding a repository; Registering the repositories; Adding a product controller; The ProductService API; Adding EF core support; EF Core DbContext; EF Core migrations; Database migration; Revisiting repositories and the controller; Introducing ViewModel; Revisiting the product controller; Summary. Chapter 3: Integration Techniques Communication between services; Styles of collaborations; Integration patterns; The API gateway; The event-driven pattern; Event sourcing; Eventual consistency; Compensating Transaction; Competing Consumers; Azure Service Bus queues; Implementation of an Azure Service Bus queue; Prerequisites; Sending messages to the queue; Receiving messages from the queue; Summary; Chapter 4: Testing Strategies ; How to test microservices; Handling challenges; Testing strategies (testing approach); Testing pyramid; Types of microservice tests; Unit testing.

Abstract:

Architect your .NET applications by breaking them into really small pieces--microservices--using this practical, example-based guideAbout This Book* Start your microservices journey and understand a broader perspective of microservices development* Build, deploy, and test microservices using ASP.Net MVC, Web API, and Microsoft Azure Cloud* Get started with reactive microservices and understand the fundamentals behind itWho This Book Is ForThis book is for .NET Core developers who want to learn and understand microservices architecture and implement it in their .NET Core applications. It's ideal for developers who are completely new to microservices or have just a theoretical understanding of this architectural approach and want to gain a practical perspective in order to better manage application complexity.What You Will Learn* Compare microservices with monolithic applications and SOA* Identify the appropriate service boundaries by mapping them to the relevant bounded contexts* Define the service interface and implement the APIs using ASP.NET Web API* Integrate the services via synchronous and asynchronous mechanisms* Implement microservices security using Azure Active Directory, OpenID Connect, and OAuth 2.0* Understand the operations and scaling of microservices in .NET Core* Understand the testing pyramid and implement consumer-driven contract using pact net core* Understand what the key features of reactive microservices are and implement them using reactive extensionIn DetailMicroservices is an architectural style that promotes the development of complex applications as a suite of small services based on business capabilities. This book will help you identify the appropriate service boundaries within the business. We'll start by looking at what microservices are, and what the main characteristics are.Moving forward, you will be introduced to real-life application scenarios, and after assessing the current issues, we will begin the journey of transforming this application by splitting it into a suite of microservices.You will identify the service boundaries, split the application into multiple microservices, and define the service contracts. You will find out how to configure, deploy, and monitor microservices, and configure scaling to allow the application to quickly adapt to increased demand in the future.With an introduction to the reactive microservices, you strategically gain further value to keep your code base simple, focusing on what is more important rather than the messy asynchronous calls.Style and approachThis guide serves as a stepping stone that helps .NET Core developers in their microservices architecture. This book provides just enough theory to understand the concepts and apply the examples.

Reviews

User-contributed reviews
Retrieving GoodReads reviews...
Retrieving DOGObooks reviews...

Tags

Be the first.
Confirm this request

You may have already requested this item. Please select Ok if you would like to proceed with this request anyway.

Linked Data


Primary Entity

<http://www.worldcat.org/oclc/990671282> # Building Microservices with .NET Core.
    a schema:MediaObject, schema:CreativeWork, schema:Book ;
    library:oclcnum "990671282" ;
    library:placeOfPublication <http://id.loc.gov/vocabulary/countries/enk> ;
    library:placeOfPublication <http://experiment.worldcat.org/entity/work/data/4390348939#Place/birmingham> ; # Birmingham
    schema:about <http://experiment.worldcat.org/entity/work/data/4390348939#Topic/service_oriented_architecture_computer_science> ; # Service-oriented architecture (Computer science)
    schema:about <http://experiment.worldcat.org/entity/work/data/4390348939#Topic/cloud_computing> ; # Cloud computing
    schema:about <http://dewey.info/class/005.3/e23/> ;
    schema:bookFormat schema:EBook ;
    schema:contributor <http://experiment.worldcat.org/entity/work/data/4390348939#Person/kale_lalit> ; # Lalit Kale
    schema:contributor <http://experiment.worldcat.org/entity/work/data/4390348939#Person/manish_kanwar> ; # Kanwar Manish
    schema:creator <http://experiment.worldcat.org/entity/work/data/4390348939#Person/aroraa_gaurav_kumar> ; # Gaurav Kumar Aroraa
    schema:datePublished "2017" ;
    schema:description "Architect your .NET applications by breaking them into really small pieces--microservices--using this practical, example-based guideAbout This Book* Start your microservices journey and understand a broader perspective of microservices development* Build, deploy, and test microservices using ASP.Net MVC, Web API, and Microsoft Azure Cloud* Get started with reactive microservices and understand the fundamentals behind itWho This Book Is ForThis book is for .NET Core developers who want to learn and understand microservices architecture and implement it in their .NET Core applications. It's ideal for developers who are completely new to microservices or have just a theoretical understanding of this architectural approach and want to gain a practical perspective in order to better manage application complexity.What You Will Learn* Compare microservices with monolithic applications and SOA* Identify the appropriate service boundaries by mapping them to the relevant bounded contexts* Define the service interface and implement the APIs using ASP.NET Web API* Integrate the services via synchronous and asynchronous mechanisms* Implement microservices security using Azure Active Directory, OpenID Connect, and OAuth 2.0* Understand the operations and scaling of microservices in .NET Core* Understand the testing pyramid and implement consumer-driven contract using pact net core* Understand what the key features of reactive microservices are and implement them using reactive extensionIn DetailMicroservices is an architectural style that promotes the development of complex applications as a suite of small services based on business capabilities. This book will help you identify the appropriate service boundaries within the business. We'll start by looking at what microservices are, and what the main characteristics are.Moving forward, you will be introduced to real-life application scenarios, and after assessing the current issues, we will begin the journey of transforming this application by splitting it into a suite of microservices.You will identify the service boundaries, split the application into multiple microservices, and define the service contracts. You will find out how to configure, deploy, and monitor microservices, and configure scaling to allow the application to quickly adapt to increased demand in the future.With an introduction to the reactive microservices, you strategically gain further value to keep your code base simple, focusing on what is more important rather than the messy asynchronous calls.Style and approachThis guide serves as a stepping stone that helps .NET Core developers in their microservices architecture. This book provides just enough theory to understand the concepts and apply the examples."@en ;
    schema:description "Cover ; Copyright ; Credits; Foreword; About the Authors; About the Reviewers; www.PacktPub.com; Customer Feedback; Table of Contents; Preface; Chapter 1: What Are Microservices? ; Origin of microservices; Discussing microservices; Monolithic architecture; Service-oriented architecture; What is service?; Understanding the microservice architecture; Messaging in microservices; Synchronous messaging; Asynchronous messaging; Message formats; Why should we use microservices?; How does the microservice architecture work?; Advantages of microservices; SOA versus microservices."@en ;
    schema:exampleOfWork <http://worldcat.org/entity/work/id/4390348939> ;
    schema:genre "Electronic books"@en ;
    schema:inLanguage "en" ;
    schema:isSimilarTo <http://worldcat.org/entity/work/data/4390348939#CreativeWork/building_microservices_with_net_core> ;
    schema:name "Building Microservices with .NET Core."@en ;
    schema:productID "990671282" ;
    schema:publication <http://www.worldcat.org/title/-/oclc/990671282#PublicationEvent/birmingham_packt_publishing_2017> ;
    schema:publisher <http://experiment.worldcat.org/entity/work/data/4390348939#Agent/packt_publishing> ; # Packt Publishing
    schema:url <https://proquest.safaribooksonline.com/9781785887833> ;
    schema:url <http://public.ebookcentral.proquest.com/choice/publicfullrecord.aspx?p=4877937> ;
    schema:url <http://www.myilibrary.com?id=1015301> ;
    schema:url <http://public.eblib.com/choice/publicfullrecord.aspx?p=4877937> ;
    schema:workExample <http://worldcat.org/isbn/9781785884962> ;
    wdrs:describedby <http://www.worldcat.org/title/-/oclc/990671282> ;
    .


Related Entities

<http://experiment.worldcat.org/entity/work/data/4390348939#Agent/packt_publishing> # Packt Publishing
    a bgn:Agent ;
    schema:name "Packt Publishing" ;
    .

<http://experiment.worldcat.org/entity/work/data/4390348939#Person/aroraa_gaurav_kumar> # Gaurav Kumar Aroraa
    a schema:Person ;
    schema:familyName "Aroraa" ;
    schema:givenName "Gaurav Kumar" ;
    schema:name "Gaurav Kumar Aroraa" ;
    .

<http://experiment.worldcat.org/entity/work/data/4390348939#Person/kale_lalit> # Lalit Kale
    a schema:Person ;
    schema:familyName "Kale" ;
    schema:givenName "Lalit" ;
    schema:name "Lalit Kale" ;
    .

<http://experiment.worldcat.org/entity/work/data/4390348939#Person/manish_kanwar> # Kanwar Manish
    a schema:Person ;
    schema:familyName "Manish" ;
    schema:givenName "Kanwar" ;
    schema:name "Kanwar Manish" ;
    .

<http://experiment.worldcat.org/entity/work/data/4390348939#Topic/service_oriented_architecture_computer_science> # Service-oriented architecture (Computer science)
    a schema:Intangible ;
    schema:name "Service-oriented architecture (Computer science)"@en ;
    .

<http://worldcat.org/entity/work/data/4390348939#CreativeWork/building_microservices_with_net_core>
    a schema:CreativeWork ;
    rdfs:label "Building Microservices with .NET Core." ;
    schema:description "Print version:" ;
    schema:isSimilarTo <http://www.worldcat.org/oclc/990671282> ; # Building Microservices with .NET Core.
    .

<http://worldcat.org/isbn/9781785884962>
    a schema:ProductModel ;
    schema:isbn "1785884964" ;
    schema:isbn "9781785884962" ;
    .


Content-negotiable representations

Close Window

Please sign in to WorldCat 

Don't have an account? You can easily create a free account.