Shop top categories that ship internationally
Buy used:
$16.61
$8.79 deliveryNovember 3 - 24.Details
Used: Very Good |Details
Condition: Used: Very Good
Comment: Former library book; May have limited writing in cover pages. Pages are unmarked. ~ ThriftBooks: Read More, Spend Less
Access codes and supplements are not guaranteed with used items.
In stock
Added to
Unable to add item to List. Please try again.

Sorry, there was a problem.

There was an error retrieving your Wish Lists. Please try again.

Sorry, there was a problem.

List unavailable.
Other sellers on Amazon
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer -no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Image Unavailable

Image not available for
Color:

Follow the authors

Something went wrong. Please try your request again later.

Building Microservices with ASP.NET Core: Develop, Test, and Deploy Cross-Platform Services in the Cloud 1st Edition

byKevin Hoffman(Author)
Sorry, there was a problem loading this page. Try again.

At a time when nearly every vertical, regardless of domain, seems to need software running in the cloud to make money, microservices provide the agility and drastically reduced time to market you require. This hands-on guide shows you how to create, test, compile, and deploy microservices, using the ASP.NET Core free and open-source framework. Along the way, you’ll pick up good, practical habits for building powerful and robust services.

Building microservices isn’t about learning a specific framework or programming language; it’s about building applications that thrive in elastically scaling environments that don't have host affinity, and that can start and stop at a moment’s notice. This practical book guides you through the process.

  • Learn test-driven and API-first development concepts
  • Communicate with other services by creating and consumingbacking services such as databases and queues
  • Build a microservice that depends on an external data source
  • Learn aboutevent sourcing, the event-centric approach to persistence
  • Use ASP.NET Core to build web applications designed to thrive in the cloud
  • Build a service that consumes, or is consumed by, other services
  • Create services and applications that accept external configuration
  • Explore ways to secure ASP.NET Core microservices and applications

  1. ISBN-10
    1491961732
  2. ISBN-13
    978-1491961735
  3. Edition
    1st
  4. Publisher
    O'Reilly Media
  5. Publication date
    October 17, 2017
  6. Language
    English
  7. Dimensions
    7 x 0.4 x 9.1 inches
  8. Print length
    229 pages

Frequently purchased items with fast delivery

Page1 of1Start over

From the brand

oreilly
  1. Infrastructure as Code: Designing and Delivering Dynamic Systems for the Cloud Age
    Cloud Native DevOps with Kubernetes: Building, Deploying, and Scaling Modern Applications in the ...
    Microservices: Up and Running: A Step-by-Step Guide to Building a Microservices Architecture
    Cloud Native Development with Google Cloud: Building Applications at Speed and Scale

    Explore Cloud & Microservices

    Visit the Store

  2. Kubernetes: Up and Running: Dive into the Future of Infrastructure
    Certified Kubernetes Administrator (CKA) Study Guide: In-Depth Guidance and Practice
    Production Kubernetes: Building Successful Application Platforms
    Kubernetes Patterns: Reusable Elements for Designing Cloud Native Applications

    Kubernetes

    Visit the Store

  3. Sharing the knowledge of experts

    O'Reilly's mission is to change the world by sharing the knowledge of innovators. For over 40 years, we've inspired companies and individuals to do new things (and do them better) by providing the skills and understanding that are necessary for success.

    Our customers are hungry to build the innovations that propel the world forward. And we help them do just that.


From the Publisher

Building Microservices with ASP.NET Cor

From the Preface

The handwriting is on the wall most people building software and services today are rushing to embrace microservices and their benefits in terms of scale, fault tolerance, and time to market.

This isn’t just because it’s a shiny new fad. The momentum behind microservices and the concepts driving them is far more important, and those looking for the pendulum to swing back away from the notion of smaller, independently deployed modules will be left behind.

Today, we need to be able to build resilient, elastically scalable applications, and we need to do it rapidly to satisfy the needs of our customers and to keep ahead of our competition.

What You’ll Build

Unlike other more reference-style books that are all about showing you each and every API, library, and syntax pattern available to you in a given language, this book is written and meant to be consumed as a guide to building services, with ASP.NET Core simply being the framework in which all the code samples are built.

This book will not teach you every single nuance of low-level C# code; there are far thicker books written by other people if that’s what you’re looking for. My goal is that by the end of the book, creating, testing, compiling, and deploying microservices in ASP Core will be muscle memory for you. You’ll develop good, practical habits that will help you rapidly build stable, secure, reliable services.

