Expose your local endpoints to the Internet. #golang

Expose your local endpoints to the Internet. #golang

inlets combines a reverse proxy and websocket tunnels to expose your internal and development endpoints to the public Internet via an exit-node. An exit-node may be a 5-10 USD VPS or any other computer with an IPv4 IP address.

https://github.com/alexellis/inlets

Why do we need this project? Similar tools such as ngrok or Argo Tunnel from Cloudflare are closed-source, have limits built-in, can work out expensive and have limited support for arm/arm64. Ngrok is also often banned by corporate firewall policies meaning it can be unusable. Other open-source tunnel tools are designed to only set up a static tunnel. inlets aims to dynamically bind and discover your local services to DNS entries with automated TLS certificates to a public IP address over its websocket tunnel.

When combined with SSL – inlets can be used with any corporate HTTP proxy which supports CONNECT.

Share This:

A modern, scalable, secure open source and patent-free IoT cloud platform written in Go. #golang

Mainflux is modern, scalable, secure open source and patent-free IoT cloud platform written in Go.

It accepts user, device, and application connections over various network protocols (i.e. HTTP, MQTT, WebSocket, CoAP), thus making a seamless bridge between them. It is used as the IoT middleware for building complex IoT solutions.

Features

  • Multi-protocol connectivity and protocol bridging (HTTP, MQTT, WebSocket and CoAP)
  • Device management and provisioning
  • Fine-grained access control
  • Storage support (Cassandra, InfluxDB and MongoDB)
  • Platform logging and instrumentation support
  • Event sourcing
  • Container-based deployment using Docker and Kubernetes
  • LoRaWAN network integration
  • SDK
  • CLI
  • Small memory footprint and fast execution
  • Domain-driven design architecture, high-quality code and test coverage

Share This:

An open source multi-cloud control plane, written in #golang

https://github.com/crossplaneio/crossplane

Crossplane is an open source Golang written multi-cloud control plane. It introduces workload and resource abstractions on-top of existing managed services that enables a high degree of workload portability across cloud providers. A single cross-plane enables the provisioning and full-life-cycle management of services and infrastructure across a wide range of providers, offerings, vendors, regions, and clusters. Crossplane offers a universal API for cloud computing, a workload scheduler, and a set of smart controllers that can automate work across clouds.

Crossplane presents a declarative management style API that covers a wide range of portable abstractions including databases, message queues, buckets, data pipelines, serverless, clusters, and many more coming. It’s based on the declarative resource model of the popular Golang based Kubernetes project, and applies many of the lessons learned in container orchestration to multicloud workload and resource orchestration.

Crossplane supports a clean separation of concerns between developers and administrators. Developers define workloads without having to worry about implementation details, environment constraints, and policies. Administrators can define environment specifics, and policies. The separation of concern leads to a higher degree of re-usability and reduces complexity.

Crossplane includes a workload scheduler that can factor a number of criteria including capabilities, availability, reliability, cost, regions, and performance while deploying workloads and their resources. The scheduler works alongside specialized resource controllers to ensure policies set by administrators are honored.

https://crossplane.io/

Share This:

Open Source, Distributed, Simple and efficient full text search engine. #golang

Riot search is a Go Open Source, Distributed, Simple and efficient full text search engine.

https://github.com/go-ego/riot

Features

Share This:

A performance, secure and extensible api-gateway for enterprise. #golang

Juz is a new api-gateway designed for enterprise,mainly focus on performance,security and extensible, juz is totally opensource, and no premium edition.

https://github.com/mafanr/juz

When refered to traditional api-gateway, there are some problems:

  • Manageability
  • Performance
  • Features lacking
  • Need more on authority management
  • Monitoring

So, we developed a new one which has been used in our enterprise for two years, and it got widely praised. Now, you can also use it in your enviroment and enjoy its convenience.

Share This:

A pure #Golang implementation of the WebRTC Native AP

This project provides a Golang implementation of the WebRTC API.

https://github.com/pions/webrtc

What can I build with pion-WebRTC?

pion-WebRTC is here to help you get media/text from A<->B, here are some of the cool things you could build.

  • Send a video file to multiple browser in real time, perfectly synchronized movie watching.
  • Send a webcam on a small device to your browser, with no additional server required
  • Securely send data between two servers, without using pub/sub
  • Record your webcam and do special effects server side
  • Build a conferencing application that processes audio/video and make decisions off of it

Share This:

API Gateway and Management Platform enables you to control who accesses your API, when and how they access it. #golang

Tyk is a lightweight, open source API Gateway and Management Platform enables you to control who accesses your API, when they access it and how they access it. Tyk will also record detailed analytics on how your users are interacting with your API and when things go wrong. Written in Golang

