1,079 karma · joined October 14, 2014
If you are looking to add Accounts Payable to your B2B product, drop me a line at sandeep at merc○a d○t c○m
Prev: Eng @ Stripe
Founder @ Kbee.app / Simplemnt.com
Developer Advocate @ Google Cloud
https://twitter.com/SandeepDinesh https://medium.com/@SandeepDinesh
[ my public key: https://keybase.io/thesandlord; my proof: https://keybase.io/thesandlord/sigs/f2WVOvjTgL_9f-Z701fGoqiRtlfAavM5RzczPZjZem8 ]
(I work for GCP)
(I work for Google)
On GCP you can run:
gcloud app deploy
And it will deploy your app on App Engine, with auto-scaling built in. The thing is, that is just the start. Pretty soon you will need databases, caching, versions, etc, etc.
(I work for Google Cloud)
Bonus: In depth code review for this package: https://youtu.be/c5ufcpTGIJM
The Java 8 runtime removed the sandbox restrictions. Most developers hated the restrictions. I highly doubt Microsoft would go down to the path of restrictions given the history in this space.
Until then, here is my shameless plug: https://medium.com/google-cloud/three-simple-steps-to-save-c...
I think the way they entered the market was unwise, not the decision itself. For example, Intel could have created an independent org within itself that could use Intel's resources but wasn't tied to legacy processes.
Now x86 is in the process of being disrupted. Look at ARM for example. Currently, most ARM chipsets are focused on mobile applications where low power is necessary. They are not powerful enough to compete with x86 on the server (yes I know there are ARM server parts, but it's still early days), but soon they will be for most customers. And at that point, the power/cost advantage will cause customers to switch over. This is already happening in laptops, with both Apple and Microsoft moving to ARM for their desktop OS. So I think it makes a lot of sense for Intel to try and address this concern, and competing with ARM/MIPS head on for the IoT market is one way to do this.
IMO the mistake Intel made is trying to take their x86 process, which has a value chain designed to serve high margin server markets, and shoehorn it into the IoT market which is dominated by low margin, ultra cheap parts (think ESP8266).
Take a look at this book for more info: https://en.wikipedia.org/wiki/The_Innovator%27s_Dilemma
There are a few interesting projects out there that do the kind of automation you are speaking of like these:
https://github.com/binary-com/gce-manager https://github.com/skelterjohn/prevmtable
Spreading multiple smaller machines over a multi-zone k8s deployment might help mitigate, but it will never solve all the issues.
Go for it as long as you understand the downside. It's possible that all instances get preempted at once (especially at the 24hr mark), that there isn't capacity to spin up new preemptible nodes in the selected zone once the old instance is deleted, etc. New VMs also take time to boot and join the cluster.
If you are just doing dev/test stuff, I'd recommend using a namespace in your production cluster or spinning up and down test clusters on demand (which can be preemptible).
If you have long running tasks (like a database) or are serving production traffic, using 100% preemptible nodes is not a good idea.
Preemptible can be great for burst traffic and batch jobs, or you can do a mix of preemptible and standard to get the right mix of stability and cost.
> Cloud solutions like elastic load balancing are generally engineered for the average use case. Think about the ways you are not like the average.
This might be the case for some things, but many of Google Cloud's "elastic/serverless" products (Load Balancers, App Engine, Pub/Sub, BigQuery, Datastore, etc) can truly scale up from nothing to huge traffic spike without the need for pre-warming and things like that.
(I work for Google Cloud)
Side note: Cosmos is really confusing to me, it has 5 consistency models, supports 4 different database models (I don't think relational is an option?), multiple different APIs, etc.
For example, Azure advertises the p99 latency, but don't specify the consistent model. I'm thinking it's for the eventual consistency, so in that case what's the latency for the strong consistency model? Definitely need to learn more.
Spanner is a database that merges the horizontal scalability of a NoSQL database with the strong consistency and SQL semantics of a relational database, basically the best of both worlds. People like to call this type of database "NewSQL."
Cassandra is also open source, Spanner is not. CockroachDB is the OSS clone of Spanner, but there are some differences and tradeoffs to be made as with all things.
(I work at Google Cloud)
You can run these models on prem, on AWS, etc.
(I work on GCP)
Ingress is free on all major clouds, but you still have to pay to get the data out.
(I work on GCP)