English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 11h 40m | 1.66 GB
Follow real-world API projects from concept to production, and learn hands-on how to describe and design APIs using OpenAPI.
In Designing APIs with Swagger and OpenAPI you will learn how to:
- Understand OpenAPI syntax and structure
- Use Swagger and other tooling to create OpenAPI definitions
- Design authentication and authorization
- Turn an OpenAPI description into online documentation
- Automate processes and generating code
- Iterate an API design with user stories
- Build a frontend against a mock server
- Generate backend code with Swagger Codegen
- Versioning an API and dodging breaking changes
- Work with cross-functional teams
Designing APIs with Swagger and OpenAPI is a comprehensive guide to designing and describing your first RESTful API using the most widely adopted standards. Following expert instruction from Swagger core contributor Josh Ponelat and API consultant Lukas Rosenstock, you’ll spend each chapter progressively expanding the kind of APIs you’ll want to build in the real world. You’ll utilize OpenAPI and Swagger to help automate your workflow, and free up your time to work on more exciting features. Learn the syntax and structure of OpenAPI definitions, create and iterate on an API design with common tools, and release your API to the public.
Create web APIs that customers and developers will love! Using Swagger, a collection of tools for defining and documenting REST APIs, you will build safe, controlled access to your software. And because Swagger implements the vendor-neutral OpenAPI specification, you’ll be building to the same standards adopted by Google, Microsoft, and Amazon.
Designing APIs with Swagger and OpenAPI introduces a design-first approach. Written for developers new to API design, it follows the lifecycle of an API project from concept to production. You’ll explore the dos and don’ts of APIs through progressively complete examples. You’ll get hands-on experience designing APIs for specific business needs, using open source tools to generate documentation, and building developer-friendly components like mocks and client SDKs.
what’s inside
- OpenAPI syntax and structure
- Using Swagger to create OpenAPI definitions
- Automating processes and generating code
- Working with cross-functional teams
Table of Contents
1 Part 1 Describing APIs
2 Introducing APIs and OpenAPI
3 Where do OpenAPI definitions fit in
4 When to use OpenAPI
5 Getting set up to make API requests
6 Adding a review to the FarmStall API
7 Our first taste of OpenAPI definitions
8 Using Swagger Editor to write OpenAPI definitions
9 Writing in Swagger Editor
10 Describing API responses
11 Status codes
12 Describing message, uuid, and userId
13 Creating resources
14 Adding examples to make try-it-out look pretty
15 Adding authentication and authorization
16 Adding the Authorization header
17 Preparing and hosting API documentation
18 Markdown basics
19 Hosting our API documentation using Netlify.com and Swagger UI
20 Part 2 Design-first
21 Designing a web application
22 Domain modeling and APIs
23 The Job and Dog models
24 Mapping user stories
25 Creating an API design using OpenAPI
26 Creating the schemas
27 The CRUD approach to API operations
28 API operations for PetSitter
29 JobApplication operations
30 Building a change workflow around API design-first
31 GitHub as our workflow engine
32 Steps in our GitHub workflow
33 Implementing frontend code and reacting to changes
34 Adding multiple examples into your OpenAPI definition
35 Choosing which mock data response to get from Prism
36 Building a backend with Node.js and Swagger Codegen
37 Investigating the structure
38 Tagging API operations
39 Testing input validation
40 Configuring Mongoose in the project
41 Integrating and releasing the web application
42 Implementing authorization
43 Managing repositories
44 Server setup
45 Part 3 Extending APIs
46 Designing the next API iteration
47 Preparing for new features
48 Reviewing user stories
49 Improving the developer experience
50 Input validation
51 Designing schemas with composition in OpenAPI
52 Polymorphism and inheritance in domain models
53 Polymorphism and inheritance in OpenAPI
54 Adding discriminators in OpenAPI
55 Scaling collection endpoints with filters and pagination
56 Designing filters
57 Handling nested schemas
58 Finding filter fields
59 Adding filters to OpenAPI
60 Offset-based and page-based pagination
61 Pagination for PetSitter
62 Multifield sorting
63 Supporting the unhappy path Error handling with problem+json
64 Finding unhappy paths
65 Requirements for error responses
66 The problem+json format
67 Error-handling guidance
68 Improving input validation with advanced JSON Schema
69 Enforcing number constraints
70 Updating PetSitter schemas
71 Versioning an API and handling breaking changes
72 Multiple API versions
73 Using media types to version operations
74 The API prerelease checklist
75 End-to-end testing
76 Getting your API consistent
77 Getting a change strategy
78 Swagger 2.0, OpenAPI 3.0, and OpenAPI 3.1
79 Components and structure
Resolve the captcha to access the links!