gofn - GitLite

KO | EN

gitlite — search

#javascript #python #hacktoberfest #golang #android #machine-learning #rust #macos #java #kubernetes #awesome-list #pytorch #mcp #openai

gofn

(★ 138)

Function process via docker provider (serverless minimalist)

File Explorer

Download Latest Version (.zip)

- - logo.png
- - main.go
  - README.md
- - main.go
- - main.go
  - README.md
- - main.go
- - main.go
  - README.md
- - main.go
- - main.go
- - amazonec2.go
  - amazonec2_test.go
- - digitalocean.go
  - digitalocean_test.go
- - google.go
  - google_test.go
- - tcp.go
  - tcp_test.go
- iaas.go
- - Dockerfile
  - main.py
- docker.go
- docker_integration_test.go
- docker_integration_unix_test.go
- docker_integration_windows_test.go
- docker_test.go
- docker_unix.go
- docker_unix_test.go
- docker_windows.go
- docker_windows_test.go
.codeclimate.yml
.gitignore
.travis.yml
gofn.go
gofn_test.go
LICENSE
Makefile
README.md
test.sh

# Installation Guide

1. Get the code

git clone https://github.com/gofn/gofn

Downloads the entire project code from GitHub to your computer.

cd gofn

Moves into the project folder you just downloaded.

2. Docker

Easy Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Docker Desktop Needed to build and run containers. Install it and keep it running in the background.

⚠️ This is a large repository, so this method may point to an internal sub-package rather than the actual core product. Check the full README as well.

docker build -f provision/testing_data/Dockerfile -t gofn .

Builds a runnable image based on the Dockerfile.

docker run -p 8080:80 gofn

Runs the built image as an actual container.

✅ Run docker compose ps to check the containers are Up. If the README mentions a port, open http://localhost:PORT in your browser.

3. Make

Medium

Prerequisites

Git Needed to download the project code from GitHub.
Make Usually pre-installed on Linux/macOS. On Windows, install separately (e.g. via MSYS2 or WSL).

make

Compiles the code based on the generated build configuration to produce an executable.

✅ If it finishes without errors, it worked. Try running the generated executable directly.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

![gofn](https://raw.githubusercontent.com/gofn/gofn/master/docs/assets/logo.png)

[![Build Status](https://travis-ci.org/gofn/gofn.svg?branch=master)](https://travis-ci.org/gofn/gofn)
[![GoDoc](https://godoc.org/github.com/gofn/gofn?status.png)](https://godoc.org/github.com/gofn/gofn)
[![Go Report Card](https://goreportcard.com/badge/github.com/gofn/gofn)](https://goreportcard.com/report/github.com/gofn/gofn)
[![codecov](https://codecov.io/gh/gofn/gofn/branch/master/graph/badge.svg)](https://codecov.io/gh/gofn/gofn)
[![Join the chat at https://gitter.im/gofn/gofn](https://badges.gitter.im/gofn/gofn.svg)](https://gitter.im/gofn/gofn?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Open Source Helpers](https://www.codetriage.com/nuveo/gofn/badges/users.svg)](https://www.codetriage.com/nuveo/gofn)

Function process via docker provider

## Install

```bash
go get github.com/gofn/gofn
```

## Example

```go
package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"os"
	"runtime"
	"sync"

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

func 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()
}

func 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 {
		key := os.Getenv("DIGITALOCEAN_API_KEY")
		if key == "" {
			log.Fatalln("You must provide an api key for digital ocean")
		}
		do, err := digitalocean.New(key)
		if err != nil {
			log.Println(err)
		}
		buildOpts.Iaas = do
	}

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

```bash
cd examples

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

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

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

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

# or run in digital ocean
export DIGITALOCEAN_API_KEY="paste your key here"
go run 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](https://docs.docker.com/engine/reference/commandline/build/#/git-repositories)

* 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.