Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Python Microservices

Sponsored · SiteGround - Reliable hosting with speed, security, and support you can count on. →

Python Microservices

This talk was given at EuroPython on July 10th, 2017

Miguel Grinberg

July 10, 2017

Transcript

24 slides
  1. About Me • Software Dev @ Rackspace • Flask Mega-Tutorial

    • Flask Web Development book • APIs, Microservices • Python, JavaScript, C++ • @miguelgrinberg • blog.miguelgrinberg.com • github.com/miguelgrinberg
  2. My Other Sessions • Building Microservices With Python and Flask

    Training Session Tuesday 10:15 to 13:15 • Flask & Web Development Help Desk Thursday 10:30 to 12:00, 14:00 to 15:30
  3. Long Functions vs Short Functions def pong(): # long function

    implemented here # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... # ... if __name__ == '__main__': pong() def game_complete(): # short function implemented here # ... def move_player(player_number): # short function implemented here # ... def move_ball(): # short function implemented here # ... def check_collisions(): # short function implemented here # ... def pong(): while not game_complete(): move_player(0) move_player(1) move_ball() check_collisions() if __name__ == '__main__': pong()
  4. A Typical Monolithic Python Web Application This app is real!

    Find it at https://github.com/miguelgrinberg/flack.
  5. The Problems with Monoliths • Codebase becomes harder to maintain

    and test as it grows larger • Coupling between modules causes random bugs when changes are made • Steep learning curve for new team members • Deployments and upgrades require downtime • If the service crashes, your entire site goes down • Inefficient scaling • Difficult to incorporate to new technologies
  6. Benefits of Microservices • Code complexity greatly reduced • Service

    separation promotes decoupled designs that have less bugs • There is a lot less to learn to become productive • Deployments don’t require downtime • If a microservice crashes, the rest of the system keeps going • Each microservice can be scaled individually according to its needs • Services can use different tech stacks
  7. Disadvantages of Microservices • The complexity moves from the code

    to the interactions between services • Complex database joins must be implemented by the application • Deployments have a lot of moving pieces • Lower performance when a request “pinballs” through multiple microservices
  8. Refactoring a Monolith into Microservices • Strategy #1: Microservices only

    going forward • Strategy #2: Break pieces of functionality into microservices over time • Strategy #3: Refactor the entire monolith into microservices • In all cases, a base microservices platform needs to be put in place before refactoring work begins
  9. Load Balancer • All microservices are accessed through the load

    balancer • While microservices come and go, the load balancer is the “switchboard” • Enables horizontal scaling of services • Enables very cool tricks ◦ Rolling upgrades ◦ A/B testing ◦ Green/Blue deployments ◦ Etc.
  10. Service Registry • Datastore that keeps a list of running

    services • Must be redundant, highly available, and fast • Services make themselves known to the registry when they start • They are removed (and possibly replaced) when they end or crash • The load balancer is dynamically reconfigured when the registry changes
  11. Containers • Make services portable across host platforms • Provide

    an additional layer of isolation over processes • Allow each service to use its own dependencies • Simplify managing of network ports
  12. Storage • Service registry, databases, message queues, etc. are stateful

    services • It is important to make these services robust to prevent data loss • Most storage solutions have clustering or mirroring options ◦ MySQL → Galera, Aurora (AWS) ◦ RabbitMQ → Native clustering and mirroring ◦ Etc.
  13. Application Microservices • The microservices that you write are (ideally)

    stateless • They can start and stop at any time, without data loss • Horizontally scalable for free • Python microservices can be written as simple web APIs using any framework • Or you can use other mechanisms such as RPC to receive requests
  14. Lifecycle of a Microservice • On startup, the microservice registers

    with the service registry • The load balancer detects the change in the registry and updates itself to include the new microservice • The new service starts receiving traffic from the load balancer • If more than one instance of the service exist, the traffic is split among them • The service sends “keep-alive” signals, or responds to periodic health checks • When the service is stopped, or stops sending keep-alives, or fails a health check, it is removed from the registry, and in turn from the load balancer
  15. Service-to-Service Communication • Outside clients connect over HTTP/REST (or maybe

    WebSocket) • The service receiving the client request may need to invoke other services • Services communicate with each other in a variety of ways ◦ HTTP/REST ◦ Job or message queues ◦ RPC mechanisms • Payloads exchanged between services should use well known formats ◦ Pickle is not a good idea ◦ JSON, msgpack, protobufs are all good
  16. Deploying MicroFlack to your Laptop • Requirements ◦ 4GB RAM

    (8GB recommended) ◦ Vagrant ◦ VirtualBox ◦ Everything is installed in an Ubuntu 16.04 VM (Windows, Mac, Linux laptops are all OK!) • Deployment commands: git clone https://github.com/miguelgrinberg/microflack_admin cd microflack_admin vagrant up # to create the VM or restart it after shutdown vagrant ssh # to open a shell session on the VM vagrant halt # to shutdown the VM (without destroying it) vagrant snapshot save clean # to save a snapshot with name “clean” vagrant snapshot restore clean --no-provision # to restore the snapshot vagrant destroy # to delete the VM

More Decks by Miguel Grinberg

Other Decks in Programming