The mentality I’d like you to have is that after reading this book, you’ll have learned a lot about how to build services that are going to be deployed in elastically scalable, high-performance cloud environments. ASP Core in C# is just one of many languages and frameworks you can use to build services, but the language does not make the service you do. The care, discipline, and diligence you put into building your services is far more a predictor of their success in production than any one language or tool ever could be.

The paintbrushes and canvas do not make the painting, the painter does. You are a painter of services, and ASP.NET Core is just one brush among many.

In this book, you’ll start with the basic building blocks of any service, and then learn how to turn them into more powerful and robust services. You’ll connect to databases and other backing services, and use lightweight distributed caches, secure services, and web apps, all while keeping an eye on the ability to continuously deliver immutable release artifacts in the form of Docker images.

Why You’re Building Services

Different teams work on different release cadences with different requirements, motivations, and measures of success. Gone are the days of building monoliths that require a custom, handcrafted, artisanal server in order to run properly. Hopefully, gone as well are the days of gathering a hundred people in conference rooms and on dial-in lines to hope and pray for the successful release of a product at 12:01 on a Sunday morning.

Microservices, if done properly, can give us the agility and drastically reduced time to market that our companies need in order to survive and thrive in this new world where nearly every vertical, regardless of its domain, seems to need software running in the cloud to make money.

As you progress through the book you’ll see the rationalizations for each decision made. From the individual lines of code to the high-level architectural 'napkin drawings,' I’ll discuss the pros and cons of each choice.

What You’ll Need to Build Services

First and foremost, you’ll need the .NET Core command-line utilities and the appropriate software development kit (SDK) installed. In the first chapter I’ll walk you through what you’ll need to get that set up.

Next, you’re going to need Docker. Docker and the container technology that supports it are ubiquitous these days. Regardless of whether you’re deploying to Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP), or your own infrastructure, Docker provides the portable and immutable release artifacts that you crave (and I’ll get more into the details of why this is the case throughout the book).

The development and build pipeline for the services in this book is the creation of Docker images running on Linux infrastructure in the cloud. As such, the path of least friction for readers of this book is likely a Mac or a Linux machine. You’ll be able to work with Windows, but some things may be higher-friction or require extra workarounds. The new Linux subsystem for Windows 10 helps with this, but still isn’t ideal.

Docker on Windows and the Mac will use virtual machines to host a Linux kernel (required for Docker’s container tech), and as such you may find your machine struggling a bit if you don’t have enough RAM.

If you’re using Linux (I used Ubuntu to verify the code), then you don’t need any virtual machines as Docker can run directly on top of a Linux kernel.

Editorial Reviews

About the Author

Kevin has been programming since he was 10 years old when he was left alone with a rebuilt Commodore VIC-20 and a BASIC programming manual. Ever since then, he has been addicted to emerging technologies, languages, and platforms.

He has written code for just about every industry, including biometric security, waste management, guidance systems for consumer-grade drones, financial services, and a bunch more. He's written over a dozen books on computer programming and has presented at a number of user groups and conferences, including Apple's WWDC and ScalaDays.

These days Kevin is teaches customers how to migrate and modernize their enterprise applications to thrive in the cloud with the latest cloud native patterns, practices, and technology.

Product details

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Videos

Help others learn more about this product by uploading a video!
Upload your video

About the authors

Follow authors to get new release updates, plus improved recommendations.
  1. Kevin Hoffman
    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    I have always had an insatiable desire to build - when I was a kid I started building things with my hands and tools, but once I discovered that I could create whole worlds and fantastic adventures within those worlds, I was hooked on writing. Today I have been able to put my desire to build to work by writing software, which pays the bills enough to let me keep writing books and building rich worlds.

    I can occasionally be found off-roading on the trails of New England in a custom-built, armored Jeep that I call the "Zombie Killer".

  2. Kevin Hoffman
    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    Discover more of the author’s books, see similar authors, read book recommendations and more.

Customer reviews

3.8 out of 5 stars
29 global ratings

Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.

To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.

Learn more how customers reviews work on Amazon
Customer image
5.0 out of 5 stars

Images in this review

Top reviews from the United States

