If you instead measure how much people talk about renewable energy, California comes out far ahead.
Back in 2011, I was using it to learn API development by intercepting mobile app requests when I discovered that Airbnb’s API was susceptible to Rails mass assignment (https://github.com/rails/rails/issues/5228). I then used it to modify some benign attributes, reached out to the company, and it landed me an interview. Rest is history.
Second, was around the migration from desktop to online. At the time, TurboTax was one of the earliest tax prep products that had a cloud offering. It had done so in a somewhat interesting way. In order to maintain parity between the tax calculations and segregate tax data, they were running an instance of the desktop software for each web user server side. It would then use a Java process to convert the desktop UI to HTML (somewhat IE specific) and output it back to the user. It was very inefficient from the resource side but it made me appreciate how nimble this large company was in adapting to new mediums.
We are running a relatively small system on k8s. The cluster contains just a few nodes, a couple of which are serving web traffic and a variable number of others that are running background workers. The number of background workers is scaled up based on the amount of work to be done, then scaled down once no longer necessary. Some cronjobs trigger every once in a while.
It runs on GKE.
All of this could run on anything that runs containers, and the scaling could probably be replaced by a single beefy server. In fact, we can run all of this on a single developer machine if there is no load.
The following k8s concepts are currently visible to us developers: Pod, Deployment, Job, CronJob, Service, Ingress, ConfigMap, Secret. The hardest one to understand is Ingress, because it is mapped to a GCE load balancer. All the rest is predictable and easy to grasp. I know k8s is a monster to run, but none of us have to deal with that part at all.
Running on GKE gives us the following things, in addition to just running it all, without any effort on our part: centralized logging, centralized monitoring with alerts, rolling deployments with easy rollbacks, automatic VM scaling, automatic VM upgrades.
How would we replace GKE in this equation? what would we have to give up? What new tools and concepts would we need to learn? How much of those would be vendor-specific?
If anyone has a solution that is actually simpler and just as easy to set up, I'm very much interested.
A few years ago I joined a startup where everything (including the db) was running on one, not-backed-up, non-reproducible, VM. In the process of "productionizing" I ran into a lot of open questions: How do we handle deploys with potentially updated system dependencies? Where should we store secrets (not the repo)? How do we manage/deploy cronjobs? How do internal services communicate? All things a dedicated SRE team managed in my previous role.
GKE offered a solution to each of those problems while allowing me to still focus on application development. There's definitely been some growing pains (prematurely trying to run our infra on ephemeral nodes) but for the most part, it's provided a solid foundation without much effort.
It also has built-in key remapping so you don’t need to mess with anything on the OS level.
While I empathize with the individuals affected, part of me can't help thinking of it as a good problem on the city level. Growing up there were places where the copper piping was more valuable than the houses. Even now there's plenty of properties to buy sub $20k, close to mass transit, farmer's markets, and places like Case Western University.
Maybe some of the affected in Detroit will move down to Cleveland and one day I too will have the luxury of complaining about gentrification.