One place for hosting & domains

      Introducción

      Introducción al paquete de Strings en Go


      Introducción

      El paquete string de Go tiene varias funciones disponibles para trabajar con el tipo de datos de cadena. Estas funciones nos permiten modificar y manipular fácilmente las cadenas. Podemos pensar que las funciones son acciones que realizamos en elementos de nuestro código. Las funciones integradas son aquellas que se definen en el lenguaje de programación de Go y están inmediatamente disponibles para su uso.

      En este tutorial, revisaremos varias funciones diferentes que podemos usar para trabajar con cadenas en Go.

      Aplicar mayúsculas y minúsculas a cadenas

      Las funciones strings.ToUpper y strings.ToLower mostrarán una cadena con todas las letras de una cadena original convertidas a mayúsculas o minúsculas. Debido a que las cadenas son tipos de datos inmutables, la cadena devuelta será nueva. Cualquier carácter de la cadena que no sea una letra no se cambiará.

      Para convertir la cadena "Sammy Shark" de modo que esté totalmente en mayúsculas, utilizaría la función strings.ToUpper:

      ss := "Sammy Shark"
      fmt.Println(strings.ToUpper(ss))
      

      Output

      SAMMY SHARK

      Para la conversión a minúsculas:

      fmt.Println(strings.ToLower(ss))
      

      Output

      sammy shark

      Debido a usará el paquete strings, primero deberá importarlo a un programa. Para convertir la cadena a mayúsculas y minúsculas, todo el programa tendría el siguiente aspecto:

      package main
      
      import (
          "fmt"
          "strings"
      )
      
      func main() {
          ss := "Sammy Shark"
          fmt.Println(strings.ToUpper(ss))
          fmt.Println(strings.ToLower(ss))
      }
      

      Las funciones strings.ToUpper y strings.ToLower facilitan la evaluación y comparación de cadenas haciendo que las letras sean mayúsculas o minúsculas de manera uniforme. Por ejemplo, si un usuario escribe su nombre en minúsculas, aún podemos determinar si su nombre está en nuestra base de datos comparándolo con una versión totalmente en mayúsculas.

      Funciones de búsqueda de cadena

      El paquete strings tiene varias funciones que permiten determinar si una cadena contiene una secuencia de caracteres específica.

      Función Uso
      strings.HasPrefix Realiza búsquedas en la cadena desde el principio.
      strings.HasSuffix Realiza búsquedas en la cadena desde el final.
      strings.Contains Realiza búsquedas en cualquier parte de la cadena.
      strings.Count Cuenta la cantidad de veces que aparece la cadena.

      Las funciones strings.HasPrefix y strings.HasSuffix le permiten comprobar si una cadena comienza o finaliza con un conjunto específico de caracteres.

      Por ejemplo, para comprobar si la cadena "Sammy Shark" comienza con Sammy y finaliza con Shark:

      ss := "Sammy Shark"
      fmt.Println(strings.HasPrefix(ss, "Sammy"))
      fmt.Println(strings.HasSuffix(ss, "Shark"))
      

      Output

      true true

      Usaría la función strings.Contains para comprobar si "Sammy Shark" contiene la secuencia Sh:

      fmt.Println(strings.Contains(ss, "Sh"))
      

      Output

      true

      Finalmente, para ver cuántas veces aparece la letra S en la frase Sammy Shark:

      fmt.Println(strings.Count(ss, "S"))
      

      Output

      2

      Nota: Para todas las cadenas de Go se distinguen mayúsculas y minúsculas. Esto significa que Sammy no es igual que sammy.

      Usar una s en minúsculas para obtener un recuento de Sammy Shark no es lo mismo que usar una S mayúscula:

      fmt.Println(strings.Count(ss, "s"))
      

      Output

      0

      Debido a que S es diferente de s, el recuento será 0.

      Las funciones de cadenas son útiles cuando desea comparar o buscar cadenas en su programa.

      Determinar la longitud de la cadena

      La función integrada len() muestra el número de caracteres de una cadena. Esta función es útil cuando necesita aplicar extensiones mínimas o máximas de contraseñas, o para acortar cadenas más grandes de modo que estén dentro de ciertos límites para su uso como abreviaturas.

      Para demostrar esta función, buscaremos la extensión de una cadena larga como una oración:

      import (
          "fmt"
          "strings"
      )
      
      func main() {
              openSource := "Sammy contributes to open source."
              fmt.Println(len(openSource))
      }
      

      Output

      33

      Establecemos la variable openSource igual a la cadena "Sammy contributes to open source." y dicha variable se pasa a la función len() con len(openSource). Finalmente, pasamos la función a la función fmt.Println() para poder ver el resultado del programa en la pantalla.

      Tenga en cuenta que la función len() contará cualquier carácter vinculado por dobles comillas, como letras, números, caracteres de espacios en blanco y símbolos.

      Funciones para la manipulación de cadenas

      Las funciones strings.Join, strings.Split y strings.ReplaceAll son algunas formas adicionales de manipular cadenas en Go.

      La función strings.Join es útil para combinar un segmento de cadenas en una nueva cadena única.

      Para crear una cadena separada por comas a partir de un segmento de cadenas, usaríamos esta función de la siguiente forma:

      fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))
      

      Output

      sharks,crustaceans,plankton

      Si deseamos añadir una coma y un espacio entre los valores de cadena de nuestra nueva cadena, podemos simplemente reescribir nuestra expresión con un espacio en blanco después de la coma: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

      Así como podemos unir cadenas, también podemos dividirlas. Para hacer esto, podemos usar la función strings.Split y realizar divisiones en los espacios:

      balloon := "Sammy has a balloon."
      s := strings.Split(balloon, " ")
      fmt.Println(s)
      

      Output

      [Sammy has a balloon]

      El resultado es un segmento de cadenas. Debido a que se utilizó strings.Println, es difícil determinar el resultado con solo mirar. Para ver que es de hecho un segmento de cadenas, utilice la función fmt.Printf con el verbo %q para poner las cadenas entre comillas:

      fmt.Printf("%q", s)
      

      Output

      ["Sammy" "has" "a" "balloon."]

      Otra función útil además de strings.Split es strings.Fields. La diferencia es que strings.Fields ignorará todos los espacios en blanco y solo dividirá los fields reales en una cadena:

      data := "  username password     email  date"
      fields := strings.Fields(data)
      fmt.Printf("%q", fields)
      

      Output

      ["username" "password" "email" "date"]

      La función strings.ReplaceAll puede tomar una cadena original y mostrar una cadena actualizada con alguna sustitución.

      Digamos que el globo que Sammy tenía se perdió. Debido a que Sammy ya no tiene este globo, cambiaremos la subcadena "has" de la cadena original balloon por "had" en una nueva cadena:

      fmt.Println(strings.ReplaceAll(balloon, "has", "had"))
      

      Dentro de los paréntesis, primero está balloon, la variable que almacena la cadena original; la segunda subcadena "has" es lo que queremos sustituir y la tercera, "had", es la alternativa con la sustituiremos la segunda subcadena. Nuestro resultado tendrá este aspecto cuando lo incorporemos a un programa:

      Output

      Sammy had a balloon.

      Usando la función de la cadena strings.Join, strings.Split y strings.ReplaceAll tendrá un mayor control para manipular cadenas en Go.

      Conclusión

      En este tutorial se repasaron algunas de las funciones más comunes del paquete string para el tipo de datos de cadena que puede usar para manipular y trabajar con cadenas en sus programas de Go.

      Puede obtener más información sobre otros tipos de datos en Información sobre tipos de datos y leer más sobre las cadenas en Introducción al uso de cadenas.



      Source link

      Introducción al uso de cadenas en Go


      Una cadena es una secuencia de uno o más caracteres (letras, números y símbolos) que puede ser una constante o una variable. Las cadenas, compuestas por Unicode, son secuencias inmutables, lo cual significa que no cambian.

      Debido a que el texto es una forma de datos común que usamos en la vida cotidiana, el tipo de datos de cadena es un elemento fundamental de la programación.

      En este tutorial de Go se repasará la forma de crear e imprimir cadenas, concatenarlas y replicarlas, y guardarlas en variables.

      Literales de cadena

      En Go, las cadenas existen dentro de comillas invertidas ` (a veces llamadas tildes inversas) o comillas dobles ". Dependiendo de las comillas que utilice, la cadena tendrá diferentes características.

      Si se usan comillas inversas, como en `bar`, se creará un literal de cadena sin formato. En un literal de cadena sin formato, cualquier carácter puede aparecer entre comillas, con la excepción de las comillas inversas. Aquí se ofrece un ejemplo de un literal de cadena sin formato:

      `Say "hello" to Go!`
      

      Las barras diagonales inversas no tienen un significado especial dentro de los literales de cadena sin formato. Por ejemplo, n aparecerá como los caracteres reales, la barra diagonal inversa y la letra n. A diferencia de los literales de cadena interpretados, en los cuales n insertará una nueva línea real.

      Los literales de cadena sin formato también pueden usarse para crear cadenas de varias líneas:

      `Go is expressive, concise, clean, and efficient.
      Its concurrency mechanisms make it easy to write programs
      that get the most out of multi-core and networked machines,
      while its novel type system enables flexible and modular
      program construction. Go compiles quickly to machine code
      yet has the convenience of garbage collection and the power
      of run-time reflection. It's a fast, statically typed,
      compiled language that feels like a dynamically typed,
      interpreted language.`
      

      Los literales de cadena interpretados son secuencias de caracteres entre dobles comillas, como en "bar". Dentro de las comillas, puede aparecer cualquier carácter, con la excepción de las comillas de nueva línea y las comillas dobles sin escapes.

      "Say "hello" to Go!"
      

      Casi siempre usará literales de cadena interpretados porque permiten caracteres con escapes dentro de ellas.

      Ahora que comprende la manera en que aplica formato a las cadenas en Go, veremos la forma en que puede imprimir cadenas en programas.

      Imprimir cadenas

      Puede imprimir cadenas usando el paquete fmt de la biblioteca del sistema e invocando la función PrintIn():

      fmt.Println("Let's print out this string.")
      

      Output

      Let's print out this string.

      Debe aplicar import a paquetes del sistema cuando los utilice. Por lo tanto, un programa sencillo para imprimir una cadena tendría este aspecto:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Let's print out this string.")
      }
      

      Concatenación de cadenas

      La concatenación implica unir cadenas de extremo a extremo para crear una cadena nueva. Puede concatenar cadenas con el operador +. Tenga en cuenta que cuando trabaje con números, + será un operador para sumar, pero cuando se use con cadenas, será un operador de unión.

      Combinaremos los literales de cadena "Sammy"y "Shark" con una concatenación a través de la instrucción fmt.PrintIn():

      fmt.Println("Sammy" + "Shark")
      

      Output

      SammyShark

      Si desea un espacio en blanco entre las dos cadenas, simplemente puede incluir el espacio en blanco en una. En este ejemplo, añada el espacio en blanco entre las comillas después de Sammy:

      fmt.Println("Sammy " + "Shark")
      

      Output

      Sammy Shark

      El operador + no puede usarse entre dos tipos de datos diferentes. Como ejemplo, no puede concatenar cadenas y enteros. Si intenta escribir lo siguiente:

      fmt.Println("Sammy" + 27)
      

      Verá los siguientes errores:

      Output

      cannot convert "Sammy" (type untyped string) to type int invalid operation: "Sammy" + 27 (mismatched types string and int)

      Si desea crear la cadena "Sammy27", podría hacerlo disponiendo el número 27 entre comillas ("27") de modo que deje de ser un entero y sea, en su lugar, una cadena. Convertir números a cadenas para su concanetación puede ser útil al manejar códigos postales o números de teléfono. Por ejemplo, no le convendría realizar una suma entre un código de país y un código de área, pero sí le convendrá que se mantengan juntos.

      Cuando combina dos o más cadenas a través de una concatenación, crea una nueva cadena que puede usar en su programa.

      Almacenar cadenas en variables

      Las variables son símbolos que puede usar para guardar datos en un programa. Puede imaginarlas como cajas vacías que llena con datos o valores. Las cadenas son datos. Por lo tanto, puede usarlas para completar una variable. Declarar cadenas como variables puede hacer que sea más fácil trabajar con cadenas en sus programas de Go.

      Para guardar una cadena dentro de una variable, simplemente asigne una variable a una cadena. En este caso, declare s como su variable:

      s := "Sammy likes declaring strings."
      

      Nota: Si está familiarizado con otros lenguajes de programación, es posible que haya escrito la variable como sammy. En Go, sin embargo, se prefieren los nombres de variables más cortos. Elegir s para el nombre de la variable en este caso se consideraría más apropiado para el estilo en el que Go está escrito.

      Ahora que fijó la variable s en esa cadena concreta, puede imprimirla de esta forma:

      fmt.Println(s)
      

      Luego, recibirá el siguiente resultado:

      Output

      Sammy likes declaring strings.

      Al usar las variables como sustitutas de las cadenas, no es necesario que vuelva a escribir una cadena cada vez que desee usarla, lo cual hace que sea más sencillo trabajar con cadenas y manipularlas en sus programas.

      Conclusión

      En este tutorial, se explicaron los aspectos básicos necesarios para trabajar con el tipo de dato de cadenas en el lenguaje de programación Go. Crear cadenas, imprimirlas, concatenarlas, replicarlas y guardarlas en variables le brindará lo esencial para usar cadenas en sus programas de Go.



      Source link

      Introducción a Helm, el administrador de paquetes de Kubernetes


      Introducción

      Implementar aplicaciones en Kubernetes (el popular y sólido sistema contenedor y organizador) puede ser un proceso complejo. Configurar una sola aplicación puede implicar crear varios recursos de interdependientes de Kubernetes (tales como lugares de descarga, servicios, implementaciones y ReplicaSets), cada uno de los cuales requiere la redacción de un archivo de manifiesto YAML detallado.

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

      Actualmente, Helm es un proyecto oficial de Kubernetes y forma parte de Cloud Native Computing Foundation, una organización sin fines de lucro que respalda proyectos de código abierto en el ecosistema de Kubernetes y a su alrededor.

      En este artículo, proporcionaremos una descripción general de Helm y las diversas abstracciones que usa para simplificar la implementación de aplicaciones en Kubernetes. Si no conoce Kubernetes, Introducción a Kubernetes puede resultarle útil antes para familiarizarse con los conceptos básicos.

      Descripción general de Helm

      La mayoría de los sistemas operativos y de programación de lenguaje tienen su propio administrador de paquetes para la instalación y el mantenimiento de software. Helm proporciona el mismo conjunto de funciones básicas que muchos de los administradores que seguramente ya conoce, como apt de Debian o pip de Python.

      Helm puede:

      • Instalar software
      • Instalar de manera automática dependencias de software
      • Actualizar software
      • Configurar implementaciones de software
      • Obtener paquetes de software de repositorios

      Helm proporciona esta funcionalidad a través de los siguientes componentes:

      • Una herramienta de línea de comandos, helm, que proporciona la interfaz de usuario para todas las funcionalidades de Helm.
      • Un componente de servidor complementario, tiller, que funciona en su clúster de Kubernetes, escucha los comandos de helm y gestiona la configuración e implementación de versiones de software en el clúster.
      • El formato de empaquetado de Helm, llamado charts.
      • Un repositorio de charts oficiales seleccionados con charts empaquetados previamente para proyectos de software de código abierto populares.

      A continuación, investigaremos el formato de los charts en mayor detalle.

      Charts

      Los paquetes de Helm se llaman charts, y constan de algunos archivos de configuración YAML y algunas plantillas que se convierten en archivos de manifiesto de Kubernetes. Esta es la estructura de directorios básica de un chart:

      Example chart directory

      package-name/
        charts/
        templates/
        Chart.yaml
        LICENSE
        README.md
        requirements.yaml
        values.yaml
      

      Estos directorios y archivos tienen las siguientes funciones:

      • charts/: en este directorio se pueden disponer dependencias de charts administradas manualmente, aunque suele ser mejor usar requirements.yaml para vincular las dependencias de manera dinámica.
      • templates/: este directorio contiene archivos de plantillas que se combinan con valores de configuración (de values.yaml y la línea de comandos) y se representan en manifiestos de Kubernetes. Las plantillas usan el formato Go programming language.
      • Chart.yaml: archivo YAML con metadatos sobre el chart, como el nombre y la versión de este, la información del mantenedor, un sitio web relevante y palabras claves de búsqueda.
      • LICENSE: licencia de texto sin formato para el chart.
      • README.md: archivo readme con información para usuarios del chart.
      • requirements.yaml: archivo YAML que enumera las dependencias del chart.
      • values.yaml: archivo YAML con valores de configuración predeterminados para el chart.

      El comando helm puede instalar un chart de un directorio local o de una versión .tar.gz empaquetada de esta estructura de directorio. Estos charts empaquetados también pueden descargarse e instalarse automáticamente desde los repositorios de charts, o repos.

      A continuación, analizaremos los repositorios de charts.

      Repositorios de charts

      Un repo de charts de Helm es un sitio HTTP simple que proporciona un archivo index.yaml y charts empaquetados .tar.gz. El comando helm tiene subcomandos disponibles para ayudar a empaquetar charts y crear el archivo index.yaml necesario. En cualquier servidor web, servicio de almacenamiento de objetos o sitio estático, como las páginas GitHub, se pueden proporcionar estos archivos.

      Helm viene previamente configurado con un repositorio de charts predeterminado, conocido como stable. Este repo apunta a un depósito de almacenamiento de Google en https://kubernetes-charts.storage.googleapis.com. La fuente del repo *stable *se puede encontrar en el repositorio Git de helm/charts en GitHub.

      Los repos alternativos pueden agregarse con el comando helm repo add. Los siguientes son algunos repositorios alternativos populares:

      Si instala un chart que desarrolló a nivel local o uno de un repo, debe configurarlo para su instalación en particular. A continuación, veremos las configuraciones.

      Configuración de charts

      Un chart suele incorporar valores de configuración predeterminados en su archivo values.yaml. Algunas aplicaciones pueden implementarse completamente con valores predeterminados, pero por lo general deberá sobrescribir alguna de las configuraciones para que el chart cumpla con sus requisitos.

      El autor del chart determina los valores expuestos para la configuración. Algunos se usan para configurar Kubernetes antiguos y algunos pueden pasarse a través del contenedor subyacente para configurar la propia aplicación.

      A continuación, se brinda un fragmento de algunos valores de ejemplo:

      values.yaml

      service:
        type: ClusterIP
        port: 3306
      

      Estas son opciones para configurar un recurso de servicio de Kubernetes. Puede usar helm inspect values chart-name para desechar todos los valores de configuración disponibles para un chart.

      Estos valores pueden sobrescribirse redactando su propio archivo YAML y usándolo al ejecutar helm install, o al establecer opciones de manera individual en la línea de comandos con el indicador --set. Solo necesita especificar esos valores predeterminados que desee cambiar.

      Un chart de Helm implementado con una configuración particular se conoce como release. Hablaremos sobre los releases a continuación.

      Releases

      Durante la instalación de un chart, Helm combina las plantillas del chart con la configuración especificada por el usuario y los valores predeterminados de value.yaml. Estos se convierten en manifiestos de Kubernetes que se implementan a través de la API de Kubernetes. Con esto se crea un release, una configuración e implementación específica de un chart en particular.

      El concepto de los lanzamientos es importante, ya que posiblemente desee implementar la misma aplicación más de una vez en un clúster. Por ejemplo, es posible que necesite varios servidores de MySQL con distintas configuraciones.

      También es posible que quiera mejorar distintas instancias de un chart de manera individual. Es posible que una aplicación esté lista para un servidor MySQL actualizado, y que otra no lo esté. Con Helm, puede mejorar cada release de forma individual.

      Es posible que mejore un release porque se actualizó el chart de este o porque quiere actualizar la configuración del propio release. De cualquier manera, con cada mejora se creará una nueva revisión de un release y Helm le permitirá restablecer fácilmente revisiones anteriores en caso de que se produzca un problema.

      Creación de charts

      Si no puede encontrar un chart existente para el software que implementará, es posible que prefiera crear uno propio. Helm puede generar la estructura del directorio de un chart con helm create chart-name. Con esto, se creará una carpeta con los archivos y directorios que analizamos en la sección Charts anterior.

      A partir de este punto, debe completar los metadatos de su chart en Chart.yaml y disponer sus archivos de manifiesto de Kubernetes en el directorio templates. Luego, debe quitar las variables de configuración pertinentes de sus manifiestos y disponerlas en values.yaml,y luego incluirlas de nuevo en sus plantillas de manifiestos mediante el sistema de creación de plantillas.

      El comando helm tiene muchos subcomandos disponibles para ayudarlo a probar, empaquetar y administrar sus charts. Para obtener más información, consulte la documentación oficial de Helm vinculada al desarrollo de charts.

      Conclusión

      A lo largo de este artículo, hicimos una revisión de Helm, el administrador de paquetes de Kubernetes. Observamos la arquitectura de Helm y los componentes individuales helm y tiller, vimos en detalle el formato de charts de Helm y analizamos los repositorios de charts. También investigamos la forma de configurar un chart de Helm y de combinar e implementar las configuraciones y los charts como releases en clústeres de Kubernetes. Por último, vimos brevemente los conceptos básicos con los que se puede crear un chart cuando no hay uno adecuado disponible.

      Para obtener más información sobre Helm, consulte la documentación oficial de Helm. Para encontrar charts oficiales para Helm, consulte el repositorio oficial de Git helm/charts en GitHub.



      Source link