gofn/gofn

Name: gofn

Owner: gofn

Description: Function process via container provider (serverless minimalist)

Created: 2016-11-30 17:14:40.0

Updated: 2018-01-16 22:46:47.0

Pushed: 2018-01-03 20:16:50.0

Homepage:

Size: 1450

Language: Go

GitHub Committers

User	Most Recent Commit	# Commits

Other Committers

User	Email	Most Recent Commit	# Commits

README

Function process via container provider

Premise

• Software makes a task
• After processing it dies
• Must put on stdout (print)

Install

et github.com/gofn/gofn

Example

age main

rt (
"context"
"flag"
"fmt"
"log"
"runtime"
"sync"

"github.com/gofn/gofn"
"github.com/gofn/gofn/iaas/digitalocean"
"github.com/gofn/gofn/provision"


 main() {
wait := &sync.WaitGroup{}
contextDir := flag.String("contextDir", "./", "a string")
dockerfile := flag.String("dockerfile", "Dockerfile", "a string")
imageName := flag.String("imageName", "", "a string")
remoteBuildURI := flag.String("remoteBuildURI", "", "a string")
volumeSource := flag.String("volumeSource", "", "a string")
volumeDestination := flag.String("volumeDestination", "", "a string")
remoteBuild := flag.Bool("remoteBuild", false, "true or false")
input := flag.String("input", "", "a string")
flag.Parse()
parallels := runtime.GOMAXPROCS(-1) // use max allowed CPUs to parallelize
wait.Add(parallels)
for i := 0; i < parallels; i++ {
    go run(*contextDir, *dockerfile, *imageName, *remoteBuildURI, *volumeSource, *volumeDestination, wait, *remoteBuild, *input)
}
wait.Wait()


 run(contextDir, dockerfile, imageName, remoteBuildURI, volumeSource, volumeDestination string, wait *sync.WaitGroup, remote bool, input string) {
buildOpts := &provision.BuildOptions{
    ContextDir: contextDir,
    Dockerfile: dockerfile,
    ImageName:  imageName,
    RemoteURI:  remoteBuildURI,
    StdIN:      input,
}
containerOpts := &provision.ContainerOptions{}
if volumeSource != "" {
    if volumeDestination == "" {
        volumeDestination = volumeSource
    }
    containerOpts.Volumes = []string{fmt.Sprintf("%s:%s", volumeSource, volumeDestination)}
}
if remote {
    buildOpts.Iaas = &digitalocean.Digitalocean{}
}

defer wait.Done()
stdout, stderr, err := gofn.Run(context.Background(), buildOpts, containerOpts)
if err != nil {
    log.Println(err)
}
fmt.Println("Stderr: ", stderr)
fmt.Println("Stdout: ", stdout)

Run Example

xamples

un main.go -contextDir=testDocker -imageName=python -dockerfile=Dockerfile

 using volume
un main.go -contextDir=testDocker -imageName=python -dockerfile=Dockerfile -volumeSource=/tmp -volumeDestination=/tmp

 using remote Dockerfile
un main.go -remoteBuildURI=https://github.com/gofn/dockerfile-python-example.git -imageName="pythonexample"

u can also send a string that will be written to the stdin of the container
un main.go -contextDir=testDocker -imageName=python -dockerfile=Dockerfile -input "input string"

 run in digital ocean
rt DIGITALOCEAN_API_KEY="paste your key here"
un main.go -contextDir=testDocker -imageName=python -dockerfile=Dockerfile -remoteBuild=true

You can also compile with go build or build and install with go install command then run it as a native executable.

Example Parameters

• -contextDir is the root directory where the Dockerfile, scripts, and other container dependencies are, by default current directory “./“.

• -imageName is the name of the image you want to start, if it does not exist it will be automatically generated and if it exists the system will just start the container.

• -dockerFile is the name of the file containing the container settings, by default Dockerfile

• -volumeSource is the directory that will be mounted as a data volume. By default is empty string indicating his not used.

• -volumeDestination is the path mounted inside the container. By default is empty string indicating his not used but if only omitted, volumeSource is used.

• -remoteBuildURI is remote URI containing the Dockerfile to build.By default is empty. More details on docker api docs

• remoteBuild is a boolean that indicates if have to run localally or in a machine in digital ocean Don't forget to export your api key.

• -input is a string that will be written to the stdin of the container

• -h Shows the list of parameters

gofn generates the images with “gofn/” as a prefix.