Cover image for Design and Build Great Web APIs

Design and Build Great Web APIs

Release Date: 2020/10/01
ISBN: 9781680508123
Topic:
0%
136
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

APIs are transforming the business world at an increasing pace. Gain the essential skills needed to quickly design, build, and deploy quality web APIs that are robust, reliable, and resilient. Go from initial design through prototyping and implementation to deployment of mission-critical APIs for your organization. Test, secure, and deploy your API with confidence and avoid the "release into production" panic. Tackle just about any API challenge with more than a dozen open-source utilities and common programming patterns you can apply right away.

Good API design means starting with the API-First principle - understanding who is using the API and what they want to do with it - and applying basic design skills to match customers' needs while solving business-critical problems. Use the Sketch-Design-Build method to create reliable and scalable web APIs quickly and easily without a lot of risk to the day-to-day business operations. Create clear sequence diagrams, accurate specifications, and machine-readable API descriptions all reviewed, tested, and ready to turn into fully-functional NodeJS code.

Create reliable test collections with Postman and implement proper identity and access control security with AuthO-without added cost or risk to the company. Deploy all of this to Heroku using a continuous delivery approach that pushes secure, well-tested code to your public servers ready for use by both internal and external developers.

From design to code to test to deployment, unlock hidden business value and release stable and scalable web APIs that meet customer needs and solve important business problems in a consistent and reliable manner.

Table of Contents

  1.  Acknowledgments
  2.  Preface
    1. Your API Journey
    2. Who Should Read This Book
    3. How This Book Is Organized
    4. What’s Covered (And What’s Not)
    5. About the BigCo, Inc., Sample Project
    6. Online Resources
  3. Part I. Getting Started
    1. 1. Getting Started with API First
    2. Adopting the API-First Principle
    3. Exploring APIs with curl
    4. What’s Next?
    5. Chapter Exercise
    6. 2. Understanding HTTP, REST, and APIs
    7. Understanding Web API Protocols, Practices, and Styles
    8. Managing Files with Git
    9. What’s Next?
    10. Chapter Exercise
  4. Part II. The Design Phase
    1. 3. Modeling APIs
    2. Understanding Norman’s Action Lifecycle
    3. Modeling Our Onboarding API Lifecycle
    4. Managing Your Project with npm
    5. What’s Next?
    6. Chapter Exercise
    7. 4. Designing APIs
    8. The Power of Design
    9. The API Design Method
    10. Identifying Your API Descriptors
    11. Creating Your Sequence Diagram
    12. What’s Next?
    13. Chapter Exercise
    14. 5. Describing APIs
    15. Learning the Role of Description Formats
    16. Describing Your API with ALPS
    17. Updating Your API Project
    18. What’s Next?
    19. Chapter Exercise
  5. Part III. The Build Phase
    1. 6. Sketching APIs
    2. Learning from Frank Gehry’s Sketches
    3. API Sketching Example
    4. The Advantages of Sketching
    5. Sketching APIs with Apiary Blueprint
    6. API Sketching Tips and Tricks
    7. What’s Next?
    8. Chapter Exercise
    9. 7. Prototyping APIs
    10. What Is an API Prototype?
    11. API Prototyping with OpenAPI
    12. Translating Your API Design into HTTP
    13. Creating Your OpenAPI Document with SwaggerHub
    14. Saving and Exporting Your API
    15. Mocking Your API
    16. Generating Your API Documentation
    17. What’s Next?
    18. Chapter Exercise
    19. 8. Building APIs
    20. Defining the API Build Process
    21. Relying on a Repeatable Process
    22. Coding APIs with NodeJS and DARRT
    23. Putting It All Together
    24. What’s Next?
    25. Chapter Exercise
  6. Part IV. The Release Phase
    1. 9. Testing APIs
    2. The Goals of API Testing
    3. Testing with SRTs
    4. Using Postman for API Testing
    5. Running Tests Locally with Newman
    6. What’s Next?
    7. Chapter Exercise
    8. 10. Securing APIs
    9. Understanding Security Basics
    10. Implementing API Security with Auth0
    11. Supporting Machine-to-Machine Security
    12. What’s Next
    13. Chapter Exercise
    14. 11. Deploying APIs
    15. The Basics of Deployment Pipelines
    16. The Role of DevOps
    17. Deploying with Heroku
    18. What’s Next?
    19. Chapter Exercise
    20. 12. Modifying APIs
    21. Going Beyond Versioning
    22. The Three Rules for Safely Modifying APIs
    23. The Recommended Pattern for Testing for API Changes
    24. The Process for Safely Deploying APIs
    25. Shutting Down an Existing API
    26. What’s Next?
    27. 13. Some Parting Thoughts
    28. Getting Started
    29. The Design Phase
    30. The Build Phase
    31. The Release Phase
    32. What’s Next?
  7. Part V. Appendixes
    1. A1. Installation Hints
    2. curl
    3. Git
    4. GitHub and SSH
    5. NodeJS and npm
    6. Postman
    7. Newman
    8. Heroku Client
    9. Installing the Local Utiltities
    10. A2. Exercise Solutions
    11. Where’s the Code?
    12. Solution for Chapter 1: Getting Started with API First
    13. Solution for Chapter 2: Understanding HTTP, REST, and APIs
    14. Solution for Chapter 3: Modeling APIs
    15. Solution for Chapter 4: Designing APIs
    16. Solution for Chapter 5: Describing APIs
    17. Solution for Chapter 6: Sketching APIs
    18. Solution for Chapter 7: Prototyping APIs
    19. Solution for Chapter 8: Building APIs
    20. Solution for Chapter 9: Testing APIs
    21. Solution for Chapter 10: Securing APIs
    22. Solution for Chapter 11: Deploying APIs
    23. A3. API Project Assets Checklist
    24. Using the API Project Assets Checklist
    25. Notes on the Assets Checklist
    26. Your API Project Assets Checklist
18.226.177.223