Apex is a small tool for deploying and managing AWS Lambda functions. With shims for languages not yet supported by Lambda, you can use Golang out of the box.

Installation

Download binaries:

latest=$(curl -s https://api.github.com/repos/apex/apex/tags | grep name | head -n 1 | sed 's/[," ]//g' | cut -d ':' -f 2)
curl -sL https://github.com/apex/apex/releases/download/$latest/apex_darwin_amd64 -o /usr/local/bin/apex
chmod +x $_

Or from master:

go get github.com/apex/apex/cmd/apex

Or upgrading:

apex upgrade

Runtimes

Currently supports:

• Nodejs
• Golang
• Python

Features

• Supports languages Lambda does not natively support via shim, such as Go
• Binary install (useful for continuous deployment in CI etc)
• Hook support for running commands (transpile code, lint, etc)
• Project level function and resource management
• Configuration inheritance and overrides
• Command-line function invocation with JSON streams
• Transparently generates a zip for your deploy
• Ignore deploying files with .apexignore
• Function rollback support
• Tail function CloudWatchLogs
• Concurrency for quick deploys
• Dry-run to preview changes

Example

Apex projects are made up of a project.json configuration file, and zero or more Lambda functions defined in the "functions" directory. Here's an example file structure:

project.json
functions
├── bar
│   ├── function.json
│   └── index.js
├── baz
│   ├── function.json
│   └── index.js
└── foo
    ├── function.json
    └── index.js

The project.json file defines project level configuration that applies to all functions, and defines dependencies. For this simple example the following will do:

{
  "name": "example",
  "description": "Example project"
}

Each function uses a function.json configuration file to define function-specific properties such as the runtime, amount of memory allocated, and timeout. This file is completely optional, as you can specify defaults in your project.json file. For example:

{
  "name": "bar",
  "description": "Node.js example function",
  "runtime": "nodejs",
  "memory": 128,
  "timeout": 5,
  "role": "arn:aws:iam::293503197324:role/lambda"
}

Now the directory structure for your project would be:

project.json
functions
├── bar
│   └── index.js
├── baz
│   └── index.js
└── foo
    └── index.js

Finally the source for the functions themselves look like this in Node.js:

console.log('start bar')
exports.handle = function(e, ctx) {
  ctx.succeed({ hello: 'bar' })
}

Or using the Golang Lambda package, Apex supports Golang out of the box with a Node.js shim:

package main

import (
  "encoding/json"

  "github.com/apex/go-apex"
)

type Message struct {
  Hello string `json:"hello"`
}

func main() {
  apex.HandleFunc(func(event json.RawMessage, ctx *apex.Context) (interface{}, error) {
    return &Message{"baz"}, nil
  })
}

Apex operates at the project level, but many commands allow you to specify specific functions. For example you may deploy the entire project with a single command:

$ apex deploy

Or whitelist functions to deploy:

$ apex deploy foo bar

Invoke it!

$ echo '{ "some": "data" }' | apex invoke foo
{ "hello": "foo" }

See the Documentation for more information.

Links

• Project Examples with source

Contributors

• TJ Holowaychuk
• Maciej Winnicki
• Pilwon Huh
• Faraz Fazli
• Johannes Boyne

Badges

---

tjholowaychuk.com  ·  GitHub @tj  ·  Twitter @tjholowaychuk