Netflix has open sourced his container management system called Titus written in Go Lang. You can see documentation of it here:

- https://netflix.github.io/titus/

Source code and Docs:

- https://github.com/Netflix/titus

#container_orchestration #docker #container #golang #go #netflix #titus #aws

https://ewanvalentine.io/microservices-in-golang-part-1/

#go #golang #microservice #docker #kubernetes #consul

How I store & manage passwords in Linux for servers and other credentials? gopass

Password management should be simple and follow Unix philosophy. With pass, each secret lives inside of a gpg encrypted file whose filename is the title of the website or resource that requires the secret. These encrypted files may be organized into meaningful folder hierarchies, copied from computer to computer, and, in general, manipulated using standard command line file management utilities.

gopass is a rewrite of the pass password manager in Go with the aim of making it cross-platform and adding additional features. Our target audience are professional developers and sysadmins (and especially teams of those) who are well versed with a command line interface. One explicit goal for this project is to make it more approachable to non-technical users. We go by the UNIX philosophy and try to do one thing and do it well, providing a stellar user experience and a sane, simple interface:

- https://github.com/gopasspw/gopass

#unix #linux #sysadmin #pass #gopass #password_management #golang #github

https://micro.mu/blog/

#golang #go #microservice #framework #micro #gomicro #blog

https://github.com/golang/go/wiki/Learn

#go #golang #wiki #learn

https://medium.com/rungo

#golang #go #tutorial #blog

https://github.com/micro/examples/blob/master/service/main.go

#golang #grpc #protobuf #consul #mdns #gomicro #github

golang practical programming course:

https://www.youtube.com/watch?v=G3PvTWRIhZA&list=PLQVvvaa0QuDeF3hP0wQoSxpkqgRcgxMqX

#golang #course #youtube

os.Rename in goLang?

Function signature:

func Rename(oldpath, newpath string) error

What Rename does?

Rename renames (moves) oldpath to newpath. If newpath already exists and is not a directory, Rename replaces it. OS-specific restrictions may apply when oldpath and newpath are in different directories. If there is an error, it will be of type *LinkError.

#golang #go #os #rename #os_rename

As you may already know in Python you can format your string using format as below:

file_name = "/root/openvpn/{}.ovpn".format(my_file_name)
// Or
file_name = "/root/openvpn/%s.ovpn" % my_file_name

In golang you need to use Sprintf method of fmt package like follow:

var fileName = fmt.Sprintf("/root/openvpn/%s.ovpn", myFileName)

#python #golang #go #fmt #sprintf #format

inheritance in Golang:

- https://golangbot.com/inheritance/

#golang #go #inheritance #struct

One of the best loggers in Golang:

- https://github.com/sirupsen/logrus

#golang #go #logrus

environments in Golang:

To set a key/value pair, use os.Setenv. To get a value for a key, use os.Getenv. This will return an empty string if the key isn’t present in the environment.

Use os.Environ to list all key/value pairs in the environment. This returns a slice of strings in the form KEY=value. You can strings.Split them to get the key and value. Here we print all the keys:

package main

import (
        "os"
        "strings"
        "fmt"
)

func main() {
    os.Setenv("FOO", "1")
    fmt.Println("FOO:", os.Getenv("FOO"))
    fmt.Println("BAR:", os.Getenv("BAR"))

    fmt.Println()
    for _, e := range os.Environ() {
        pair := strings.Split(e, "=")
        fmt.Println(pair[0])
    }
}

#golang #go #env #environment #environment_variables #range #setenv #getenv #environ

If you want to implement "Python Capitalize" method in Go:

strings.Title(strings.ToLower("MYNAME")) // output: Myname

There is another method called ToTitle which is used for one character long (but to letters):

str := "dz"
fmt.Println(strings.ToTitle(str)) // output: Dz

#python #golang #go #ToLower #Title #strings #capitalize #ToTitle

How to block forever in Go?

- https://blog.sgmansfield.com/2016/06/how-to-block-forever-in-go/

#golang #go #sync #block

A very great talk by Brian Ketelsen about microservices using go-micro:

- https://www.youtube.com/watch?v=OcjMi9cXItY

#youtube #golang #go #microservice #gomicro #micro

A very great article about Go styling and how to code readble, maintainable code in Go (it can be used in other languages too):

- https://dave.cheney.net/practical-go/presentations/qcon-china.html#_always_document_public_symbols

#golang #go #maintainable #readble_code

Let's talk a little bit about WaitGroup in sync library. First things first, the documentation is here:
- https://golang.org/pkg/sync/#WaitGroup

A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. Then each of the goroutines runs and calls Done when finished. At the same time, Wait can be used to block until all goroutines have finished.

With an example it will be crystal clear. Let's say we have a script that fetches URLs concurrently and we want to wait using WaitGroup until all the fetches are complete:

package main

import (
        "sync"
)

type httpPkg struct{}

func (httpPkg) Get(url string) {}

var http httpPkg

func main() {
        var wg sync.WaitGroup
        var urls = []string{
                "http://www.golang.org/",
                "http://www.google.com/",
                "http://www.somestupidname.com/",
        }
        for _, url := range urls {
                // Increment the WaitGroup counter.
                wg.Add(1) 
                // Launch a goroutine to fetch the URL.
                go func(url string) {
                        // Decrement the counter when the goroutine completes.
                        defer wg.Done()
                        // Fetch the URL.
                        http.Get(url)
                }(url)
        }
        // Wait for all HTTP fetches to complete.
        wg.Wait()
}

First we create a WaitGroup called wg and using range loop through the URLs on each iterration we use Add to increment WaitGroup counter/queue and run an anonymous function that gets a URL. When func i
s done getting the URL, defer will be run and Done decrement the counter in WaitGroup. Finally we use Wait to actually wait for all http calls to get completed.

NOTE: anonymous function is preceded with go keyword that runs the function concurrently.

#golang #go #sync #WaitGroup #Done #Add #Wait

GJSON is a Go package that provides a fast and simple way to get values from a json document. It has features such as one line retrieval, dot notation paths, iteration, and parsing json lines.

Las mere:
https://github.com/tidwall/gjson

#golang #go #gjson