One place for hosting & domains

      paquetes

      Cómo instalar software en clústeres de Kubernetes con el administrador de paquetes Helm 3


      Introducción

      Helm es un administrador de paquetes para Kubernetes que permite a los desarrolladores y operadores configurar e implementar de forma más sencilla aplicaciones en los clústeres de Kubernetes.

      A través de este tutorial, configurará Helm 3 y lo utilizará para instalar, volver a configurar, restaurar y eliminar una instancia de la aplicación Kubernetes Dashboard. El panel es una GUI de Kubernetes oficial basado en la web.

      Para obtener una descripción general conceptual de Helm y su ecosistema de paquetes, lea nuestro artículo Introducción a Helm.

      Requisitos previos

      Para este tutorial, necesitará lo siguiente:

      • Un clúster de Kubernetes con control de acceso basado en roles (RBAC) habilitado. Helm 3.1 admite clústeres de las versiones 1.14 a 1.17. Para obtener más información, consulte la página de versiones de Helm.
      • La herramienta de línea de comandos kubectl instalada en su máquina local, configurada para establecer conexión con su clúster. Puede leer más sobre la instalación de kubectl en la documentación oficial.

      Puede probar su conectividad con el siguiente comando:

      Si no ve errores, estará conectado al clúster. Si accede a varios clústeres con kubectl, asegúrese de verificar que haya seleccionado el contexto de clúster correcto:

      • kubectl config get-contexts

      Output

      CURRENT NAME CLUSTER AUTHINFO NAMESPACE * do-fra1-helm3-example do-fra1-helm3-example do-fra1-helm3-example-admin

      En este ejemplo, el asterisco (*) indica que se estableció conexión con el clúster do-fra1-helm3-example. Para cambiar de clústeres ejecute:

      • kubectl config use-context context-name

      Cuando esté conectado al clúster correcto, continúe con el paso 1 para comenzar a instalar Helm.

      Paso 1: Instalar Helm

      Primero, instalará la utilidad de línea de comandos helm en su máquina local. Helm proporciona una secuencia de comandos que gestiona el proceso de instalación en MacOS, Windows o Linux.

      Pase a un directorio editable y descargue la secuencia de comandos del repositorio de GitHub de Helm:

      • cd /tmp
      • curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3

      Haga que la secuencia de comandos sea ejecutable con chmod:

      Puede utilizar su editor de texto favorito para abrir la secuencia de comandos e inspeccionarla a fin de asegurarse de que sea segura. Cuando esté satisfecho, ejecútela:

      Es posible que se le solicite la contraseña. Ingrésela y presione INTRO para continuar.

      El resultado tendrá el siguiente aspecto:

      Output

      Downloading https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz Preparing to install helm into /usr/local/bin helm installed into /usr/local/bin/helm

      Ahora que instaló Helm, está listo para usarlo para instalar su primer chart.

      Paso 3: Instalar un chart de Helm

      Los paquetes de software de Helm se llaman charts. Hay un repositorio administrado de charts llamado stable, el cual consiste principalmente en tablas comunes que puede ver en su repositorio de GitHub. Helm no lo tiene preconfigurado en Helm. Por lo tanto, tendrá que añadirlo manualmente. Luego, a modo de ejemplo, instalará Kubernetes Dashboard.

      Añada el repositorio stable al ejecutar lo siguiente:

      • helm repo add stable https://kubernetes-charts.storage.googleapis.com

      El resultado será lo siguiente:

      Output

      "stable" has been added to your repositories

      Luego, utilice helm para instalar el paquete kubernetes-dashboard desde el repositorio stable:

      • helm install dashboard-demo stable/kubernetes-dashboard --set rbac.clusterAdminRole=true

      El parámetro --set le permite personalizar variables de chart, que el chart expone para permitirle personalizar su configuración. Aquí, establece la variable rbac.clusterAdminRole en true para conceder acceso a Kubernetes Dashboard a todo el clúster.

      El resultado tendrá este aspecto:

      Output

      NAME: dashboard-demo LAST DEPLOYED: Tue Mar 31 15:04:19 2020 NAMESPACE: default STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: ...

      Observe la línea de NAME, resaltada en el resultado del ejemplo anterior. En este caso, especificó el nombre dashboard-demo. Este es el nombre de la versión. Una versión de Helm es una única implementación de un chart con una configuración específica. Puede implementar varias versiones del mismo chart, cada una con su propia configuración.

      Puede enumerar todas las versiones del clúster:

      El resultado tendrá un aspecto similar a este:

      Output

      NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION dashboard-demo default 1 2020-03-31 15:04:19.324774799 +0000 UTC deployed kubernetes-dashboard-1.10.1 1.10.1

      Ahora, podemos usar kubectl para verificar que se haya implementado un nuevo servicio en el clúster:

      El resultado tendrá el siguiente aspecto:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dashboard-demo-kubernetes-dashboard ClusterIP 10.245.115.214 <none> 443/TCP 4m44s kubernetes ClusterIP 10.245.0.1 <none> 443/TCP 19m

      Tenga en cuenta que, por defecto, el nombre del servicio correspondiente a la versión es una combinación del nombre de versión de Helm y el nombre del chart.

      Ahora que implementó la aplicación, utilizará Helm para cambiar su configuración y actualizar la implementación.

      Paso 3: Actualizar una versión

      El comando helm upgrade puede utilizarse para actualizar una versión con un chart nuevo o actualizado, o para actualizar sus opciones de configuración (variables).

      Realizará un cambio sencillo en la versión de dashboard-demo para demostrar el proceso de actualización y reversión: actualizará el nombre del servicio de dashboard simplemente a kubernetes-dashboard en lugar de dashboard-demo-kubernetes-dashboard​​​​​​.

      El chart kubernetes-dashboard proporciona una opción de configuración de fullnameOverride para controlar el nombre de servicio. Para cambiar el nombre de la versión, ejecute helm upgrade con esta opción establecida:

      • helm upgrade dashboard-demo stable/kubernetes-dashboard --set fullnameOverride="kubernetes-dashboard" --reuse-values

      Al pasar el argumento --reuse-values, asegúrese de que el proceso de actualización no restablezca las variables de chart que haya establecido anteriormente.

      Visualizará un resultado similar al del paso inicial de ​​​​​​helm install.

      Verifique si sus servicios de Kubernetes reflejan los valores actualizados:

      El resultado será similar a lo siguiente:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.245.0.1 <none> 443/TCP 38m kubernetes-dashboard ClusterIP 10.245.49.157 <none> 443/TCP 8s

      Observe que el nombre del servicio se actualizó con el nuevo valor.

      Nota: En este punto, es posible que desee cargar Kubernetes Dashboard en su navegador y revisarlo. Para hacerlo, primero ejecute el siguiente comando:

      Esto crea un proxy que le permite acceder a recursos de clústeres remotos desde su computadora local. Conforme a las instrucciones anteriores, su servicio de dashboard se llama kubernetes-dashboard y se ejecuta en el espacio de nombres default. Ahora podrá acceder al panel en la siguiente URL:

      http://localhost:8001/api/v1/namespaces/default/services/https:kubernetes-dashboard:https/proxy/
      

      Las instrucciones para el uso del panel quedan fuera del alcance de este tutorial, pero puede leer los documentos oficiales de Kubernetes Dashboard para obtener más información.

      A continuación, verá la capacidad de revertir y eliminar versiones de Helm.

      Paso 4: Revertir y eliminar una versión

      Cuando actualizó la versión de dashboard-demo en el paso anterior, creó una segunda revisión de la versión. Helm conserva todos los detalles de las versiones anteriores en caso de que deba realizar una reversión a una configuración o un chart anterior.

      Utilice helm list para inspeccionar la versión de nuevo:

      Verá el siguiente resultado:

      Output

      NAME REVISION UPDATED STATUS CHART NAMESPACE dashboard-demo 2 Wed Aug 8 20:13:15 2018 DEPLOYED kubernetes-dashboard-0.7.1 default

      La columna REVISON le indica que ésta es, ahora, la segunda revisión.

      Utilice helm rollback para revertir la primera revisión:

      • helm rollback dashboard-demo 1

      Debería ver el siguiente resultado, lo cual indica que la reversión se realizó:

      Output

      Rollback was a success! Happy Helming!

      En este punto, si ejecuta kubectl get services de nuevo, observará que el nombre de servicio se cambió de nuevo a su valor anterior. Helm volvió a implementar la aplicación con la configuración de la revisión 1.

      Es posible eliminar versiones de helm con el comando helm delete:

      • helm delete dashboard-demo

      El resultado será lo siguiente:

      Output

      release "dashboard-demo" uninstalled

      Puede intentar enumerar las versiones de Helm:

      Verá que no hay ninguna:

      Output

      NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION

      Con esto, la versión se eliminó realmente y podrá reutilizar el nombre de versión.

      Conclusión

      A lo largo de este tutorial, instaló la herramienta de línea de comandos helm y exploró la instalación, la actualización, la reversión y la eliminación de charts y versiones de Helm mediante la administración del chart kubernetes-dashboard.

      Para obtener más información sobre Helm y sus charts, consulte la documentación oficial de Helm.



      Source link

      Cómo escribir paquetes en Go


      Un paquete está compuesto por archivos de Go que se alojan en el mismo directorio y tienen la misma instrucción de paquetes al inicio. Puede incluir funcionalidad adicional de paquetes para hacer que tus programas sean más sofisticados. Algunos paquetes están disponibles a través de la biblioteca de Go Standard y, por lo tanto, se incluyen con su instalación de Go. Otros se pueden instalar con el comando go get de Go. También puede crear sus propios paquetes de Go creando archivos de Go en el mismo directorio en el que desee compartir el código, con la instrucción de paquete necesaria.

      A través de este tutorial, podrás escribir paquetes Go para utilizarlos en otros archivos de programación.

      Requisitos previos

      • Configurar un entorno de programación de Go siguiendo uno de los tutoriales de la serie Cómo instalar y configurar un entorno de programación local para Go. Cree su espacio de trabajo Go siguiendo el paso 5 en los tutoriales de entorno de programación local. Para seguir el ejemplo y las convenciones de nomenclatura de este artículo, lea la primera sección: Escribir e importar de paquetes.
      • Para ampliar su conocimiento de GOPATH, lea nuestro artículo Información sobre GOPATH.

      Escribir e importar paquetes

      Escribir un paquete es como escribir cualquier archivo de Go. Los paquetes pueden contener definiciones de funciones, tipos y variables que luego pueden utilizarse en otros programas de Go.

      Para crear un nuevo paquete, es necesario encontrarse en el espacio de trabajo de Go propio. Normalmente, esto se encuentra en gopath. Por ejemplo, en este tutorial daremos el nombre greet al paquete. Para hacer esto, creamos un directorio llamado greet en nuestro gopath, en el espacio de nuestro proyecto. Si nuestra organización fuera gopherguides y quisiéramos crear el paquete greet con la organización mientras usamos Github como nuestro repositorio de código, nuestro directorio tendría el siguiente aspecto:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
      

      El directorio greet se necuentra dentro del directorio gopherguides:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── greet
      

      Por último, podemos añadir el primer archivo en nuestro directorio. Se considera práctica frecuente que el archivo primary o entry point de un paquete lleve el nombre del directorio. En este caso, crearíamos un archivo llamado greet.go dentro del directorio greet:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── greet
                          └── greet.go
      

      Con el archivo creado, podemos comenzar a escribir el código propio que queramos volver a usar o compartir en proyectos. En este caso, crearemos una función llamada Hello que imprima Hello World.

      Abra su archivo greet.go en su editor de texto y añada el siguiente código:

      greet.go

      package greet
      
      import "fmt"
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Desglosaremos este primer archivo. En la primera línea de cada archivo se necesita el nombre del package en el que trabaje. Debido a que se encuentra en el paquete greet, utiliza la palabra package seguida del nombre del paquete:

      package greet
      

      Esto indicará al compilador que considere todo en el archivo como parte del paquete greet.

      Luego, declare cualquier otro paquete que deba usar con la instrucción import. Sólo usará uno en este archivo: fmt:

      import "fmt"
      

      Por último, cree la función Hello. Se usará el paquete fmt para imprimir Hello, World!:

      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Ahora que escribió el paquete greet, puede utilizarlo en cualquier otro paquete que cree. Crearemos un nuevo paquete en el que usará su paquete greet.

      Crearemos un paquete llamado example, lo cual significa que necesita un directorio llamado example. Cree este paquete en su organización gopherguides, para que la estructura de directorios tenga el siguiente aspecto:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                          └── example
      

      Ahora que dispone del directorio para su nuevo paquete, puede crear el archivo de punto de entrada. Debido a que este será un programa ejecutable, es recomendable asignarle el nombre main.go:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── example
                          └── main.go
      

      En su editor de texto, abra main.go y añada el siguiente código para invocar al paquete greet:

      main.go

      package main
      
      import "github.com/gopherguides/greet"
      
      func main() {
          greet.Hello()
      }
      

      Debido a que importará un paquete, debe invocar la función haciendo referencia al nombre del paquete en notación de punto. La notación de punto es la práctica de poner un punto . entre el nombre del paquete que usa y el recurso en ese paquete que quiere usar. Por ejemplo, en su paquete greet, tiene la función Hello como recurso. Si desea invocar ese recurso, debe utilizar la notación de punto de greet.Hello().

      Ahora, podrá abrir su terminal y ejecutar el programa en la línea de comandos:

      Cuando lo haga, verá el siguiente resultado:

      Output

      Hello, World!

      Para ver cómo puede usar variables en un paquete, añadiremos una definición variable en su archivo greet.go:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Luego, abra su archivo main.go y añada la siguiente línea resaltada para invocar a la variable de greet.go en una función fmt.Println():

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      }
      

      Una vez que ejecute el programa de nuevo:

      Obtendrá el siguiente resultado:

      Output

      Hello, World! Sammy

      Por último, también definiremos un tipo en el archivo greet.go. Crearás el tipo Octopus con los campos name y color, y una función que imprimirá los campos cuando se invoque:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Abra main.go para crear una instancia de ese tipo al final del archivo:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      }
      

      Una vez que haya creado una instancia de tipo Octupus con oct := greet.Octopus, podrá acceder a las funciones y los campos del tipo dentro del espacio de nombres del archivo main.go. Esto le permite escribir oct.String() en la última línea sin invocar a greet. También podrías invocar uno de los campos de tipo como oct.Color sin hacer referencia al nombre del paquete greet.

      El método String del tipo Octopus utiliza la función fmt.Sprintf para crear una frase y muestra con returns el resultado, una cadena, al elemento de llamada (en este caso, su programa principal).

      Cuando ejecute el programa, verá el siguiente resultado:

      Output

      Hello, World! Sammy The octopus's name is "Jesse" and is the color orange.

      Al crear el método String en Octopus, accede a una alternativa reutilizable para imprimir información sobre su tipo personalizado. Si quiere cambiar el comportamiento de este método en el futuro, solo tiene que editarlo.

      Código exportado

      Posiblemente haya observado que todas las declaraciones del archivo de greet.go que invocó llevaban mayúsculas. Go no incluye, como otros lenguajes, el concepto de modificadores public, private o protected. La visibilidad externa se controla con mayúsculas. Los tipos, las variables, las funciones y otros elementos que empiezan con mayúsculas están disponibles de forma pública, fuera del paquete actual. Un símbolo visible fuera de su paquete se considera como exported.

      Si añade un nuevo método a Octopus llamado reset, puede invocarlo desde el interior del paquete greet, pero no desde su archivo main.go, que se encuentra fuera del paquete greet:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func (o *Octopus) reset() {
          o.Name = ""
          o.Color = ""
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      
      

      Si intenta invocar reset desde el archivo main.go:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      
          oct.reset()
      }
      

      Verá el siguiente error de compilación:

      Output

      oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset)

      Para aplicar export a la funcionalidad reset desde Octopus, use la R mayúscula en reset:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func (o *Octopus) Reset() {
          o.Name = ""
          o.Color = ""
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Como resultado, puede invocar a Reset desde su otro paquete sin obtener un error:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      
          oct.Reset()
      
          fmt.Println(oct.String())
      }
      

      Ahora, si ejecuta el programa:

      Recibirá el siguiente resultado:

      Output

      Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color .

      Al invocar Reset, eliminó toda la información de los campos Name y Color. Cuando invoque el método String, este no imprimirá nada donde normalmente aparecen Name y Color porque los campos ahora estarán vacíos.

      Conclusión

      Escribir un paquete de Go es lo mismo que escribir cualquier archivo de Go, pero insertarlo en otro directorio le permite aislar el código para que pueda reutilizarse desde cualquier lugar. En este tutorial, se abordó la forma de escribir las definiciones dentro de un paquete, se demostró la manera de usar esas definiciones en otro archivo de programación de Go y se explicaron las opciones para guardar el paquete a fin de acceder a él.



      Source link

      Importar paquetes en Go


      Introducción

      Habrá ocasiones en las que su código necesitará funciones adicionales fuera de su programa actual. En estos casos, puede usar paquetes para sumar sofisticación a su programa. Un paquete representa todos los archivos en un solo directorio en el disco. Los paquetes pueden definir funciones, tipos e interfaces a los que puede hacer referencia en otros archivos o paquetes de Go.

      Este tutorial le servirá como orientación en la instalación, la importación y el solapamiento de paquetes.

      Paquetes de la biblioteca estándar

      La biblioteca estándar que se incluye con Go es un conjunto de paquetes. Estos paquetes contienen muchos de los bloques fundamentales para escribir software moderno. Por ejemplo, el paquete fmt contiene funciones básicas para dar formato a las cadenas e imprimirlas. El paquete net/http contiene funciones que permiten que un desarrollador cree servicios web y envíe y obtenga datos a través del protocolo http, entre otras posibilidades.

      Para aprovechar las funciones de un paquete, deberá acceder a este con una instrucción import. Una instrucción import consta de la palabra clave import y el nombre del paquete.

      Como ejemplo, en el archivo random.go del programa de Go puede importar el paquete math/rand para generar números aleatorios de esta manera:

      random.go

      import "math/rand"
      

      Cuando importamos un paquete, hacemos que esté disponible en nuestro programa actual como un espacio de nombres por separado. Esto significa que tendremos que hacer referencia a la función en notación de punto, como en package.function.

      En la práctica, una función del paquete math/rand podría parecerse a los siguientes ejemplos:

      • rand.Int(), que invoca a la función para mostrar un entero al azar.
      • rand.Intn(), que llama a la función para mostrar un elemento aleatorio desde el 0 hasta el número especificado que se proporcionó.

      Crearemos un bucle for para mostrar la forma en que invocaremos una función del paquete math/randm dentro de nuestro programa random.go:

      random.go

      package main
      
      import "math/rand"
      
      func main() {
        for i := 0; i < 10; i++ {
          println(rand.Intn(25))
        }
      }
      

      Este programa primero importa el paquete math/rand en la tercera línea y luego se desplaza a un bucle for que se ejecutará 10 veces. Dentro del bucle, el programa imprimirá un entero aleatorio en el rango de 0 a 25. El número entero 25 se transmite a rand.Intn() como su parámetro.

      Cuando ejecutemos el programa con go run random.go, veremos 10 enteros aleatorios como resultado. Debido a que son aleatorios, es probable que obtenga diferentes enteros cada vez que ejecute el programa. El resultado tendrá un aspecto similar a este:

      Output

      6 12 22 9 6 18 0 15 6 0

      Los enteros nunca serán menores que 0 o mayores que 24.

      Al importar más de un paquete, puede usar () para crear un bloque. Al usar un bloque, puede evitar repetir la palabra clave import en cada línea. Esto hará que su código se vea más limpio:

      random.go

      
      import (
        "fmt"
        "math/rand"
      )
      

      Para aprovechar el paquete adicional, ahora podemos dar formato al resultado e imprimir la iteración en la que se generó cada número aleatorio durante el bucle:

      random.go

      package main
      
      import (
        "fmt"
        "math/rand"
      )
      
      func main() {
        for i := 0; i < 10; i++ {
          fmt.Printf("%d) %dn", i, rand.Intn(25))
        }
      }
      

      Ahora, cuando ejecutemos nuestro programa, veremos un resultado similar a este:

      Output

      0) 6 1) 12 2) 22 3) 9 4) 6 5) 18 6) 0 7) 15 8) 6 9) 0

      A través de esta sección, aprendió a importar paquetes y usarlos para escribir un programa más sofisticado. Hasta ahora, solo utilizamos paquetes de la biblioteca estándar. A continuación, veremos la manera de instalar y usar paquetes escritos por otros desarrolladores.

      Instalar paquetes

      Si bien la biblioteca estándar incluye muchos paquetes fabulosos y útiles, estos están diseñados de forma intencional para* uso general *y no específico. Esto permite que los desarrolladores construyan sus propios paquetes sobre la biblioteca estándar para satisfacer sus propias necesidades específicas.

      La cadena de herramientas de Go incluye el comando go get. Este comando le permite instalar paquetes de terceros en su entorno de desarrollo local y usarlos en su programa.

      Cuando se usa go get para instalar paquetes de terceros, es común que la ruta canónica de un paquete haga referencia a este. Esa ruta también puede ser una ruta hacia un proyecto público alojado en un repositorio de códigos como GitHub. En ese sentido, si desea importar el paquete flect, usaría la ruta canónica completa:

      • go get github.com/gobuffalo/flect

      La herramienta go get encontrará el paquete, en este caso en GitHub, y lo instalará en su $GOPATH.

      Para este ejemplo, el código se instalaría en este directorio:

      $GOPATH/src/github.com/gobuffalo/flect
      

      Los autores originales a menudo actualizan los paquetes para corregir errores o añadir nuevas funciones. Cuando esto sucede, es posible que quiera usar la versión más reciente de ese paquete para aprovechar las nuevas funciones o las correcciones de errores. Para actualizar un paquete, puede usar el indicador -u con el comando go get:

      • go get -u github.com/gobuffalo/flect

      Este comando también hará que Go instale el paquete si no se encuentra localmente. Si ya está instalado, Go intentará actualizar el paquete a la última versión.

      El comando go get siempre permite obtener la última versión disponible del paquete. Sin embargo, puede haber actualizaciones a versiones anteriores del paquete que son aún más recientes de las que está usando y sería útil actualizarlas en su programa. Para obtener esa versión específica del paquete, tendría que usar una herramienta de administración de paquetes, como Go Modules.

      A partir de Go 1.11, Go Modules se utiliza para administrar la versión del paquete que se intenta importar. El tema de la administración de paquetes está fuera del alcance de este artículo, pero puede obtener más información relacionada en la página de GitHub sobre módulos de Go.

      Solapar paquetes importados

      Quizá desee cambiar el nombre de un paquete si ya dispone de un paquete local con el mismo nombre que un paquete de terceros que esté usando. Cuando esto suceda, solapar su importación es la mejor manera de manejar el conflicto. Puede modificar los nombres de los paquetes y sus funciones dentro de Go disponiendo un nombre alias delante del paquete importado.

      La construcción de esta instrucción tiene el siguiente aspecto:

      import another_name "package"
      

      En este ejemplo, modifique el nombre del paquete fmt en el archivo del programa random.go. Cambiaremos el nombre del paquete de fmt a f para abreviarlo. Nuestro programa modificado tendrá el siguiente aspecto:

      random.go

      package main
      
      import (
       f "fmt"
        "math/rand"
      )
      
      func main() {
        for i := 0; i < 10; i++ {
          f.Printf("%d) %dn", i, rand.Intn(25))
        }
      }
      

      Dentro del programa, ahora haremos referencia a la función Printf como f.Printf en lugar de fmt.Printf.

      Mientras que en otros lenguajes existe una inclinación por el solapamiento de paquetes para facilitar su uso posterior en los programas, en Go esto no sucede. Por ejemplo, el solapamiento del paquete fmt para que pase a ser f no sería compatible con la guía de estilo.

      Cuando se cambian los nombres de las importaciones para evitar un conflicto de nombres, debe intentar aplicar el cambio a la importación más local o específica del proyecto. Por ejemplo, si tuviera un paquete local llamado strings y también necesitara importar el paquete del sistema llamado strings, optaría por cambiar el nombre su paquete local en lugar del paquete del sistema. Siempre que sea posible, es mejor evitar por completo el conflicto de nombres.

      En esta sección, aprendió a asignar un alias a una importación para evitar conflictos con otra importación en nuestro programa. Es necesario recordar que la legibilidad y la claridad son importantes en su programa, por lo que solo debe usar el solapamiento para hacer más legible el código o cuando necesite evitar un conflicto de nombres.

      Dar formato a las importaciones

      Al dar formato a las importaciones, puede clasificar los paquetes en un orden específico que hará que su código sea más uniforme. Además, esto evitará que se produzcan confirmaciones aleatorias cuando lo único que cambie sea el orden de clasificación de las importaciones. Debido a que la aplicación de formato a las importaciones evitará las confirmaciones aleatorias, esto evitará renovaciones innecesarias y revisiones confusas de código.

      La mayoría de los editores darán formato a las importaciones de manera automática o le permitirán configurar su editor para usar goimports. Se considera que el uso de goimports en su editor es una práctica estándar, ya que intentar mantener manualmente el orden de clasificación de sus importaciones puede ser tedioso y estar sujeto a errores. Además, si se realizan cambios de estilo, goimports se actualizará para reflejar estos cambios de estilo. Esto garantiza que usted y cualquier persona que trabaje en su código tengan un estilo uniforme en sus bloques de importación.

      A continuación, se muestra el aspecto que puede tener un bloque de importación de ejemplo antes de la aplicación de formato:

      import (
        "fmt"
        "os"
        "github.com/digital/ocean/godo"
        "github.com/sammy/foo"
        "math/rand"
        "github.com/sammy/bar"
      )
      

      Ejecutar la herramienta goimport (como alternativa, al guardar el archivo , esta se ejecutará en la mayoría de los editores en los que venga instalada), ahora tendrá el siguiente formato:

      import (
        "fmt"
        "math/rand"
        "os"
      
        "github.com/sammy/foo"
        "github.com/sammy/bar"
      
        "github.com/digital/ocean/godo"
      )
      

      Tenga en cuenta que agrupa primero todos los paquetes de la biblioteca estándar y luego paquetes de terceros junto con líneas en blanco. Esto facilita la lectura y comprensión de los paquetes que se utilizan.

      A través de esta sección, aprendió que el uso goimports mantendrá todos los bloques de importación en un formato adecuado e impedirá renovaciones de código innecesarias entre desarrolladores que trabajen en los mismos archivos.

      Conclusión

      Al importar paquetes, se puede invocar funciones que no están integradas en Go. Algunos paquetes son parte de la biblioteca estándar que se instala con Go y se instalarán a través de go get.

      Usar paquetes nos permite aportar más solidez y capacidad a nuestros programas, ya que aprovechamos el código existente. También podemos crear nuestros propios paquetes para que nosotros y otros programadores lo utilicemos en futuros programas.



      Source link