Nanopack is a collection of libraries aimed at improving infrastructure development and management through a fundamentally different approach to building infrastructure components and services.
Libraries include:
- Yoke - Postgres high-availability cluster with auto-failover and automated cluster recovery.
- Redundis - Redis high-availability cluster using Sentinel to transparently proxy connections to the active primary member.
- Portal - An api-driven, in-kernel layer 2/3 load balancer.
- Logvac - Simple, lightweight, api-driven log aggregation service with realtime push capabilities and historical persistence.
- Hoarder - A simple, api-driven storage system for storing code builds and cached libraries for cloud-based deployment services.
- Shaman - Small, lightweight, api-driven dns server.
- Mist - A distributed, tag-based pub-sub service for modern web applications and container-driven cloud.
- more...
Snap — is an open telemetry framework designed to simplify the collection, processing and publishing of system data through a single API. The goals of this project are to:
- Empower systems to expose a consistent set of telemetry data
- Simplify telemetry ingestion across ubiquitous storage systems
- Allow flexible processing of telemetry data on agent (e.g. filtering and decoration)
- Provide powerful clustered control of telemetry workflows across small or large clusters
Gitql — is a Git query language.
Cayley — is an open-source graph inspired by the graph database behind Freebase and Google’s Knowledge Graph.
Its goal is to be a part of the developer’s toolbox where Linked Data and graph-shaped data (semantic webs, social networks, etc) in general are concerned.
Docker — is an open source project to pack, ship and run any application as a lightweight container.
Build Once. Ship Anywhere.
Kubernetes — is an open source system for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. Kubernetes is hosted by the Cloud Native Computing Foundation.
Kubernetes builds upon a decade and a half of experience at Google running production workloads at scale using a system called Borg, combined with best-of-breed ideas and practices from the community.
Nanobox — is a cross-platform micro-PaaS (μPaaS) that allows developers to focus on application development, rather than the complexities of infrastructure configuration and management.
Nanobox creates isolated development environments (using Docker) which are staged locally, and deployed anywhere. This guarantees parity of application environments across entire teams throughout the development lifecycle (dev, staging, production, etc.).
cobra — a library for creating powerful modern CLI applications as well as a program to generate applications and command files.
Hyperd — is a hypervisor-agnostic technology that allows you to run Docker images on plain hypervisor.
Terraform — is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions.
gago — genetic algorithm toolkit written in Go. The following example attempts to minimize the Drop-Wave function.
Hugo — a static HTML and CSS website generator written in Go. It is optimized for speed, easy use and configurability. Hugo takes a directory with content and templates and renders them into a full HTML website.
Gin — is a web framework written in Go. It features a martini-like API with much better performance, up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin.
gobot — a framework using the Go programming language for robotics, physical computing, and the Internet of Things.
utron — is a lightweight MVC framework in Go (Golang) for building fast, scalable and robust database-driven web applications.
Caddy — a general-purpose web server for Windows, Mac, Linux, BSD, and Android. It is a capable but easier alternative to other popular web servers.
gogs — Gogs (Go Git Service) is a painless self-hosted Git service.
tile38 — an open source, in-memory geolocation data store, spatial index, and realtime geofence. It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON.
logrus — a structured logger for Golang, completely API compatible with the standard library logger.
traefik — a modern HTTP reverse proxy and load balancer made to deploy microservices with ease. It supports several backends (Docker, Swarm, Kubernetes, Marathon, Mesos, Consul, Etcd, Zookeeper, BoltDB, Eureka, Rest API, file…) to manage its configuration automatically and dynamically.
dry — a terminal application to manage Docker containers and images. It aims to be an alternative to the official Docker CLI when it is needed to repeatedly execute commands on existing containers and images, and also as a tool to monitor Docker containers from a terminal.
pgweb — Web-based PostgreSQL database browser written in Go.
rkt — (pronounced "rock-it") is a CLI for running app containers on Linux. rkt is designed to be secure, composable, and standards-based.
Some of rkt's key features and goals include:
- Security: rkt is developed with a principle of "secure-by-default", and includes a number of important security features like support for SELinux, TPM measurement, and running app containers in hardware-isolated VMs.
- Composability: rkt is designed for first-class integration with init systems (systemd, upstart) and cluster orchestration tools (fleet, Kubernetes, Nomad), and supports swappable execution engines.
- Open standards and compatibility: rkt implements the appc specification, supports the Container Networking Interface specification, can also run Docker images, and OCI images via docker2aci. Native OCI image support is in development.
Distribution — The Docker toolset to pack, ship, store, and deliver content.
Flynn — is an open source Platform as a Service. Flynn is designed to run anything that can run on Linux, not just stateless web apps. Flynn comes with highly available database appliances, including PostgreSQL, MySQL, and MongoDB.
Convox Rack — is open source PaaS built on top of expert infrastructure automation and devops best practices.
Rack gives you a simple developer-focused API that lets you build, deploy, scale and manage apps on private infrastructure with ease.
GoReplay — is the simplest and safest way to test your app using real traffic before you put it into production.
As your application grows, the effort required to test it also grows exponentially. GoReplay offers you the simple idea of reusing your existing traffic for testing, which makes it incredibly powerful. Our state of art technique allows to analyze and record your application traffic without affecting it. This eliminates the risks that come with putting a third party component in the critical path.
Packer — is a tool for building identical machine images for multiple platforms from a single source configuration.
Packer is lightweight, runs on every major operating system, and is highly performant, creating machine images for multiple platforms in parallel. Packer comes out of the box with support for the following platforms:
- Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs
- Azure
- DigitalOcean
- Docker
- Google Compute Engine
- OpenStack
- Parallels
- QEMU. Both KVM and Xen images.
- VirtualBox
- VMware
Support for other platforms can be added via plugins.
fzf — is a general-purpose command-line fuzzy finder.
InfluxDB — is an open source time series database with no external dependencies. It's useful for recording metrics, events, and performing analytics.
Features
- Built-in HTTP API so you don't have to write any server side code to get up and running.
- Data can be tagged, allowing very flexible querying.
- SQL-like query language.
- Simple to install and manage, and fast to get data in and out.
- It aims to answer queries in real-time. That means every data point is indexed as it comes in and is immediately available in queries that should return in < 100ms.
Negroni. Idiomatic HTTP Middleware for Golang
Example:
package main
import (
"fmt"
"net/http"
"github.com/urfave/negroni"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the home page!")
})
n := negroni.Classic() // Includes some default middlewares
n.UseHandler(mux)
http.ListenAndServe(":3000", n)
}NSQ — is a realtime distributed messaging platform designed to operate at scale, handling billions of messages per day.
It promotes distributed and decentralized topologies without single points of failure, enabling fault tolerance and high availability coupled with a reliable message delivery guarantee. See features & guarantees.
Operationally, NSQ is easy to configure and deploy (all parameters are specified on the command line and compiled binaries have no runtime dependencies). For maximum flexibility, it is agnostic to data format (messages can be JSON, MsgPack, Protocol Buffers, or anything else). Official Go and Python libraries are available out of the box (as well as many other client libraries) and, if you're interested in building your own, there's a protocol spec.
Blackfriday — is a Markdown processor implemented in Go. It is paranoid about its input (so you can safely feed it user-supplied data), it is fast, it supports common extensions (tables, smart punctuation substitutions, etc.), and it is safe for all utf-8 (unicode) input.
HTML output is currently supported, along with Smartypants extensions. An experimental LaTeX output engine is also included.
IronFunctions — is an open source serverless platform, or as we like to refer to it, Functions as a Service (FaaS) platform that you can run anywhere.
Gizmo. Microservice Toolkit This toolkit provides packages to put together server and pubsub daemons with the following features:
- standardized configuration and logging
- health check endpoints with configurable strategies
- configuration for managing pprof endpoints and log levels
- structured logging containing basic request information
- useful metrics for endpoints
- graceful shutdowns
- basic interfaces to define our expectations and vocabulary
Grumpy — is a Python to Go source code transcompiler and runtime that is intended to be a near drop in replacement for CPython 2.7. The key difference is that it compiles Python source code to Go source code which is then compiled to native code, rather than to bytecode. This means that Grumpy has no VM. The compiled Go source code is a series of calls to the Grumpy runtime, a Go library serving a similar purpose to the Python C API (although the C API is not directly supported).
testify — a sacred extension to the standard go testing package.
Example:
package yours
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestSomething(t *testing.T) {
// assert equality
assert.Equal(t, 123, 123, "they should be equal")
// assert inequality
assert.NotEqual(t, 123, 456, "they should not be equal")
// assert for nil (good for errors)
assert.Nil(t, object)
// assert for not nil (good when you expect something)
if assert.NotNil(t, object) {
// now we know that object isn't nil, we are safe to make
// further assertions without causing any errors
assert.Equal(t, "Something", object.Value)
}
}Chisel — is a fast TCP tunnel, transported over HTTP. Single executable including both client and server. Written in Go (Golang). Chisel is mainly useful for passing through firewalls, though it can also be used to provide a secure endpoint into your network. Chisel is very similar to crowbar though achieves much higher performance. Warning Chisel is currently beta software.
chi — is a lightweight, idiomatic and composable router for building Go 1.7+ HTTP services. It's especially good at helping you write large REST API services that are kept maintainable as your project grows and changes. chi is built on the new context package introduced in Go 1.7 to handle signaling, cancelation and request-scoped values across a handler chain.
The focus of the project has been to seek out an elegant and comfortable design for writing REST API servers, written during the development of the Pressly API service that powers our public API service, which in turn powers all of our client-side applications.
The key considerations of chi's design are: project structure, maintainability, standard http handlers (stdlib-only), developer productivity, and deconstructing a large system into many small parts. The core router github.com/pressly/chi is quite small (less than 1000 LOC), but we've also included some useful/optional subpackages: middleware, render and docgen. We hope you enjoy it too!
go-callvis — a development tool to help visualize call graph of your Go program using Graphviz's dot format.
Purpose of this tool is to provide a visual overview of your program by using the data from call graph and its relations with packages and types. This is especially useful in larger projects where the complexity of the code rises or when you are just simply trying to understand code structure of somebody else.
fasthttp — is a fast HTTP implementation for Go.
SQLBoiler — SQLBoiler is a tool to generate a featureful and blazing-fast Go ORM with extensive relationship support, tailored specifically to your database schema. The SQLBoiler approach has conferred the following benefits, and more:
- ActiveRecord-like productivity: Eliminate all sql boilerplate, have relationships as a first-class concept.
- Go-like feel: Work with normal structs, call functions, no hyper-magical struct tags, small interfaces.
- Go-like performance: Benchmark and optimize the hot-paths, perform like hand-rolled sql.DB code.
- Type-safety: The models package is type safe. This means no chance of random panics due to passing in the wrong type. No need for interface{}.
- A system that is easy to debug. Your ORM is tailored to your schema, the code paths should be easy to trace since it's not all buried in reflect.
- Auto-completion provides work-flow efficiency gains.
SQLBoiler currently supports Postgres, MySQL and MSSQL, with plans for SQLite3 in the pipeline.
Tyk — is an open source, fast and scalable API management platform featuring an API gateway, API analytics, developer portal and API management dashboard.
