12 Indispensable Go Paquetes y Librerías

Spanish (Español) translation by James (you can also view the original English article)

Go es un lenguaje asombroso con mucho ímpetu, y se centra en la simplicidad. Este enfoque es evidente en su biblioteca estándar, que proporciona todo lo necesario, pero no mucho más.

Afortunadamente, Go tiene una vibrante comunidad que crea y comparte un montón de librerías de terceros. En este tutorial, te introduzco a 12 de Go mejores paquetes y bibliotecas. Algunas de ellas tienen alcance relativamente estrecho y pueden agregarse a cualquier proyecto, mientras que otros son grandes proyectos que usted puede incorporar en sistemas distribuidos a gran escala, masivos.

Awesome Go

Antes de zambullirse en las bibliotecas de sí mismos, permítanme presentarles a Awesome Go, una lista muy activa y curada de Go bibliotecas y otros recursos. Debe visitar de vez en cuando y comprobar lo nuevo.

1. Set de Golang

Go tiene arreglos de discos, láminas y mapas, pero no tiene una estructura de datos del sistema. Puede imitar un conjunto con un mapa de bools, pero es bueno tener un tipo de datos reales con las operaciones de derecha y semántica. Esto es donde golang-set. Aquí es un ejemplo básico de crear un nuevo conjunto, agregar elementos y pruebas para ser miembro:

package main

import (
    "fmt"
  "github.com/deckarep/golang-set"
)


func main() {
	basicColors := mapset.NewSet()
	basicColors.Add("Red")
	basicColors.Add("Blue")
	basicColors.Add("Green")

	if basicColors.Contains("Green") {
		fmt.Println("Yay! 'Green' is a basic color")
	} else {
		fmt.Println("What a disappointment! 'Green' is not a basic color")
	}


	if basicColors.Contains("Yellow") {
		fmt.Println("Yay! 'Yellow' is a basic color")
	} else {
		fmt.Println("What a disappointment! 'Yellow' is not a basic color")
	}
}

Output:

Yay! 'Green' is a basic color
What a disappointment! 'Yellow' is not a basic color

Observe que el nombre del paquete es "mapset". Además de lo básico, es realizar todos las operaciones Unión, intersección y diferencia. Usted también puede iterar sobre los valores:

package main

import (
    "fmt"
	"github.com/deckarep/golang-set"
)


func main() {
	basicColors := mapset.NewSet()
	basicColors.Add("Red")
	basicColors.Add("Blue")
	basicColors.Add("Green")

	otherColors := mapset.NewSetFromSlice([]interface{}{"Orange", "Yellow", "Indigo", "Violet"})
	rainbowColors := basicColors.Union(otherColors)

	for color := range rainbowColors.Iterator().C {
		fmt.Println(color)
	}
}

2. Color

Continuemos con el tema de color. Al escribir programas de línea de comandos, es útil utilizar colores para destacar mensajes importantes o distinguir entre errores, éxitos y advertencias.

El paquete de color da una manera fácil de añadir color a sus programas (ver lo que hice allí?). ¡Utiliza códigos de escape ANSII y soporta Windows también! Aquí está un ejemplo rápido:

package main

import (
    "github.com/fatih/color"
)

func main() {
	color.Red("Roses are red")
	color.Blue("Violets are blue")
}

Las ayudas del paquete de color mezclando colores con los colores de fondo, estilos como negrita o cursiva y riego color con salida sin color.

package main

import (
    "github.com/fatih/color"
	"fmt"
)

func main() {
	minion := color.New(color.FgBlack).Add(color.BgYellow).Add(color.Bold)
	minion.Println("Minion says: banana!!!!!!")

	m := minion.PrintlnFunc()
	m("I want another banana!!!!!")

	slantedRed := color.New(color.FgRed, color.BgWhite, color.Italic).SprintFunc()
	fmt.Println("I've made a huge", slantedRed("mistake"))
}

El paquete de color tiene otras características útiles. Seguir adelante y explorar más.

3. Now

Now es un paquete muy simple que proporciona un contenedor de comodidad para el paquete de tiempo estándar y facilita trabajar con varias construcciones de fecha y hora en la época actual.

Por ejemplo, puede llegar el principio del minuto actual o al final del domingo más cercano a la hora actual. Aquí es cómo utilizar "Now":

package main

import (
    "github.com/jinzhu/now"
	"fmt"
)

