update api creation resources

mattmakai · mattmakai · commit 45066967023e · 2019-02-23T14:44:48.000-05:00
diff --git a/content/pages/04-web-development/44-web-apis.markdown b/content/pages/04-web-development/44-web-apis.markdown
@@ -66,10 +66,20 @@ on the number's page on Twilio as shown below.
   is a well-written overview of the REpresentational State Transfer (REST)
   architecture proposed by Roy Fielding in his dissertation.
 
+* The list of [public APIs](https://github.com/toddmotto/public-apis) in
+  this Git repository is incredible and worth examining if you are looking
+  to find data sources for your projects.
+
 * [GET PUT POST](https://medium.com/get-put-post) is a newsletter just
   about APIs. Past issues have included interviews with the developers 
   behind Stripe, Dropbox and Coinbase.
 
+* [Designing robust and predictable APIs with idempotency](https://stripe.com/blog/idempotency) 
+  discusses designing APIs for *idempotency*, which means guaranteeing that 
+  side effects only occur once. This topic is especially important with web
+  APIs because network connections are and will always be unreliable so you
+  need to build knowing network problems will happen.
+
 * [What RESTful actually means](https://codewords.recurse.com/issues/five/what-restful-actually-means)
   does a fantastic job of laying out the REST principles in plain language
   terms while giving some history on how they came to be.
@@ -87,6 +97,7 @@ on the number's page on Twilio as shown below.
   that are new in 2015.
 
 
+
 ## APIs learning checklist
 1. Learn the API concepts of machine-to-machine communication with JSON and 
    XML, endpoints and webhooks.
diff --git a/content/pages/04-web-development/48-api-creation.markdown b/content/pages/04-web-development/48-api-creation.markdown
@@ -57,6 +57,7 @@ applications through machine-to-machine communication.
 * [Pycnic](http://pycnic.nullism.com) is a JSON-API-only framework designed 
   with REST in mind. 
 
+
 ## API testing projects
 Building, running and maintaining APIs requires as much effort as building,
 running and maintaining a web application. API testing frameworks are the 
@@ -65,6 +66,8 @@ equivalent of browser testing in the web application world.
 * [zato-apitest](https://github.com/zatosource/zato-apitest) invokes HTTP 
   APIs and provides hooks for running through other testing frameworks.
 
+* [Tavern](https://taverntesting.github.io/) is a pytest plugin for 
+  automated API testing.
 
 
 ### Hosted API testing services
@@ -91,6 +94,10 @@ equivalent of browser testing in the web application world.
   difficult problems so keep an eye on server utilization and endpoint calls 
   growth to separate legitimate from illegitimate traffic. 
 
+* [API versioning](https://stripe.com/blog/api-versioning) is a wonderful
+  article on the tradeoffs between including an API version in the URL
+  compared to other common ways to version APIs.
+
 * [API Doc JS](http://apidocjs.com/) allows a developer to embed markup
   in their documentation that will generate a site based on the endpoints
   available in the API.
@@ -169,11 +176,9 @@ equivalent of browser testing in the web application world.
   into what makes a good API framework and which one you should currently
   choose for Django.
 
-* [Create a REST API in Minutes with Pyramid and Ramses](https://realpython.com/blog/python/create-a-rest-api-in-minutes-with-pyramid-and-ramses/)
-  is a thorough tutorial from start to finish that uses the 
-  [Pyramid](/pyramid.html) web framework along with 
-  [Ramses](https://pypi.org/project/ramses/), a library that uses
-  YAML files to generate a RESTful API.
+* [Creating Web APIs with Python and Flask](https://programminghistorian.org/en/lessons/creating-apis-with-python-and-flask)
+  is a free book on building APIs with [Flask](/flask.html) as the
+  core [web framework](/web-framework.html).
 
 * [RESTful web services with Python](http://www.slideshare.net/Solution4Future/python-restful-webservices-with-python-flask-and-django-solutions)
   is an interesting overview of the Python API frameworks space.
@@ -189,17 +194,30 @@ equivalent of browser testing in the web application world.
   subscribing to updates via a REST interface. Both REST hooks and webhooks
   are far more efficient than polling for updates and notifications.
 
+* [Rate limiters](https://stripe.com/blog/rate-limiters) provides a great
+  overview of how limiting access in both the number of requests per
+  second as well as the number of concurrent open connections can help
+  keep your API alive during times of heavy traffic.
+
 * Serialization is common for transforming objects into web API JSON
   results. One company found the serialization performance of Django REST 
   framework was lacking so they created 
   [Serpy](https://github.com/clarkduvall/serpy) and 
   [wrote a blog post with the results of its performance](https://engineering.betterworks.com/2015/09/04/ditching-django-rest-framework-serializers-for-serpy/).
 
+* [Designing a Web API](http://restlet.com/company/blog/2015/03/16/api-design-designing-a-web-api/)
+  gives a detailed walkthrough of concepts and design decisions you need
+  to make when building an API.
+
 * Microsoft's 
   [REST API Guidelines](https://github.com/Microsoft/api-guidelines/blob/master/Guidelines.md)
   are a detailed set of considerations for when you are building your own
   APIs that you want to be easily-consumable by other developers.
 
+* [Designing Good Static REST API Documentation](https://www.moesif.com/blog/technical/documentation/Designing-Good-Static-REST-API-Documentation/)
+  is about documentation not APIs themselves, but it covers a critical topic
+  if you want your API to succeed: how to use the damn thing.
+
 * [Building better API docs](https://engineering.gosquared.com/building-better-api-docs)
   shows how Square used Swagger with React to create more helpful docs.
 
diff --git a/content/pages/05-deployment/19-nginx.markdown b/content/pages/05-deployment/19-nginx.markdown
@@ -94,13 +94,17 @@ several years.
   has a great chapter devoted to why Nginx is built to scale a certain way
   and lessons learned along the development journey.
 
+* [nginx-quick-reference](https://github.com/trimstray/nginx-quick-reference)
+  provides fantastic tactical advice for improving Nginx performance,
+  handling security and many other critical aspects.
+
 * [Inside Nginx: How we designed for performance and scale](http://nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/)
   is a blog post from the developers behind Nginx on why they believe their
   architecture model is more performant and scalable than other approaches
   used to build web servers.
 
 * [Test-driving web server configuration](https://gdstechnology.blog.gov.uk/2015/03/25/test-driving-web-server-configuration/)
-  is a good story for how to iteratively apply configuration changes, such
+  tells a good story for how to iteratively apply configuration changes, such
   as routing traffic to [Piwik](http://piwik.org/) for 
   [web analytics](/web-analytics.html), reverse proxying to backend
   application servers and terminately TLS connections appropriately.
diff --git a/content/pages/05-deployment/33-ansible.markdown b/content/pages/05-deployment/33-ansible.markdown
@@ -48,10 +48,20 @@ be able to structure your playbooks:
   is an incredibly detailed look at how one developer installs and run
   Ansible.
 
+* This retrospective from a developer on 
+  [lessons from using Ansible exclusively for 2 years](https://blog.serverdensity.com/what-ive-learnt-from-using-ansible-exclusively-for-2-years/)
+  explains his rationale for choosing Ansible over Puppet and Chef,
+  then goes through several use cases and best practices learned over
+  time with the tool.
+
 * [Using Ansible for deploying serverless applications](https://opensource.com/article/17/8/ansible-serverless-applications)
   provides a short overview with an example playbook how Ansible can also
   be useful for configuring [serverless](/serverless.html) applications.
 
+* [Painless Immutable Infrastructure with Ansible and AWS](http://radify.io/blog/painless-immutable-infrastructure-with-ansible-and-aws/)
+  covers the steps needed for the unique authentication complexities
+  that arise from using Amazon Web Services for your infrastructure.
+
 * [DevOps from Scratch, Part 1: Vagrant & Ansible](https://www.kevinlondon.com/2016/09/19/devops-from-scratch-pt-1.html)
 
 * [Ansible: Post-Install Setup](https://valdhaus.co/writings/ansible-post-install/)
