Running in Production

In this episode of Running in Production, Eduardo Messuti talks about building a status page and monitoring service with Phoenix and Elixir. It’s hosted on DigitalOcean and Heroku. It’s been up and running since 2017. Eduardo talks about upgrading their code base to use Phoenix contexts, using Oban, creating a notification abstraction, going all-in with EEx rendered templates and a bit of jQuery, using Docker Compose in production and more. Topics Include 1:59 – What it was like using Elixir back in 2017 4:52 – Elixir handles 500k requests a day and motivation to use Elixir / Phoenix 8:17 – The process to upgrade the code base to use Phoenix contexts 10:02 – Oban is being used to handle background jobs 14:39 – Sending out notifications and webhooks with custom code 16:39 – Using Mix format as part of a CI pipeline with GitHub Actions 19:00 – Breaking out the mail service into its own service 21:03 – About 28k lines of Elixir and 2k lines of JS 23:48 – Server rendered app with EEx vs going the SPA / API route vs Live View 28:45 – Supplying a status page embed widget for customers and custom domains 33:08 – Using nginx as a reverse proxy, ETS for caching along with Cloudflare 35:03 – Hugo is being used to serve the static marketing site 37:11 – Docker is being used in staging and production 38:17 – The mailer is hosted on Heroku, everything else is on DigitalOcean 39:58 – The hardware specs of the 4-5 DigitalOcean servers and what they do 42:27 – They’re running Ubuntu 20.04 LTS and upgraded the servers on the fly 44:13 – The servers are manually provisioned and run Docker Compose 50:52 – Deploying a feature from development to production 53:37 – User logos get uploaded and saved to disk with a Docker volume 54:52 – Using BackupPC for backing up the database, certificates and file uploads 56:40 – DigitalOcean’s monitoring and Pingdom are being used for various health checks 57:38 – Honeybadger and Papertrail for errors + logging, and the Elixir experience 1:00:38 – Best tips? Pick a technology you’re comfortable with and start building 1:01:31 – What it was like hiring Elixir contract workers 1:02:40 – Check out https://statuspal.io/ with promo code PRODUCTION to save 10% Links 📄 References https://turbo.hotwire.dev/ https://github.com/asdf-vm/asdf https://elixirjobs.net/ ⚙️ Tech Stack phoenix → elixir → bootstrap → cloudflare → digitalocean → docker → github-actions → heroku → honeybadger → hugo → jquery → lets-encrypt → mailgun → nginx → papertrail → pingdom → postgres → preact → twilio → ubuntu → webpack → 🛠 Libraries Used https://github.com/sorentwo/oban https://github.com/code-corps/stripity_stripe https://github.com/unrelentingtech/httpotion https://github.com/smpallen99/coherence https://github.com/preactjs/preact https://backuppc.github.io/backuppc/ Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Jon Perl goes over building a service that automates creating browser tests for your web apps. It’s built with Node and React and is hosted on Netlify, Vercel, Azure Containers and DigitalOcean. It’s been running in production since 2019. Jon talks about creating an open source tool and turning it into a SAAS app, using VNC and websockets to stream test runner data to the browser, keeping things as a mono repo, moving from Azure Containers to Kubernetes and much more. Topics Include 3:11 – Going from a self hosted version to self hosted + hosted SAAS app 7:20 – Motivation for using Node and React 8:33 – Docker is being used for the test runners 11:24 – A mono repo with Next.js, GraphQL and Apollo 15:33 – Balancing your unit tests with end to end tests 18:25 – Using noVNC and websockets to link the test runner output to the browser 22:58 – Spinning up separate Docker containers for each test runner 24:52 – Next.js, Webpack, React and Typescript make up the front-end JS 28:37 – Efficiently sending VNC data over websockets 32:21 – Handling usage limits with the API server 35:55 – PostgreSQL is their primary database and they’re using Pipedream 38:01 – Stripe is being used to handle payments and SendGrid to send emails 42:00 – Everything is hosted on a combo of Netlify, Vercel, Azure and DigitalOcean 47:11 – Scaling up and down Azure containers with custom Node scripts 49:06 – Moving to Kubernetes in the future but only after it was deemed worth it 57:08 – The current deployment strategy pre-Kubernetes 1:00:03 – Jest tests are written and the code is linted with ESLint 1:04:06 – Database backups and the front-end is deployed to 2 hosts for redundancy 1:06:11 – Datadog handles monitoring and logging with Slack for notifications 1:09:30 – Keeping your assets fresh in a SPA or a long lived app in a browser tab 1:14:44 – Best tips? Focus on getting something out and learning from it 1:16:32 – Toggling feature flags with ENV variables and database fields 1:18:03 – Building the selector generator was a tricky problem to solve 1:23:06 – Check out https://www.qawolf.com/, the app is on GitHub and you can email Jon Links 📄 References https://code.visualstudio.com/docs/remote/containers https://github.com/yjs/yjs ⚙️ Tech Stack node → react → apollo → azure → datadog → digitalocean → docker → github-actions → graphql → lets-encrypt → netlify → nextjs → nginx → open-source → pipedream → postgres → sendgrid → slack → stripe → vercel → webpack → 🛠 Libraries Used https://github.com/novnc/noVNC https://microsoft.github.io/monaco-editor/ https://github.com/socketio/socket.io https://github.com/patriksimek/vm2 https://www.kubestack.com/ https://github.com/eslint/eslint https://github.com/facebook/jest https://github.com/prettier/prettier Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, David Parker talks about building a service to subscribe to people with Ruby on Rails and Sapper. It’s hosted on Heroku ($30 / month) and has been up and running since November 2020. David talks about creating an API back-end with Rails, trying out Svelte and Sapper, the challenges of scraping names from websites, figuring out and fixing PostgreSQL performance issues, finding a good work / life balance and more. Topics Include 3:27 – Motivation for using Ruby on Rails and Sapper / Svelte 6:18 – Writing raw SQL queries before translating them to ActiveRecord 7:36 – A few Ruby libraries that helped build this project 9:37 – The challenges around scraping human names from various websites 13:17 – The API Rails back-end is a monolithic app with about 100 endpoints 15:44 – David pulls from 94 different sources to find new content 19:06 – The Engtagger gem helps figure out stop words 20:25 – Why did you go with an API back-end? 21:43 – What Svelte and Sapper are and how they help build UIs 25:34 – How the back-end and front-end communicate with each other 28:29 – ~11k LOC on the back-end and ~5 LOC on the front-end 30:49 – At the moment it’s a free service and there’s no ads too 33:23 – What Sidekiq is being used for in terms of background jobs 35:30 – Mailgun is being used to send all transactional emails 37:34 – How the service might be monetized in the future (it’s $30 / month for hosting now) 40:31 – Break down of Heroku Dynos and add-ons 43:17 – Figuring out how to add new people and also using Cloudflare 45:40 – The deployment process from development to production 49:16 – The database is being backed up through Heroku 52:00 – A features table is in the database to enable features for himself 54:37 – Logentries will send out a notification if something goes down 57:50 – What to look out for and how to fix certain performance issues with PostgreSQL 1:01:09 – An example of when to consider breaking up a wide table into multiple tables 1:05:22 – Best tips? Figure out your work / life balance and try the back-end / front-end split 1:11:21 – Find David on Twitter, https://www.programmingtil.com/ and his YouTube channel Links 📄 References https://www.mturk.com/ https://github.com/evanw/esbuild https://www.snowpack.dev/ https://dev.to/svelte-radio/building-listenaddict-with-david-w-parker https://github.com/heroku/heroku-pg-extras http://rachbelaid.com/postgres-full-text-search-is-good-enough/ https://mcfunley.com/choose-boring-technology ⚙️ Tech Stack rails → ruby → svelte → sapper → cloudflare → honeybadger → logentries → mailgun → new-relic → postgres → redis → vercel → webpack → 🛠 Libraries Used https://github.com/heartcombo/devise https://github.com/waiting-for-dev/devise-jwt https://github.com/yohasebe/engtagger https://github.com/rack/rack-attack https://github.com/rubocop/rubocop https://prettier.io/ Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Ege Ersoz goes over building a project management service using Phoenix and Elixir. It runs on Gigalixir along with Heroku and has been up and running since early 2019. Ege talks about using Elixir for the last few years, upgrading to use Phoenix contexts, building a monolithic app with an API back-end / VueJS front-end, building his own Stripe billing module, what it’s been like using Gigalixir and more. Topics Include 1:24 – What it was like using Elixir back in early 2019 4:55 – Motivation for using Phoenix and Elixir 6:37 – Phoenix Channels and Elixir GenServers are being used a bit 10:14 – It’s a monolithic app with mostly an API back-end using VueJS on the front-end 13:34 – Going through the process of upgrading to use Phoenix contexts 18:19 – Interesting packages in Ege’s mix file that helped him build his app 23:00 – The front-end assets are managed with Webpack, Vuetify is being used too 26:47 – Separation of concerns was the main reason for making an API back-end 29:43 – Stripe is being used to accept payments with no 3rd party Stripe library 32:27 – PostgreSQL is the primary database and it’s all hosted on Gigalixir 36:38 – The Gigalixir bill is about $200 a month including a staging environment 39:49 – The deployment process from development to production 42:07 – Offloading PDF generation to a micro-service 43:38 – Gigalixir is handling automated database backups 45:44 – UptimeRobot monitors the app and reports back if it’s down 47:05 – Getting rid of subdomains for each user account / tenant and multi-tenancy 51:34 – Moving from Timber to Logflare for application logs 54:26 – Transactional emails are sent using SendGrid 55:57 – Best tips? Having a trustworthy co-founder has been incredibly important 59:12 – Check out https://pricetable.io/ and you can email Ege directly too Links 📄 References https://en.wikipedia.org/wiki/BEAM_(Erlang_virtual_machine) ⚙️ Tech Stack phoenix → elixir → vue → gigalixir → gitlab-ci → heroku → logflare → postgres → s3 → sendgrid → stripe → uptime-robot → 🛠 Libraries Used https://github.com/bitwalker/timex https://github.com/elixirmoney/money https://github.com/ex-aws/ex_aws https://github.com/thoughtbot/bamboo https://github.com/sorentwo/oban https://vuetifyjs.com/en/ https://github.com/alvarcarto/url-to-pdf-api Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Jake Lazaroff talks about building a video rendering service with Express and Node. It runs on a few DigitalOcean servers and has been up and running in production since February 2019. Jake goes over rendering ~30k+ videos over 2+ years, executing background tasks, sharing lots of code between the back-end and front-end, using both Stripe and PayPal, not using an ORM with PostgreSQL, setting up Blue / Green deploys with Terraform, Packer and nginx, plus tons more. Topics Include 4:07 – Shipping an MVP in a bit under 6 months working on it nights and weekends 6:54 – About 125 videos are rendered per day (~30k since the 2+ years it’s been up) 9:09 – Motivation for using Express and Node and a few libs he’s using server side 12:02 – The app is mostly monolithic and Bull handles processing background tasks 13:10 – A background task spawns DigitalOcean servers for video rendering 16:14 – Both the Node back-end and JS front-end are in the same repo and share code 17:49 – The shared code lets you get real-time video previews straight in the browser 20:06 – Create React App was used as a base to build the front-end 22:16 – Hugo powers the marketing site and is hosted on Netlify 24:00 – There’s no custom theme, it’s all hand crafted CSS using SASS 25:30 – Both Stripe and PayPal are used to handle 1 time and subscription payments 31:03 – The admin back-end is a bunch of API endpoints protected by an admin user flag 32:33 – PostgreSQL is the primary database and no ORM is being used 34:56 – TypeScript is used through out the code base / nginx + Cloudflare is being used 36:31 – Docker isn’t being used in development / Postmark is used for sending emails out 38:43 – Blue / Green deploys with Terraform, Packer and nginx on DigitalOcean 41:56 – Ubuntu LTS is running on all of the servers 42:41 – 1 CPU / 1 GB for the API server & load balancer, 1 CPU / 3 GB for the renderers 43:04 – Paid videos get a CPU optimized render server with 4 CPUs / 8 GB of memory 44:41 – Videos use up a lot of storage and they’re stored on DigitalOcean Spaces 47:35 – Ansible was used in the past but now everything is baked into the Packer image 48:53 – The deploy process from development to production 54:31 – Database migrations are run out of band with a tool called Dbmate 55:28 – Backups are handled with DigitalOcean’s automated backups 58:16 – Alarms, alerts, monitoring and error reporting 1:01:57 – The paid plan has unlimited video uploads and overall hosting is ~$125 / month 1:07:05 – Best tips? You can’t go too wrong with choosing boring technology 1:09:27 – Check out SongRender (IG / Twitter), Jake has a personal blog and is on Twitter too Links 📄 References https://en.wikipedia.org/wiki/Non-linear_editing https://paw.cloud/ https://jake.nyc/words/bluegreen-deploys-and-immutable-infrastructure-with-terraform/ https://martinfowler.com/bliki/BlueGreenDeployment.html http://boringtechnology.club/ ⚙️ Tech Stack express → node → react → hugo → cloudflare → digitalocean → digitalocean-spaces → netlify → nginx → packer → papertrail → paypal → postgres → postmark → redis → sentry → statuscake → stripe → systemd → terraform → ubuntu → webpack → 🛠 Libraries Used https://github.com/bithavoc/express-winston https://github.com/OptimalBits/bull https://github.com/facebook/create-react-app https://github.com/sass/sass https://github.com/mjmlio/mjml https://github.com/amacneil/dbmate Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Utsav Shah goes over building Dropbox with Pylons, Python, Rust and Go. It’s mostly hosted on their own data centers across 1,000+ servers. It’s been available since 2008. They have 700+ million users and handle 100k+ requests per second. Utsav talks about working with hundreds of engineers on a multi-million line Python based monolithic app, handling payments without Stripe, storing exabytes of files, using Rust in the desktop client, having remote dev boxes, leveraging open source tools and tons more. Topics Include 1:32 – A couple of hundred of developers committing to a monolithic app 2:30 – Motivation for choosing Pylons and Python 4:04 – Their service architecture can be described as a solar system 6:03 – Building their own NoSQL database called Edgestore before MongoDB existed 8:41 – Pylons is a micro-framework for Python 10:29 – Developing a custom payment handling system before Stripe existed 13:43 – How Dropbox stores your files on disk and who can access those files 17:32 – Back in 2014 Dropbox moved away from S3 to their own infrastructure 18:50 – Dealing with exabytes of storage 20:44 – A “multi mono repo” set up with millions of lines of Python 21:57 – The desktop client is a combination of Python and Rust 23:34 – Updating the desktop client code base from Python 2 to Python 3 26:09 – Pytest is being used for tests and Black for code formatting 29:04 – A developer can spin up their own Dropbox stack on a hosted dev server 32:34 – The web UI is mostly server rendered templates and a mix of React 36:46 – There’s a lot going on with MySQL, plus memcached and nginx / Envoy 39:06 – Using open source libraries created by Facebook and YouTube 41:39 – The open source version of nginx is being used a bunch 43:33 – Most things are hosted on their own data centers running Ubuntu 45:32 – There’s dedicated teams that focus on the infrastructure 46:59 – How code gets from a developer’s dev environment to passing in CI 53:46 – Once everything passes, it’s rolled out internally and then incrementally to users 55:13 – Feature flags are being used with a home grown solution 56:06 – Dealing with secrets using something they’ve developed in house 58:01 – Sometimes you end up building out a lot more than your core product 59:03 – Your files are very safely and securely backed up 1:01:16 – Monitoring, alerting, logging and error handling 1:04:09 – Rate limiting is handled at the app level along with memcached 1:05:13 – Best tips? Monoliths aren’t bad if you invest in them 1:06:30 – Think deeply about what you’re developing and focus on the architecture 1:08:55 – Utsav has a podcast at https://www.softwareatscale.dev, check it out! Links 📄 References https://dropbox.tech/infrastructure/atlas--our-journey-from-a-python-monolith-to-a-managed-platform https://dropbox.tech/application/speeding-up-a-git-monorepo-at-dropbox-with--200-lines-of-code https://dropbox.tech/infrastructure/reintroducing-edgestore https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/ https://www.softwareatscale.dev/p/software-at-scale-001-alexey-ivanov (podcast episode) https://dropbox.tech/infrastructure/magic-pocket-infrastructure (exabytes of storage) https://dropbox.tech/infrastructure/continuous-integration-and-deployment-with-bazel https://dropbox.tech/infrastructure/how-we-migrated-dropbox-from-nginx-to-envoy https://dropbox.tech/infrastructure/athena-our-automated-build-health-management-system https://dropbox.tech/infrastructure/monitoring-server-applications-with-vortex ⚙️ Tech Stack pylons → python → golang → rust → react → cassandra → envoy → memcached → mysql → nginx → phabricator → ses → ubuntu → webpack → 🛠 Libraries Used https://pythonpaste.readthedocs.io/en/latest/ https://github.com/python/mypy https://github.com/pytest-dev/pytest https://github.com/psf/black https://github.com/bazelbuild/bazel Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Nate Rush goes over building a JupyterLab extension with Python. It runs locally in a Jupyter Notebook but they also host JupyterHub instances on a Kubernetes cluster running in EKS. It’s been running in production since late 2020. Nate talks about building a cross platform Python installer, building and publishing a JupyterLab extension, leveraging Pandas, building the front-end with React / Typescript, hosting a version of their product on a Kubernetes cluster, the value in automating the hard stuff and more. Topics Include 1:15 – What is a Jupyter Notebook and how do JupyterLab extensions work? 3:35 – 2 developers are currently building it 6:50 – You can run it in an offline notebook or through their hosted service 8:48 – Handling local installations across Windows, macOS and Linux 15:58 – How users launch their Jupyter Notebook locally with this extension 17:16 – How do you create a JupyterLab extension? 21:10 – The back-end is built upon Pandas 23:31 – How do front-end assets make their way into the extension? 28:50 – Webpack is being used to bundle up the front-end assets 29:36 – Using GitHub Actions to handle the deploy process for the JupyterLab extension 35:20 – Front-end packages to help build a spreadsheet driven UI 37:37 – Discovering front-end performance issues and errors through logging 45:12 – Hosting JupyterHub instances on Kubernetes with EKS on AWS 47:32 – The hosted version is free, but it’s on its way to being phased out 51:57 – The workflow for deploying the Kubernetes set up and running 3-10 worker nodes 54:56 – Backups of the Kubernetes cluster are handled with Velero 56:13 – Route53 is hosting their DNS records 57:29 – Best tips? They really love Typescript and also automate as much as possible 1:00:58 – Don’t hesitate to ask for help and focus on what your users want 1:06:34 – Check out https://trymito.io Links 📄 References http://paulgraham.com/ds.html https://docs.anaconda.com/anaconda/navigator/ https://jupyter.org/hub The Phoenix Project book ⚙️ Tech Stack jupyter → python → react → aws → kubernetes → webpack → github-actions → s3 → route53 → segment → mixpanel → 🛠 Libraries Used https://pandas.pydata.org/ https://github.com/pytest-dev/pytest https://github.com/DevExpress/testcafe https://www.ag-grid.com/ https://velero.io/ Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Tigran Nazaryan covers building a WordPress hosting platform with Laravel, Python and Node. It’s hosted on GCP for their clients’ sites and OVH for their core services. It’s been up and running as a hosting platform since late 2020. Tigran talks about working with a team of 34 engineers, using both MongoDB and MySQL, creating a bunch of services with a very well thought out architecture while keeping it simple enough for it to all run on a developer’s laptop. He covered a lot of ground. Topics Include 1:49 – Thousands of customers have their site hosted there 3:00 – A break down of their stack (there’s a lot going on) 4:38 – Motivation for choosing a mixture of programming languages and frameworks 7:10 – All of the services are independent and live in their own git repo 9:23 – The image optimizer service is written with Laravel 12:34 – MongoDB is quite heavily used by a number of services 15:40 – How to optimize CSS and JS bundles with many WordPress plugins 21:13 – The hosting service is written in Python with MySQL for a DB (hosted on GCP) 23:52 – It’s mostly Linux containers being used but Docker is used in some spots 25:11 – End customers don’t need to worry about things like nginx and SSL certs 30:30 – Other tech components that’s in their stack 32:00 – Payments are handled monthly or annually with Stripe and PayPal 33:12 – Client sites are hosted on Google Cloud and their services are on OVH 37:33 – Some of the servers are pretty beefy with 32GB of memory and 8+ CPU cores 39:56 – Developers can run everything on their own laptops 44:27 – The developers who build a service are responsible for deploying it 45:26 – The process to set up a server is documented and automated when possible 48:46 – Customers can access their hosted sites very quickly after signing up 51:13 – The deployment process from development to production 56:55 – Databases are backed up and core services are load balanced 59:04 – Keeping track of errors, monitoring and alerting 1:03:45 – Cloudflare is sitting in front of the core services 1:06:42 – Best tips? Really focus on getting a good architecture designed early on 1:10:36 – Check out https://10web.io/, Tigran’s LinkedIn and their Engineer blog Links 📄 References https://developers.google.com/speed/pagespeed/insights/ ⚙️ Tech Stack laravel → php → python → node → angularjs → cloudflare → docker → gcp → lets-encrypt → mongodb → mysql → nginx → ovh → paypal → redis → sentry → slack → stripe → ubuntu → 🛠 Libraries Used https://github.com/PyCQA/flake8 https://github.com/psf/black https://github.com/PyCQA/bandit Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Ian Eyberg goes over creating a Unikernel with C as well as host a few sites supporting his tool with Go. It’s hosted on Google Cloud and their own data center. Nanos has been available since 2020. Ian talks about what a Unikernel is, their open source tools and how they manage their own services. This episode has a healthy mix between background knowledge on Unikernels and how they (as a company) set up their infrastructure. It’s worth pointing out you can run your existing applications in a Unikernel without having to change how it’s written and they support running them on most major hosting providers (AWS, GCP, Azure, DigitalOcean, your own hardware, etc.). Topics Include 1:44 – What is a Unikernel? How is it different than a traditional VM or container? 7:58 – There’s a free and open source tool and an optional SAAS offering 10:07 – How it’s possible to build a new deployable golden image in 2 minutes 12:12 – Motivation to use Go for building the surrounding sites and services 16:51 – Certain organizations are pushing decent traffic through their Unikernel driven apps 19:02 – How you can run a multi-service app with Nanos (web + worker + db + cache, etc.) 22:59 – ops.city and nanos.org are a single Go binary / 1 Unikernel driven app 25:37 – The nanovms.com site is a bit more involved and has Stripe integration 28:08 – I never heard of the term Unikernel until today 30:20 – nginx isn’t sitting in front of the Go app and how Unikernels can be so fast 40:29 – With a Unikernel approach you can easily move between hosting providers 44:23 – SSL certs are handled directly by the Go app for their sites 49:56 – nanos.org and ops.city use GCP and nanovms.com is on their own hardware 54:26 – Why they went with their own data center for hosting and their server specs / costs 1:02:02 – Terraform, Ansible and similar tools aren’t being used to set up anything 1:04:21 – What the deployment process looks like for their services 1:10:40 – You can run all of this on a Raspberry Pi 4 1:13:15 – What does the development process look like with a Unikernel driven app? 1:16:21 – Dealing with secrets in production 1:17:55 – Databases are backed up regularly and how logs are handled 1:23:52 – Getting notified of errors and up-time reports from updown.io 1:25:52 – Mailgun is used for sending out transactional emails 1:26:45 – Best tips? Keep it simple (seriously) 1:30:05 – Thoughts on the Plan9 operating system 1:34:06 – You don’t need to change how you write your apps to run them in a Unikernel 1:40:07 – The code for Nanos is open source on GitHub Links 📄 References https://ops.city/ https://nanos.org/ https://firecracker-microvm.github.io/ https://deepdiscountservers.com/ https://he.net/ https://queue.acm.org/detail.cfm?id=2349257 ⚙️ Tech Stack golang → aws → circle-ci → gcp → mailgun → s3 → stripe → updownio → webpack → 🛠 Libraries Used https://github.com/gorilla/mux Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

