Some examples of how many job iterations would use 1 Gb hour would help, or maybe I'm missing them?
It's really just the running time of your program (you control this) plus a less than a second of setup / tear down time. If your job is set to consume 1GB that's it, you've consumed that many GB-seconds. If it's a 128MB job, then you've only consumed 1/8th of that many GB-seconds.
Let me know if this example is getting it across, it's a simplified version of the pricing of other serverless platforms.
I really need to guarantee controlling unbounded costs. I would think most people have similar expectations.
Coherence API is a twist on serverless that lets you deploy and run code the same way you call a local function. It integrates with the programming language so you can just pass a func and it's getting run. No need to change your workflow or toolset.
I'll be here to answer any questions.
The problem that I have with these Serverless stacks is that they all demo pretty well for the trivial case of "it sends emails / transcodes video / puts files in S3" but then jump to "run your entire business on this" without clearly showing how its possible to do that with a complex system.
Is your solution different?
I'm moving over some of my own services to Coherence so it's very much intended to "run your whole business".
"Backend-as-a-service" businesses need to check all of those boxes.
- scaling the function
This is where we've invested most of our effort. We're envisioning a load test demo soon.
- monitoring the function (billing, errors, throughput, latency)
This is something which we will need to invest more in. Great feedback here. We don't have much in the way of monitoring yet, but everything is there and we just need to expose it to the users.
- moving data between two functions, storing data
Traditional solutions like Redis and Postgres seem like a good solution here. You can't host them on Coherence yet, but it's something that we're working on.
- signaling a function, upgrading a function, downgrading a function
Versioning is particularly interesting here. A lot of time we've thought of these functions as ephemeral.
Send me an email (bryan at coherenceapi . com) I'm really interested to talk more about the use cases you're envisioning.
A malicious user that manages to break out of the container environment will only have access to other instances of their own applications. Stronger security policies exist between users.
In terms of DOS'ing our services, we limit disk space usage per job, and are working on bandwidth limitations (this is a weakness, but for now we'll just ban abusers and work with those with legit needs)
Or things like using stolen credit cards to do Bitcoin mining.
We have plans but ultimately won't really know until we're in the thick of it.
Our plans though are to limit bandwidth and ban abusers.
We'll work with Stripe's Radar platform to reduce the stolen credit card fraud.
And, btw, I don't even own a CC.
The fact is in the early stage, this will help restrict fraud and bring in more engaged customers to ensure their expectations are met.
It's not something we plan to require forever.
For example, if you only had 2 compute hours, would it be enough for your evaluation?
I'm thinking we'll put something in place for free frictionless small evaluation after we think about fraud management a little bit.
Thanks for the feedback here everyone this is really invaluable!
I see that you worked on .Net at Microsoft, + supported languages at present are Python 2,3 and .Net Core.
So.... How different is this from Azure Functions? https://azure.microsoft.com/en-us/services/functions/
Cos I can create a Serverless API using Azure functions also, right? https://docs.microsoft.com/en-us/azure/azure-functions/funct...
This is the most common question! Other FaaS solutions require your code or your workflow to be structured in some way to fit in with their system, not to mention requiring you to use their tools.
Coherence integrates with the programming language to make it a lot simpler on the developer. Just pass a func and it's getting run. Structure your code however you like and use your favorite tools!
EDIT: One example, it's going to be a lot easier to run your web crawlers on Coherence.
EDIT 2: Yes I worked on .NET Core and am a python enthusiast for over 9 years. This is why they are the first supported languages.
I'm curious what your cold-start times are like (knowing that build sizes and languages affect that too). Also, any plans to support Go?
Our cold-start times have a way to go, they're around 1 minute on the first invocation of some set of binaries and less than 20 seconds on subsequent invocations.
We've done a lot more work on optimizing the subsequent invocations time, including even running a forked version of docker (it reduces docker save time by 100x or more)
This is a primary scenario for us though and there's a lot of room for further optimization. We'll be posting figures and progress regularly post-launch.
I missed some of your questions, we need to upload your project's binaries only (not package manager binaries). So languages with larger binary sizes will have longer cold start times. Overall this comes down to the factoring of the project though.
We should be able to support Go since the binary is static linked, but it has less portability than other managed languages so we've targetted those first as lower hanging fruit.