https://github.com/TykTechnologies/tyk

What is an API Gateway?

An API Gateway sits in front of your application(s) and manages the heavy lifting of authorization, access control and throughput limiting to your services. Ideally, it should mean that you can focus on creating services instead of implementing management infrastructure. For example, if you have written a really awesome web service that provides geolocation data for all the cats in NYC, and you want to make it public, integrating an API gateway is a faster, more secure route than writing your own authorization middleware.

Key Features of Tyk

Tyk offers powerful, yet lightweight features that allow fine-grained control over your API ecosystem.

  • RESTFul API – Full programmatic access to the internals makes it easy to manage your API users, keys and Api Configuration from within your systems
  • Multiple access protocols – Out of the box, Tyk supports Token-based, HMAC Signed, Basic Auth and Keyless access methods
  • Rate Limiting – Easily rate limit your API users, rate limiting is granular and can be applied on a per-key basis
  • Quotas – Enforce usage quotas on users to manage capacity or charge for tiered access
  • Granular Access Control – Grant api access on a version by version basis, grant keys access to multiple API’s or just a single version
  • Key Expiry – Control how long keys are valid for
  • API Versioning – API Versions can be easily set and deprecated at a specific time and date
  • Blacklist/Whitelist/Ignored endpoint access – Enforce strict security models on a version-by-version basis to your access points
  • Analytics logging – Record detailed usage data on who is using your API’s (raw data only)
  • Webhooks – Trigger webhooks against events such as Quota Violations and Authentication failures
  • IP Whitelisting – Block access to non-trusted IP addresses for more secure interactions
  • Zero downtime restarts – Tyk configurations can be altered dynamically and the service restarted without affecting any active request

Tyk is written in Go, which makes it fast and easy to set up. Its only dependencies are a Mongo database (for analytics) and Redis, though it can be deployed without either (not recommended).

Share This:

A personal information dashboard for your terminal, developed in #golang

WTF is a personal information dashboard for your terminal, developed in #golang for those who spend most of their day in the command line.

https://wtfutil.com/

It provides a framework for rapidly viewing important at-a-glance information easily.

Keep an eye on your OpsGenie schedules, Google CalendarGit and Github repositories, and New Relicdeployments.

See who’s away in BambooHR, which Jira tickets are assigned to you, and what time it is in Barcelona.

It even has weather. And clocks. And emoji.

Share This:

Robust & Easy to use model mapper and utility methods for Go struct. #golang

go-model library provides handy methods to process struct with below highlighted features. It’s born from typical need while developing Go application or utility.

https://github.com/jeevatkm/go-model

  • Embedded/Anonymous struct
  • Multi-level nested struct/map/slice
  • Pointer and non-pointer within struct/map/slice
  • Struct within map and slice
  • Embedded/Anonymous struct fields appear in map at same level as represented by Go
  • Interface within struct/map/slice
  • Get struct field reflect.Kind by field name
  • Get all the struct field tags (reflect.StructTag) or selectively by field name
  • Get all reflect.StructField for given struct instance
  • Get or Set by individual field name on struct
  • Add global no traverse type to the list or use notraverse option in the struct field
  • Options to name map key, omit empty fields, and instruct not to traverse with struct/map/slice
  • Conversions between mixed non-pointer types – add custom conversation method, refer to usage

Share This:

Distributed, scalable, durable, and highly available orchestration engine in #golang from Uber

Cadence is a distributed, scalable, durable, and highly available orchestration engine developed in Golang at Uber Engineering to execute asynchronous long-running business logic in a scalable and resilient way.

https://github.com/uber/cadence

Business logic is modeled as workflows and activities. Workflows are the implementation of coordination logic. Its sole purpose is to orchestrate activity executions. Activities are the implementation of a particular task in the business logic. The workflow and activity implementation are hosted and executed in worker processes. These workers long-poll the Cadence server for tasks, execute the tasks by invoking either a workflow or activity implementation, and return the results of the task back to the Cadence server. Furthermore, the workers can be implemented as completely stateless services which in turn allows for unlimited horizontal scaling.

The Cadence server brokers and persists tasks and events generated during workflow execution, which provides certain scalability and reliability guarantees for workflow executions. An individual activity execution is not fault tolerant as it can fail for various reasons. But the workflow that defines in which order and how (location, input parameters, timeouts, etc.) activities are executed is guaranteed to continue execution under various failure conditions.

This repo contains the source code of the Cadence server. The client lib you can use to implement workflows, activities and worker can be found here.

Share This: