iron-io/functions

IronFunctions - the serverless microservices platform by

functions's Issues

How to run on Kubernetes

How to run on Docker Swarm

Emit Metrics to Logs

Using log format defined here: https://github.com/iron-io/logspout-statsd

Eg:

metric=someevent value=1 type=count
metric=somegauge value=50 type=gauge

Emit the following metrics (at least):

• wait time total (all apps)
• wait time per function
• execution time total (all apps)
• execution time per function
• function request count
• function error count
• cpu/memory per function ?

Getting this error all of a sudden: error="tx not writable"

Aug 30 00:24:54 0850e63e776b functions: time="2016-08-30T07:24:54Z" level=error msg="Could not list routes from datastore" action=server.handleSpecial
request_id=8db8390e-9442-5f7d-b1d4-bd25ea9f68b6

Add PORT env var to optionally change ports.

Implement in worker too: https://github.com/iron-io/worker/issues/339

Log function durations as metric

Per function memory requirements

Generate unique IDs for each run request

Required to prevent conflicts of creating two containers having the same name

Replace IronCache with another database (make datastore interface so it's swappable)

Bolt and Postgres would be good. Bolt for quick start, postgres for production and ability to scale.

Cache registry auth checks or better yet, only do it when adding a route

I see this before every execution: INFO[1021] Hitting registry to check image access permission. and it takes way too long.

Support query params

eg: http://chadsapp1.123.ironfunctions.com/hi?name=poop

How do we pass these into the container though? This would be a GET with no body. Perhaps we can use env vars for query params and headers?

Get rid of /api/ in the API path.

Allow setting content-type on a route, then use that when responding

Make "function tool" in ironcli

Say you make a directory for each function, the tool will go through each directory and check for changes, if changed, bump a version number (use the same type of script we use in release.sh? or check for a VERSION file and bump that), then run docker build, tag it with version, then docker push, then update route in IronFunctions.

Should think about some way to help with testing too, like build, then run tests against the container?

See: https://github.com/iron-io/functions/tree/master/tool

and/or build this into serverless framework?

How to run on DC/OS

Use STDERR for logging, STDOUT is the response.

Make function testing framework

Probably building off this: #13

It will build the function image, then run test(s) against it.

Async functions

First PR #97

This issue is for discussion and feedback on the functionality.

Remove datastore and config from context, turn them globals

How to run on Openstack

Should the input stream include a headers section, just like HTTP?

re: #71

Pros:

• more flexible
• multiple requests per invocation

Cons:

• bit more complicated for user, have to parse out the headers and what not

Note: can't be some json structure containing headers and payload, etc. since we can't stream that.

How to run on CloudFoundry

Dynamic routes: Can we optimize the route matching rather than pulling up all routes for an app?

This is tricky because of this: #71

ie: https://github.com/iron-io/functions/pull/74/files#diff-e180f07f5c320b82004c2bb065eedef0R99

The problem is we'd like to query for a single route, but let's say the route is defined as:

/blogs/:blog_id/comments/:comment_id

And a request comes in for:

/blogs/123/comments/456

How do we query the database for the route metadata with only that information? Could query for /blogs/123/comments/456, which is the static default way. But that wouldn't match. We could try all variations, eg /blogs/123/comments/* and /blogs/123/*/456, and /blogs/123/*/*, and so on, but that wouldn't be very efficient.

To summarize, the problem here is:

Given a path and only a path, eg: /blogs/travisblog/comments/123 what should you query for? Not knowing what routes exist before hand.

Wait for capacity if no RAM left on server and log wait time as metric to logs

Share memory checking functions from Titan.

If queue of requests get too big (100?), start returning 503's.

ALWAYS log the wait time, even if it's zero.

Make swagger yaml for API

Add current API endpoints + what we need:

• delete route
• get all routes for an app
• ???

Switch to gin from gorilla for http server.

Docs and example of autoscaling

Collect some metrics (function wait time probably good?) from logs then launch new server(s) based on that. Use something like Kubernetes or operator to keep it simple. Needs to be added to load balancer automatically too.

Let user specify a syslog URL to output all logs for an app too

Response on create app should use app wrapper

Currently returns:

✗ curl -H "Content-Type: application/json" -X POST -d '{
quote>     "app": { "name":"myapp5" }
quote> }' http://functions.iron.io/v1/apps
{"name":"myapp5"}

Return the "app" wrapper, same as the input. And also add a "message" or "msg" that says "App created successfully".

Support for params in route paths

eg: /r/myapp/somethings/:something_id/comments/:comment_id => PARAM_SOMETHING_ID=X and PARAM_COMMENT_ID=Y

Also add METHOD=GET/POST env vars.

re: #56

[WIP] CRON like scheduling / scheduler

Triggers functions on a repeating schedule.

Use new input format discussed recently and probably CRON format as well.

---

Proposal for cron support

Basic architecture sketch for each IronFunctions node:

                 ┌────────┐
     ┌──────────▶│D. Lock │
     │           └────────┘
     │
┌────────┐       ┌────────┐
│  Cron  │──────▶│   DB   │◀─────────────┐
└────────┘       └────────┘              │
     │                                   │
     │           ┌────────┐         ┌────────┐
     └──────────▶│   MQ   │◀────────│  HTTP  │
                 └────────┘         └────────┘
                      ▲                  │
                      │                  │
                      │                  ▼
                 ┌────────┐         ┌────────┐
                 │ Async  │         │  Sync  │
                 └────────┘         └────────┘