func main() {

	fmt.Println("All the beginnings...")
	fmt.Println(now.BeginningOfMinute())
	fmt.Println(now.BeginningOfHour())
	fmt.Println(now.BeginningOfDay())
	fmt.Println(now.BeginningOfWeek())
	fmt.Println(now.BeginningOfMonth())
	fmt.Println(now.BeginningOfQuarter())
	fmt.Println(now.BeginningOfYear())

}

Output:

All the beginnings...
2017-06-04 16:59:00 -0700 PDT
2017-06-04 16:00:00 -0700 PDT
2017-06-04 00:00:00 -0700 PDT
2017-06-04 00:00:00 -0700 PDT
2017-06-01 00:00:00 -0700 PDT
2017-04-01 00:00:00 -0700 PDT
2016-12-31 23:00:00 -0800 PST

Puede también analizar tiempos y añadir sus propios formatos (que serán necesario actualizar los formatos conocidos). El tipo Now incorpora time.Time, así que puede usar métodos time.Time de tiempo directamente en objetos de Now.

4. Gen

La herramienta gen genera código para usted, en particular, que tipo de código que intenta paliar el vacío de no tener plantillas o genéricos en Go.

Anota los tipos con un comentario especial, y gen genera archivos de origen que se incluyen en el proyecto. No hay magia de tiempo de ejecución. Veamos un ejemplo. Aquí es un tipo de anotación.

// +gen slice:"Where,Count,GroupBy[int]"
type Person struct {
    Name string
	Age int
}

Ejecutando gen (Asegúrese de que esté en tu camino) genera person_slice.go:

// Generated by: gen
// TypeWriter: slice
// Directive: +gen on Person

package main

// PersonSlice is a slice of type Person. Use it where you would use []Person.
type PersonSlice []Person

// Where returns a new PersonSlice whose elements return true for func. See: https://clipperhouse.github.io/gen/#Where
func (rcv PersonSlice) Where(fn func(Person) bool) (result PersonSlice) {
    for _, v := range rcv {
		if fn(v) {
			result = append(result, v)
		}
	}
	return result
}

// Count gives the number elements of PersonSlice that return true for the passed func. See: http://clipperhouse.github.io/gen/#Count
func (rcv PersonSlice) Count(fn func(Person) bool) (result int) {
	for _, v := range rcv {
		if fn(v) {
			result++
		}
	}
	return
}

// GroupByInt groups elements into a map keyed by int. See: http://clipperhouse.github.io/gen/#GroupBy
func (rcv PersonSlice) GroupByInt(fn func(Person) int) map[int]PersonSlice {
	result := make(map[int]PersonSlice)
	for _, v := range rcv {
		key := fn(v)
		result[key] = append(result[key], v)
	}
	return result
}

El código proporciona LINQ-like métodos para operar en el tipo de PersonSlice. Es fácil de entender y muy bien documentado.

Aquí es cómo usarlo. En la función principal, se define un PersonSlice. La función age() selecciona el campo de la edad de su argumento Person. La función GroupByInt() genera la función age() y vuelve la gente de la rebanada agrupada por su edad (34 es a Jim, pero 23 tiene Jane y Kyle).

package main

import (
    "fmt"
)

// +gen slice:"Where,Count,GroupBy[int]"
type Person struct {
	Name string
	Age int
}

func age(p Person) int {
	return p.Age
}

func main() {
	people := PersonSlice {
		{"Jim", 34},
		{"Jane", 23},
		{"Kyle", 23},
	}

	groupedByAge := people.GroupByInt(age)

	fmt.Println(groupedByAge)
}


Output:

map[34:[{Jim 34}] 23:[{Jane 23} {Kyle 23}]]

5. Gorm

Go es conocido por su carácter espartano. Programación de base de datos no es diferente. Las bibliotecas más populares de DB para ir son bastante bajo nivel. Gorm trae el mundo de Mapeo objeto-relacional para Go con las siguientes características:

Asociaciones (tiene uno, tiene muchos, pertenece, muchos a muchos, polimorfismo)
Devoluciones de llamada (antes y después de crear/guardar/actualizar/borrar/buscar)
Precarga (ansioso por carga)
Transacciones
Clave Primaria Compuesta
Constructor SQL
Migraciones Automatica
Registrador
Extensible, escribir Plugins basado en callbacks GORM

Pero no cubre todo. Si vienes desde Python, no esperes magia SQLAlchemy. Para más cosas de lujo, usted tendrá que ir un nivel más bajo. Aquí es un ejemplo de cómo usar Gorm con sqlite. Tenga en cuenta el gorm.Model incrustada en la estructura del producto.