There was a problem filtering reviews. Please reload the page.

  • Reviewed in the United States on October 28, 2017
    Format: PaperbackVerified Purchase
    Very good advice when developing and deploying microservices.
  • Reviewed in the United States on February 19, 2019
    Format: PaperbackVerified Purchase
    This is one of the worst books. It's very brief, lazy and poorly put together. It only touches on the topics, and doesnt lay the concepts out at all. It briefly mentions stuff, and then points you to a url or git repo. Theres no good foundation of the microservice principles. I'm glad I already knew what CQRS/ES was, because the chapter would lose anybody with it's poor and brief information, and complicated and confusing code example. This is how every chapter is. It should have been a 500pg book, not 200.
    2 people found this helpful
    Report
  • Reviewed in the United States on February 20, 2018
    Format: Paperback
    very nice to read if Max or Linux is your dev environment. If you are focused on Windows, you're lost after chapter 1 as it does not explain how to use/install docker on the Linux subsystem for Windows.
    Does "The new Linux subsystem for Windows 10 ...still isn't ideal" (page ix) mean "don't use it, it's buggy" ?
    Also the fact that Visual Studio comes with a nice Docker integration is completely left out.
    4 people found this helpful
    Report
  • Reviewed in the United States on October 9, 2017
    Format: Paperback
    This book is really good for a number of reasons.
    1. great introduction to .NET Core - I've done a little with .NET Core but this is making more of it solidify.
    2. Very current - It's just been published in Sept 2017
    3. I've been wanting a book on MicroServices but something that walks me through building good code examples and this has that too.
    4. Learning microservices allows me to learn some new architectural concepts.
    5. The book is written really well too so it is a fast read.
    6. Microservices are implemented in Docker so I'll finally get to wrestle with that a bit too.

    Additionally, the introduction to .NET Core is very good because it gives you exactly what you need to try it out without overwhelming at the first parts of the book.
    Author does a great job of explaining microservices architecture in context of actual working code and best-practices like CI (continuous integration) etc.
    A fantastic read which provides a lot of value.
    10 people found this helpful
    Report
  • Reviewed in the United States on December 20, 2017
    Format: PaperbackVerified Purchase
    Not worth the money. It's one of those books that constantly points you to a URL in order to learn about different technologies. Defeats the purpose of buying a book in my opinion. Doesn't go in-depth about anything. Hard to see who would benefit from this book.
    9 people found this helpful
    Report
  • Reviewed in the United States on January 17, 2020
    Format: Paperback
    I was really excited to get this book, unfortunately it does not offer much for Windows based developers.

    Examples are all taken from a Mac, which is not the end of the world, but considering most .NET Core Devs are in fact Windows users, it's a little annoying.

    By the second chapter though, you're directed to use tools that don't even have a Windows version at all (Wercker CLI) and he even mentions in the book that the only reason he picked Wercker was because it didn't require a credit card up front. (?!?)

    He also makes a LOT of assumptions and jumps around a lot in his early projects, using phrases like "we added..." (when exactly did you add that, and where?)

    Lots of links to the web as well, which I understand means newer documentation, it also is a huge failure vector when trying to run everything as written in the book. A book should be a snapshot.

    Don't buy if you're a Windows Dev, unless you own a Mac or a Linux computer.
    One person found this helpful
    Report

Top reviews from other countries

  • Jesús Fernando González Cerroblanco
    5.0 out of 5 starsBuen libro
    Reviewed in Mexico on May 1, 2019
    Format: PaperbackVerified Purchase
    Buen contenido, falta profundidad pero cumple con lo mencionado
  • Jon Carl Griffiths
    1.0 out of 5 starsNot enough detail
    Reviewed in the United Kingdom on January 19, 2018
    Format: PaperbackVerified Purchase
    A complete lack of detail. Hurries quickly through all topics, pointlessly includes coverage of concepts such as dependency injection and TDD (lets face it, if you're writing microservices you'd really better already know these), tries bewilderingly to cover CQRS and Event Sourcing in a single chapter and is constantly directing the reader to external URL. I didn't purchase the book to read about TDD, dependency injection, CQRS and Event Sourcing. I did want to read in depth about service intercommunication, service discovery, advice on service organisation, persistence options and options for hosting, scaling, monitoring and reporting of the services. Sadly this book delivers no real depth of information on any of those.
  • Thiago
    4.0 out of 5 starsPractical guidelines
    Reviewed in Brazil on November 9, 2017
    Format: PaperbackVerified Purchase
    At first glance, the book is a good source about microservices, however, some topics are written briefly and don't go deeply enough as we'd suppose for the price I got this book.

    In a nutshell, the book is written for beginners and people starting to understand about microservices and it give us directions to manage Microservices trade-offs using .NET.

    I could get this book in Amazon US cheaper than Amazon Brazil once we have no tax to be paid for importing books. It is a complain. It is unfair
  • Petterson
    1.0 out of 5 starsEstragou o livro
    Reviewed in Brazil on July 9, 2023
    Format: PaperbackVerified Purchase
    Livro veio completamente amassado.