The two additional components are:

D. Lock is a some sort of distributed lock offered by latest versions of etcd
and Consul. In theory, any distributed lock would be enough in order to achieve
the necessary role in this design.

Cron is a gear similar to async. It enqueues a cron job while holding a
distributed mutex lock. Its implementation would be similar to the following:

lock()
jobs := cronjobs()
for _, job := range jobs {
	ls := laststart(j)
	if job.shouldRunAfter(ls) {
		ls.touch()
		enqueue(j)
	}
}
unlock()

In the DB, the new datastructure would be:

[{
	"id": "...",
	"function": {
		"app": "app",
		"path": "/fn",
		"headers": ["Context-Type: application/json"],
		"body": "....",
	}
	"frequency": "*/10 * * * *"
}, ...]

id is a unique identifier for the cronjob. It aims to allow repeated entries
for a same given function.

function is the description of the function to be ran. It will mimic a HTTP
POST call with headers and body. It also adds a User-Agent with the
specific information that this call is made by the cron worker.

frequency is a crond-like string that specifies when should this cronjob be
ran.

Restricting the distributed lock to etcd/consul and alikes, it means they can
also be used as an authoritative key-value source of truth regarding the last
execution.

laststart in the example code above, is the last time this cronjob was started,
regardless of success or failure.

Check if image exists when registering the route, not at run time

Allow env vars for config on the app and routes (routes override apps).

Also headers for responses.

eg:

curl -H "Content-Type: application/json" -X POST -d '{
  "path":"/guppy",
  "image":"treeder/guppy:0.0.2",
  "config": {"DB_URL": "abc"},
  "response_headers": {"Content-Type": "application/json"}
}' http://localhost:8080/v1/apps/myapp/routes

Set timeout (max 60 seconds) for every function call

Reuse Titan code.

Pass in request URL as REQUEST_URL env var

So code can access query params .

Provide a really simple way to setup a load balancer for this

Could use the obvious like nginx or HAProxy, but it might be nice to use and contribute to a Go one. Maybe Traefik, Vulcand or Caddy.

Test suite to test API

Builds the image, starts the API, then:

• Test all API endpoints
• Tests some routes, such as hello world one and checks to see that response is valid (headers and body)
• Test an error route (iron/error image is a container that just errors out, good for testing). Ensure error status code.

Long(er) running containers for better performance aka Hot Containers

Instead of one off execution, keep container running for a while and take requests.

The first version executes a container per function call/request. Which is fine for many things, but we may want a way to run for longer periods of time to increase performance due to things like keeping db connections open, etc.

This would probably require a more lambda like code format and language libraries. See https://github.com/iron-io/lambda for existing work on lambda style code format.

I created a prototype of this years ago that routed traffic into IronWorker containers, should dig that out and look into that implementation.

Provide a base url for each app, eg: appname.userid.iron.computer

Send metrics into logs using standard metrics format

Change PAYLOAD input to STDIN

Should apply to both IronWorker and Functions.

See IronWorker issue: https://github.com/iron-io/titan/issues/297

• Implement the change
• Update ALL examples to use STDIN (both functions and Titan)

New Postgres bugs

There was this one: 662216f

And now I get this one after that fix:

RRO[0086] Could not create app                          action=server.handleAppCreate error=pq: column "config" of relation "apps" does not exist

@pedronasser looks like you may have broken this with your config changes. Can you please fix, thanks.

Docs/example/demo of forking a function, changing it (hello your name), then pushing to docker hub, adding a route for it, viewing URL to see change

Full App/Microservice example

An example that builds a full API with multiple endpoints, authentication, etc.

Take a blog example or something and build it using IronFunctions.

• GET /posts returns list of posts
• POST /posts adds a new post and stores it in a database (a database that requires auth like a postgres database hosted on heroku or something). Requires authentication (JWT token in header).
• GET /posts/:id returns a full post.

Get rid of these errors in the logs or deal with them better so they aren't errors

ERRO[0456] error streaming docker stats for task         container=task-a790dc09-7149-58eb-b8ef-bdc1571ad2c5 error=io: read/write on closed pipe task_id=a790dc09-7149-58eb-b8ef-bdc1571ad2c5
ERRO[0459] Handler for POST /containers/task-a790dc09-7149-58eb-b8ef-bdc1571ad2c5/stop returned error: Container task-a790dc09-7149-58eb-b8ef-bdc1571ad2c5 is already stopped

The function appears to execute and respond just fine, but these errors show up every time.

Setup CircleCI

Similar to Titan.

Make a bunch of examples

• Serverless Slackbot (see guppy pull request in treeder/slackbots), could convert all the ones from my serverless slackbot posts too
• Update a database
• Check API's and return results, twitter maybe?
• Microservice without the servers: https://aws.amazon.com/blogs/compute/microservices-without-the-servers/
• How about a webpage app too? single page app would be good

Document route parameters

in README and README.io docs. See: #71

For STDERR logging, use this format

Take STDERR from runner containers and add app_name, path, function, request_id and put the actual log line in msg. If using logrus, it will automatically use msg.

Switch to Titan Docker execution