Gain insights into designing robust APIs, explore essential tools for design, documentation, testing, and deployment. Delve into ALPS, OpenAPI, Postman, and Heroku for comprehensive API development.

Design and Build Great Web API's by The Pragmatic Programmer-01.png

webapis.tar.gz

Testing APIs

Testing API Exercise

Building API Exercise

Building API Exercise Solution

Securing API Exercise

Securing API Exercise Solution

MockAPI

Account Mock API

Company service Mock API

Challenge-1 Mock API Solution

Postman Mock API

At the start of this course, you’ll be introduced to a handful of important practices and principles for designing and building APIs that are robust, reliable, and resilient. You’ll also acquire skills in a wide range of developer tools, including tools for design, documentation, building, testing, security, and deployment. 

You'll learn the best practices for modeling an APIs lifecycle using Donald Norman’s action lifecycle. Then, you’ll learn how to use the sequence diagram for designing APIs and describing them using ALPS. For sketching an API, you will learn about Gehry's sketches. You will also cover OpenAPI and SwaggerHub for API mocking. Moreover, the usage of DARRT and NodeJS will be covered for building APIs. You'll finish with learning how to use the Postman for testing APIs and then deploy them using Heroku.

By the end of this course, you will have an in-depth understanding of how to make fully functional efficient APIs from its inception to its deployment.

Design and Build Great Web APIs

# Overview

In this lesson, we’ll discuss the background challenges of deploying API projects to the cloud and how deployment pipelines can make this easier, safer, and more reliable than just doing it all manually.

# Basics of the deployment pipeline
One of the most challenging elements of designing and building APIs is the deployment of the completed work into production. In many organizations, this “release into production” step is very risky and many have a special set of protocols established to deal with it.



Here are some of the protocols we’ve heard about when talking to companies about their release or deployment processes:

* “We can only release on the weekend, when no one’s in the building.”
* “Before release, we have a meeting with all the department heads where everyone has to give their ‘go/no-go’ to proceed.”
* “We stop all coding and bug fixes for two weeks while we package up and validate the build for the upcoming release.
* “Production releases take so much time and energy from the team that we only do it a few times a year.”

As we can see from this short list, releasing a product can be tough. There are lots of reasons for this, most of them historical, but it all boils down to some basic issues, outlined below.

## Too much time passes between releases
Writing code and building software is a pretty detailed and grueling practice. Small changes can have big impacts on the system we’re working on. And as time passes, every software system adds more data, which affects performance and can result in new and unexpected behaviors. When the code for new features and bug fixes is left alone for a while, the tests used to validate them become less reliable, and that means the release package itself is less likely to succeed.

## Most release packages are too big
Like time, size also affects release quality. The more changes in a single release, the less likely that release is to succeed. If there have been a lot of changes in a release and it fails, it can be hard to discover which of those changes (or which combination of those changes) are the cause of the failure.

## There are too many variables to control for each release
The number of changes in the release is just one variable of the process. Making sure all the tests were run on the same hardware as production, using the same version of the operating system, and using the same edition of the software framework, libraries, and utilities can be difficult to achieve. Teams often spend hours or days just recreating a parallel production environment to run tests again before committing the changes to production. And still, success is not guaranteed.






Learn about the basics of the deployment pipeline for an API.

Introduction

Understanding HTTP, REST, and APIs

Modeling APIs

Designing APIs

Describing APIs

Sketching APIs

Prototyping APIs

Building APIs

Testing APIs

Securing APIs

Deploying APIs

Modifying APIs

Some Parting Thoughts

Appendixes

The Basics of Deployment Pipeline

Overview