In this episode of Running in Production, Cole Simmons goes over building an AI driven service for commercial real estate professionals with Flask and Python. It’s hosted on Google Cloud using GKE (Kubernetes) and has been up and running since 2017. Cole talks about rewriting the initial prototype, the dangers of not using an ORM, splitting out the front-end from the back-end, using Google Functions, the importance in making sure you’re building what your users want and so much more. Topics Include 1:05 – The inefficiencies when dealing with commercial real estate 6:51 – From an MVP in 2016 to the main app in 2017 to the first paying customer in 2019 16:48 – Motivation for choosing Flask and Python and backing out from using Go 21:59 – Losing (recoverable) data by accidentally running a bad raw SQL query 24:14 – Using openpyxl to handle Excel files and Weasy print to export PDFs 25:31 – The API is a separate service in its own repo and the AI stuff runs on App Engine 30:47 – The API is built with Flask straight up, no external packages 32:19 – The front-end is built using React and Redux 34:24 – Creating an amazing data tables solution is still not a generic solved problem 39:43 – Payments are handled in a custom way (ACH, check, etc.) 44:06 – Going with Google Cloud, Google Functions and GKE (Kubernetes Engine) 49:18 – A DNS related GCP bug caused ~80% of their requests to 404 for 2-3 days 54:00 – Developing local functions and what it’s like to deploy everything 1:03:04 – Making sure the back-end and front-end deployments are sync’d up 1:05:15 – Dealing with secret management using Google’s key management service 1:07:48 – Currently using Mailgun but looking to switch over to Postmark 1:13:43 – Database and file backups are happening regularly 1:19:31 – GCP’s logging and error reporting has been good so far, using LogRocket too 1:21:25 – The TL;DR on what Webflow is and how they use it for their landing page 1:27:10 – Best tips? Listen to advice but make and follow your own path 1:29:41 – Customer discovery is important as well as asking the right questions 1:32:15 – It’s probably going to take you longer to build your app than you initially think 1:38:30 – Cole’s on Twitter and you can email him if you’re an engineer that is interested in this problem space Links 📄 References https://phoenixframework.org/ https://blog.samaltman.com/advice-for-ambitious-19-year-olds ⚙️ Tech Stack flask → python → react → app-engine → docker → elasticsearch → firebase → gcp → gke → intercom → jenkins → kubernetes → log-rocket → mailgun → postgres → webflow → 🛠 Libraries Used https://github.com/coleifer/peewee https://openpyxl.readthedocs.io/en/stable/ https://weasyprint.org/ https://github.com/pytorch/pytorch https://github.com/reduxjs/redux https://imagemagick.org/index.php Support the Show This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.