package main

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
  gorm.Model
  Code string
  Price uint
}

func main() {
  db, err := gorm.Open("sqlite3", "test.db")
  if err != nil {
    panic("failed to connect database")
  }
  defer db.Close()

  // Migrate the schema
  db.AutoMigrate(&Product{})

  // Create
  db.Create(&Product{Code: "L1212", Price: 1000})

  // Read
  var product Product
  db.First(&product, 1) // find product with id 1
  db.First(&product, "code = ?", "L1212")

  // Update - update product's price to 2000
  db.Model(&product).Update("Price", 2000)

  // Delete - delete product
  db.Delete(&product)

6. Goose

Una de las tareas más importantes cuando se trabaja con bases de datos relacionales es administrar el esquema. Modificando el esquema de DB se considera un cambio de "miedo" en algunas organizaciones. El paquete de Goose le permite realizar cambios de esquema y migraciones de datos incluso si es necesario. Puede goose up y goose down para ir hacia adelante y hacia atrás. Mente sus datos y asegúrese de que no Haz perdido o dañado.

Ganso obras de control de versiones el esquema y utilizando archivos de migración correspondientes a cada esquema. Los archivos de migración pueden ser comandos SQL o comandos Go. Este es un ejemplo de un archivo de migración de SQL que agrega una nueva tabla:

-- +goose Up
CREATE TABLE person (
    id int NOT NULL,
    name text,
    age int,
    PRIMARY KEY(id)
);

-- +goose Down
DROP TABLE person;

El -- +goose up y -- +goose down comentarios dicen goose qué hacer para mejorar o degradar el esquema.

7. Glide

Glide es un gestor de paquetes para ir. Bajo una sola GOPATH, pueden tener muchos programas que tienen dependencias contradictorias. La solución es que cada programa de administrar su propio directorio de proveedores de las dependencias del paquete. Glide ayuda con esta tarea.

Aquí están las características de Glide:

Soporte de paquetes de control de versiones incluyendo soporte semántico versión 2.0.0.
Soporte paquetes de aliasing (por ejemplo, para trabajar con horquillas de github).
Eliminar la necesidad de que las declaraciones de importación de descripciones.
Trabajar con todas las herramientas de Go.
Soporte todas las herramientas de VCS que Go apoya (git, bzr, hectogramo, svn).
Soporte custom plugins locales y globales.
Repositorio de almacenamiento en caché y caché de datos para mejorar el rendimiento.
Aplane las dependencias, las diferencias de versión y evitando la inclusión de un paquete varias veces.
Gestionar e instalar dependencias bajo demanda o vendored en su sistema de control de versión.

Las dependencias se almacenan en glide.yaml, y planeo proporciona varios comandos para manejar las dependencias:

     create, init       Initialize a new project, creating a 
                        glide.yaml file
     config-wizard, cw  Wizard that makes optional suggestions 
                        to improve config in a glide.yaml file.
     get                Install one or more packages into 
                        `vendor/` and add dependency to 
                        glide.yaml.
     remove, rm         Remove a package from the glide.yaml 
                        file, and regenerate the lock file.
     import             Import files from other dependency 
                        management systems.
     name               Print the name of this project.
     novendor, nv       List all non-vendor paths in a 
                        directory.
     rebuild            Rebuild ('go build') the dependencies
     install, i         Install a project's dependencies
     update, up         Update a project's dependencies
     tree               (Deprecated) Tree prints the 
                        dependencies of this project as a tree.
     list               List prints all dependencies that the 
                        present code references.
     info               Info prints information about this 
                        project
     cache-clear, cc    Clears the Glide cache.
     about              Learn about Glide
     mirror             Manage mirrors
     help, h            Shows a list of commands or help for 
                        one command

8. Ginkgo

Ginkgo es un framework de pruebas de BDD (Behavior Driven Development). Le permite escribir las pruebas en una sintaxis que se asemeja a Inglés y permitir a la gente menos técnica examinar las pruebas (y su producción) y verificar que coinciden con los requerimientos del negocio.

Algunos desarrolladores como este estilo de la especificación de prueba demasiado. Se integra con el paquete de prueba incorporado de ir y se combina a menudo con Gomega. Este es un ejemplo de un Ginkgo + Gomega prueba:

1	actual, err := foo()
2	Ω(err).Should(BeNil())
3	Ω(actual).ShouldNot(BeNil())
4	Ω(actual.result).Should(Equal(100))

9. Etcd

Etcd es una tienda confiable de clave y valor distribuida. El servidor se implementa en Go, y aunque cliente vaya interactúa con él gRPC.

Se centra en lo siguiente:

Simple: bien definida, orientada al usuario API (gRPC).
Seguro: automático TLS con autenticación de cliente cert opcional.
Rápido: entre 10.000 escrituras por segundo.
Confiable: correctamente distribuida utilizando balsa.

Aquí es un ejemplo de conexión con el servidor, colocando un valor y conseguirla, incluyendo tiempos de espera y limpieza.

func test_get() {
    cli, err := clientv3.New(clientv3.Config{
		Endpoints:   endpoints,
		DialTimeout: dialTimeout,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	_, err = cli.Put(context.TODO(), "foo", "bar")
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 
                                       requestTimeout)
	resp, err := cli.Get(ctx, "foo")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}
	// Output: foo : bar
}

10. NSQ

NSQ es una gran cola distribuida. Lo he utilizado con éxito como un bloque principal de construcción para sistemas distribuidos a gran escala. Estas son algunas de sus características:

La ayuda distribuidas topologías con ningún SPOF.
Horizontal escalable (no brokers, perfectamente añadir más nodos al clúster).
Baja latencia empuje basado en entrega de mensajes (rendimiento).
Combinación de equilibrio de carga y enrutamiento de mensajes de multidifusión de estilo.
Excel en streaming (alto rendimiento) y trabajo orientado a las cargas de trabajo (bajo rendimiento).
Sobre todo en la memoria (más allá de una agua marca alta mensajes transparente se guardan en el disco).
Servicio de detección de tiempo de ejecución para los consumidores encontrar productores (nsqlookupd).
Seguridad de capa de transporte (TLS).
Formato de datos independiente.
Algunas dependencias (fáciles de implementar) y sane, delimitado, configuración por defecto.
Protocolo TCP simple apoyo a bibliotecas de cliente en cualquier idioma.
Interfaz HTTP para estadísticas, acciones de la administración y los productores (biblioteca de cliente no es necesario para publicar).
Se integra con statsd para instrumentación en tiempo real.
Interfaz de administración de clúster robusto (nsqadmin).

Aquí es cómo publicar un mensaje en NSQ (manejo de errores se omite):

package main

import (
  "github.com/bitly/go-nsq"
)

func main() {
  config := nsq.NewConfig()
  p, _ := nsq.NewProducer("127.0.0.1:4150", config)

  p.Publish("topic", []byte("message"))
  p.Stop()
}

Y aquí está cómo consumir:

package main

import (
  "sync"
  "fmt"
  "github.com/bitly/go-nsq"
)

func main() {
  wg := &sync.WaitGroup{}
  wg.Add(1)

  config := nsq.NewConfig()
  q, _ := nsq.NewConsumer("topic", "channel", config)
  handler := nsq.HandlerFunc(func(message *nsq.Message) error {
      fmt.Printf("Got a message: %v", message)
      wg.Done()
      return nil
  })
  q.AddHandler(handler)
  q.ConnectToNSQD("127.0.0.1:4150")
  wg.Wait()
}

11. Docker

Docker es un nombre familiar ahora (si los miembros de su familia son en su mayoría gente de DevOps). No es consciente que el Docker es implementado en Go. Por lo general no utiliza Docker en el código, pero es un proyecto importante y merece ser reconocida como un proyecto de Go enormemente exitoso y popular.

12. Kubernetes

Kubernetes es una plataforma de orquestación de contenedor de código abierto para aplicaciones nativas de nube. Es otro sistema de monstruo distribuido en Go. Recientemente escribí un libro llamado Dominando Kubernetes donde ir en detalle sobre los aspectos más avanzados de Kubernetes. Desde el punto de vista del desarrollador vaya Kubernetes es muy flexible, y puede extender y personalizar mediante plugins.

Conclusión

Go es una gran lengua. Su filosofía de diseño es un lenguaje simple y accesible. Su biblioteca estándar no es tan completo como otros lenguajes como Python.

Se acercó la comunidad Go, y hay muchas bibliotecas de alta calidad que se pueden utilizar en sus programas. En este artículo, introduje las 12 bibliotecas. Le animo a buscar otras bibliotecas antes de saltar e implementar todo desde cero.