Implementing and Securing an API with ASP.NET Core

Building an API with ASP.NET Core is an obvious choice for solutions that require cross-platform hosting, micro-service architecture, or just broad scale. This course will show you how to do just that.
Course info
Rating
(220)
Level
Beginner
Updated
Jan 19, 2017
Duration
6h 8m
Table of contents
Course Overview
Getting Started
Reading Data
Modifying Data via an API
Entities and Models
Associations in APIs
Functional APIs
Securing APIs
Token Authentication
Versioning Your API
REST Constraints
Description
Course info
Rating
(220)
Level
Beginner
Updated
Jan 19, 2017
Duration
6h 8m
Description

Whether you're building a website, integrating with a SPA framework or even integrating with a mobile app, you need to build a smart and secure API. Building an API with ASP.NET Core is an obvious choice for solutions that require cross-platform hosting, micro-service architecture, or just broad scale. In this course, Implementing and Securing an API with ASP.NET Core, you are going build an entire web application, from start to finish. You'll start with a complete blank slate and end up with a small, but fully functional web application. First, you're going to learn why ASP.NET Core is a better way to build web applications, and how to create web pages with ASP.NET MVC. Next, you'll learn about building APIs with ASP.NET MVC, as well as how to secure your pages and APIs with ASP.NET Identity. Finally, you'll wrap up the course learning how to use AngularJS for client-side development. By the end of this course, you'll you'll feel confidence in knowing how to build your own applications with ASP.NET Core.

About the author
About the author

Shawn Wildermuth has been tinkering with computers and software since he got a Vic-20 back in the early '80s. As a Microsoft MVP since 2002, he's also involved with Microsoft as an ASP.NET Insider and ClientDev Insider.

More from the author
Less: Getting Started
Intermediate
1h 11m
Sep 19, 2018
More courses by Shawn Wildermuth
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone, my name is Shawn Wildermuth and welcome to my course Implementing and Securing an API with ASP. NET Core. I'm an author, a trainer, and a 15 time Mircrosoft MVP. ASP. NET Core is a great way to implement an API for your angular, react or other web-based project, regardless of what operating system you want to deploy your solution to. In this course I'm going to teach you how to build and secure a web API using ASP. NET Core. Some of the major topics that we cover will include building an API using ASP. NET Core, creating resource-based APIs from database data, securing an API, versioning an API, and implementing REST constraints. By the end of the course you'll be able to build an API from start to finish. Before beginning the course you should be familiar with ASP. NET Core and the Entity Framework. I hope you'll join me on this journey to learn APIs with ASP. NET Core, using the Implementing an API with ASP. NET Core course here at Pluralsight.

Reading Data
In this next module, we're going to start reading data. We'll start building our actual API by looking at how to read data from some data store, and expose it out through our API.

Modifying Data via an API
Welcome to the next module where we'll start modifying data in our API. We'll take what we've learned in the last few modules and apply them towards actually making changes to resources inside of our API. Let's do that next.

Associations in APIs
In this next module, we're going to be talking about Associations. The idea of Associations is that often, when you're building an API, you're dealing with resources that are related to each other. So in the canonical example of customers have orders, and orders have details, the orders have an Association to the customers, and the details have a relationship to the orders. You should design your API with these Associations in mind. So in our example, we have API that has our code camps, and then individual code caps have a moniker defining that resource, and then we're going to extend this by using Associations, where we're going to look at the speakers for an individual code camp, and then an individual speaker in that code camp we continue it down to look at the talks for that speaker in that code camp, and then finally, a specific talk for a specific speaker for specific code camp. When you're building your controllers, much like we did in previous modules, we built a controller for the camps to deal with not only getting a collection of camps or getting an individual camp, but also supporting, inserting, updating, and deleting those camps, as well as other operations you may need. We're going to extend this by creating an Association Controller for the speakers that are related to those camps, and then eventually a controller for the talks that are related to the speakers that are those camps. Now, this doesn't mean that you may not have a valid reason to create a controller and API directly to all the speakers across the camps, but in our case, speakers always exist in a camp and so it's just not necessary. What I'm talking about here is the specific things about creating controllers that have those Associations.

Securing APIs
In this next module, let's talk about how to secure your API. Through this module, I'll discuss some of the basics, including why you need to secure your API, how SSL works, what CORS is, as well as how to use ASP. NET Identity with an API. Let's get started.

Token Authentication
In this next module we're going to talk about token authentication. This is going to include using JWT tokens, which I'll explain and show you how to implement in order to handle most of the authentication scenarios you need.

REST Constraints
In this module, we're going to talk about REST constraints. This is going to include the different characteristics that REST services can implement to make them easier to consume and use and to increase their reliability.