One place for hosting & domains

      Cómo administrar conjuntos ordenados en Redis


      Introducción

      Redis es un almacén de datos clave-valor en memoria de código abierto. En Redis, los conjuntos ordenados son un tipo de datos similares a los conjuntos, ya que ambos son grupos de cadenas que no se repiten. La diferencia es que cada componente de un conjunto ordenado se asocia a una puntuación, lo que permite ordenarlos de la menor a la mayor. Como en el caso de los conjuntos, todos los componentes de un conjunto ordenado deben ser únicos, aunque varios pueden compartir la misma puntuación.

      En este tutorial, se explica la forma de crear conjuntos ordenados, obtener y eliminar sus componentes y crear nuevos conjuntos ordenados a partir de conjuntos existentes.

      Cómo usar esta guía

      Esta guía está escrita a modo de ayuda memoria con ejemplos independientes. Lo alentamos a ir directamente a cualquier sección que sea pertinente para la tarea que desee completar.

      Los comandos que se muestran en esta guía se probaron en un servidor de Ubuntu 18.04 con Redis 4.0.9. Para configurar un entorno similar, puede seguir el paso 1 de nuestra guía Cómo instalar y proteger Redis en Ubuntu 18.04. Mostraremos el comportamiento de estos comandos ejecutándolos con redis-cli, la interfaz de línea de comandos de Redis. Tenga en cuenta que si utiliza una interfaz de Redis diferente (por ejemplo, Redli), el resultado exacto de algunos comandos puede diferir.

      De forma alternativa, podría proporcionar una instancia de base de datos de Redis gestionada para probar estos comandos, pero tenga en cuenta que, dependiendo del nivel de control que permita su proveedor de base de datos, es posible que algunos comandos de esta guía no funcionen según lo descrito.  Para proporcionar una base de datos gestionada de DigitalOcean, consulte nuestra documentación sobre bases de datos gestionadas. Luego, debe instalar Redli o configurar un túnel TLS para establecer conexión con la base de datos gestionada mediante TLS.

      Crear conjuntos ordenados y añadir componentes

      Para crear un conjunto ordenado, utilice el comando zadd. zadd acepta como argumento el nombre de la clave que contendrá el conjunto ordenado, seguido de la puntuación del componente que añada y el valor del propio componente. Con el siguiente comando, se creará una clave de conjunto ordenado denominada faveGuitarists con un componente, "Joe Pass", que tiene una puntuación de 1:

      • zadd faveGuitarists 1 "Joe Pass"

      zadd mostrará un entero que indica la cantidad de componentes añadidos al conjunto ordenado si se creó de forma correcta.

      Output

      (integer) 1

      Puede añadir más de un componente a un conjunto ordenado con zadd. Tenga en cuenta que no es necesario que las puntuaciones sean secuenciales; puede haber brechas entre ellas, y varios componentes de un mismo conjunto ordenado pueden compartir la misma puntuación:

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd puede aceptar las siguientes opciones, que debe ingresar después del nombre de clave y antes de la puntuación del primer componente:

      • NX o XX: estas opciones tienen efectos opuestos. Por lo tanto, solo puede incluir una de ellas en cualquier operación de zadd:
        • NX: indica a zadd que no actualice componentes existentes. Con esta opción, zadd añadirá únicamente elementos nuevos.
        • XX: indica a zadd a que solo actualice elementos existentes. Con esta opción, zadd nunca añadirá nuevos componentes.
      • CH: en general, zadd solo muestra la cantidad de nuevos elementos añadidos al conjunto ordenado. Con esta opción, sin embargo, zadd mostrará la cantidad de elementos modificados. Esto comprende los componentes recientemente añadidos y aquellos cuya puntuación se modificó.
      • INCR: hace que el comando aumente el valor de la puntuación del componente. Si el componente todavía no existe, el comando lo añadirá al conjunto ordenado con el aumento como puntuación, como si la puntuación original hubiera sido 0. Con INCR incluido, zadd muestra la puntuación nueva del componente si es correcta. Tenga en cuenta que solo puede incluir una puntuación o un componente a la vez cuando se utiliza esta opción.

      En lugar de pasar la opción INCR a zadd, puede usar el comando zincrby, que se comporta exactamente de la misma manera. En vez de dar al componente del conjunto ordenado el valor que indica la puntuación como zadd, aplica a la puntuación del componente un incremento equivalente a ese valor.  Por ejemplo, con el siguiente comando se aplica un incremento de 5 a la puntuación del componente "Stephen Malkmus", que originalmente era 4, con lo cual llega a 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      Como en el caso de la opción INCR del comando zadd, si el componente especificado no existe, zincrby lo crea con el valor de incremento como puntuación.

      Obtener componentes de conjuntos ordenados

      La manera más básica de recuperar componentes de un conjunto ordenado es usar el comando zrange.  Este comando acepta como argumento el nombre de la clave cuyos componentes desea obtener y un intervalo de componentes que se encuentran en su interior. El intervalo está definido por dos números que representan índices basados en cero, lo cual significa que 0 representa el primer componente del conjunto ordenado (o el componente con la puntuación más baja), 1 el siguiente y así sucesivamente.

      En el siguiente ejemplo, se mostrarán los primeros cuatro componentes del conjunto ordenado faveGuitarists creado en la sección anterior:

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Tenga en cuenta que si el conjunto ordenado que pasa a zrange tiene dos o más elementos con la misma puntuación, les aplicará orden lexicográfico o alfabético.

      Los índices de inicio y detención también pueden ser números negativos: -1 representa el último componente, -2 el penúltimo y así sucesivamente.

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange puede aceptar el argumento WITHSCORES que, cuando se incluya, también mostrará las puntuaciones de los componentes:

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange solo puede mostrar un intervalo de componentes en orden numérico ascendente. Para revertir esto y mostrar un intervalo en orden decreciente, debe usar el comando zrevrange. Considere este comando como una reversión temporal del ordenamiento del conjunto ordenado dado antes de mostrar los componentes que se encuentran dentro del intervalo especificado. Como sucede con zrevrange, 0 representará el último componente de la clave, 1 el penúltimo y así sucesivamente:

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange también puede aceptar la opción WITHSCORES.

      Puede mostrar un intervalo de componentes según sus puntuaciones con el comando zrangebyscore. En el siguiente ejemplo, con el comando se mostrará cualquier componente que se encuentre en la clave faveGuitarists con una puntuación de 2, 3, o 4:

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      En este ejemplo, el intervalo es inclusivo, lo cual significa que mostrará componentes con puntuaciones de 2 o 4. Puede excluir cualquier extremo del intervalo anteponiéndole un paréntesis abierto ((). En el siguiente ejemplo, se mostrarán todos los componentes con una puntuación superior o igual a 2, pero inferior a 4:

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Al igual que zrange, zrangebyscore puede aceptar el argumento WITHSCORES. También acepta la opción LIMIT, que puede usar para obtener solo una selección de elementos del resultado de zrangebyscore. Esta opción acepta un desplazamiento, que indica el primer componente del intervalo que se mostrará con el comando y un recuento que define la cantidad total de componentes que se mostrarán con el comando. Por ejemplo, con el siguiente comando se analizarán los primeros seis componentes del conjunto ordenado faveGuitarists, pero solo se mostrarán 3 componentes de él, a partir del segundo componente del intervalo, representado por 1:

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Con el comando zrevrangebyscore, se muestra un intervalo invertido de componentes según sus puntuaciones. Con el siguiente comando se muestran todos los componentes del conjunto con una puntuación de entre 10 y 6:

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      Al igual que zrangebyscore, zrangebyscore puede aceptar las opciones WITHSCORES y LIMIT. Además, puede excluir cualquier extremo del intervalo anteponiéndole un paréntesis abierto.

      Puede haber momentos en que todos los componentes de un conjunto ordenado tengan la misma puntuación. En ese caso, puede hacer que Redis muestre de forma forzosa un intervalo de elementos en orden lexicográfico o alfabético con el comando zrangebylex. Para probar este comando, ejecute el siguiente comando zadd a fin de crear un conjunto ordenado en el que cada componente tenga la misma puntuación:

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      zrangebylex debe ir seguido del nombre de una clave, un intervalo de inicio y un intervalo de detención. Los intervalos de inicio y detención deben iniciarse con un paréntesis abierto (() o un corchete abierto ([), como se muestra a continuación:

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Tenga en cuenta que en este ejemplo solo se mostraron cuatro de los ocho componentes del conjunto, a pesar de que el comando buscaba un intervalo de la a a la z. Esto se debe a que los valores de Redis distinguen entre mayúsculas y minúsculas; por lo tanto, los componentes que comienzan con letras mayúsculas se excluyeron de su resultado. Para mostrarlos, puede ejecutar lo siguiente:

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex también acepta los caracteres especiales -, que representa un infinito negativo y +, que representa un infinito positivo. Por lo tanto, con la siguiente sintaxis de comando también se mostrarán todos los componentes del conjunto ordenado:

      • zrangebylex SomervilleSquares - +

      Tenga en cuenta que zrangebylex no puede mostrar componentes del conjunto en orden lexicográfico inverso (alfabético ascendente). Para hacerlo, utilice zrevrangebylex:

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Debido a que está destinado a usarse con conjuntos ordenados en los que todos los componentes tienen la misma puntuación, zrangebylex no acepta la opción WITHSCORES.  Sin embargo, sí acepta la opción LIMIT.

      Obtener información sobre conjuntos ordenados

      Para averiguar la cantidad de componentes de un conjunto ordenado determinado (o, en otras palabras, su cardinalidad), utilice el comando zcard. En el siguiente ejemplo, se muestra la cantidad de componentes contenidos en la clave faveGuitarists de la primera sección de esta guía:

      Output

      (integer) 9

      zcount puede indicar la cantidad de elementos de un conjunto ordenado determinado que se encuentran dentro de un intervalo de puntuaciones. El primer número que sigue a la clave es el comienzo del intervalo y el segundo es el final:

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore obtiene la puntuación de un componente especificado de un conjunto ordenado:

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Si el componente o la clave especificados no existen, zscore mostrará (nil).

      zrank es similar a zscore, pero, en vez de mostrar la puntuación del componente determinado, muestra su clasificación. En Redis, una clasificación es un índice basado en cero de los componentes de un conjunto ordenado por su puntuación. Por ejemplo, "Joe Pass" tiene una puntuación de 1, pero, dado que esa es la puntuación más baja de todos los componentes de la clave, tiene una clasificación de 0:

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Hay otro comando de Redis denominado zrevrank que realiza la misma función que zrank, pero, en su lugar, invierte las clasificaciones de los componentes del conjunto. En el siguiente ejemplo, el componente "Joe Pass" tiene la puntuación más baja y, por lo tanto, la clasificación invertida más alta:

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      La única relación entre la puntuación de un componente y su clasificación es la posición que ocupa su puntuación en relación con las de otros miembros.  Si hay una brecha de puntuación entre dos componentes secuenciales, no se reflejará en su clasificación. Tenga en cuenta que si dos componentes tienen la misma puntuación, el primero en orden alfabético tendrá la menor clasificación.

      Al igual que zscore, zrank y zrevrank devolverán (nil) si la clave o el componente no existen.

      zlexcount puede indicar la cantidad de componentes que se encuentran en un conjunto ordenado en un intervalo lexicográfico. En el siguiente ejemplo, se utiliza el conjunto ordenado SomervilleSquares de la sección anterior:

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Este comando tiene la misma sintaxis que zrangebylex. Por lo tanto, consulte la sección anterior para obtener información detallada sobre cómo definir un intervalo de cadena.

      Eliminar componentes de conjuntos ordenados

      Con el comando zrem, es posible eliminar uno o más componentes de un conjunto ordenado:

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem mostrará un entero que indicará la cantidad de componentes que eliminó del conjunto ordenado:

      Output

      (integer) 2

      Hay tres comandos de Redis que le permiten eliminar componentes de un conjunto ordenado basado en un intervalo. Por ejemplo, si todos los componentes de un conjunto ordenado tienen la misma puntuación, puede eliminar componentes sobre la base de un intervalo lexicográfico con zremrangebylex. Este comando utiliza la misma sintaxis que zrangebylex. En el siguiente ejemplo, se eliminarán de la clave SomervilleSquares creada en la sección anterior todos los componentes que comiencen con una letra mayúscula :

      • zremrangebylex SomervilleSquares [A [Z

      zremrangebylex dará como resultado un entero que indica la cantidad de componentes que eliminó:

      Output

      (integer) 3

      También puede eliminar componentes en base a un intervalo de puntuaciones con el comando zremrangebyscore, que utiliza la misma sintaxis que el comando zrangebyscore. En el siguiente ejemplo, se eliminarán todos los componentes de faveGuitarists con una puntuación de 4, 5 o 6:

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Puede eliminar componentes de un conjunto en base a un intervalo de clasificaciones con el comando zremrangebyrank, que utiliza la misma sintaxis que zrangebyrank. Con el siguiente comando, se eliminarán los tres componentes del conjunto ordenado con las clasificaciones más bajas, que se definen en función de un intervalo de índices basados en cero:

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Tenga en cuenta que los números que se pasan a remrangebyrank también pueden ser negativos: -1 representa la clasificación más alta, -2 la siguiente y así sucesivamente.

      Crear nuevos conjuntos ordenados a partir de conjuntos existentes

      Redis incluye dos comandos que le permiten comparar componentes de varios conjuntos ordenados y crear conjuntos nuevos sobre la base de esas comparaciones: estos son zinterstore y zunionstore. Para experimentar con ellos, ejecute los siguientes comandos zadd a fin de crear conjuntos ordenados de ejemplo.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore encuentra los componentes que comparten dos o más conjuntos ordenados (en su intersección) y produce un nuevo conjunto ordenado que contiene únicamente estos componentes. Este comando debe incluir, en orden, el nombre de una clave de destino en la que los componentes de la intersección se almacenarán como conjunto ordenado, el número de claves que se pasan a zinterstore y los nombres de las claves que desea analizar:

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore mostrará un entero que indica la cantidad de elementos almacenados en el conjunto ordenado de destino. Debido a que NewKids y Nsync solo comparten un componente, "Joey", el comando mostrará 1:

      Output

      (integer) 1

      Tenga en cuenta que si la clave de destino ya existe, zinterstore sobrescribirá su contenido.

      zunionstore creará un nuevo conjunto ordenado que contendrá todos los componentes de las claves que se le pasaron. Este comando utiliza la misma sintaxis que zinterstore y requiere el nombre de una clave de destino, la cantidad de claves que se pasan al comando y los nombres de estas:

      • zunionstore SuperGroup 2 NewKids Nsync

      Al igual que zinterstore, zunionstore , mostrará un entero que indica la cantidad de elementos almacenados en la clave de destino. Si bien los dos conjuntos ordenados originales tienen cinco componentes, dado que los conjuntos ordenados no pueden tener componentes repetidos y cada clave tiene un componente denominado "Joey", el entero resultante será 9:

      Output

      (integer) 9

      Al igual que zinterstore, zunionstore sobrescribirá el contenido de la clave de destino si ya existe.

      Para tener más control sobre las puntuaciones de los componentes al crear conjuntos ordenados nuevos con zinterstore y zunionstore, los dos comandos aceptan las opciones WEIGHTS y AGGREGATE.

      La opción WEIGHTS va seguida de un número por cada conjunto ordenado incluido en el comando que pondera o multiplica la puntuación de cada componente. El primer número después de la opción WEIGHTS pondera las puntuaciones de la primera clave que se pasó al comando, el segundo número pondera la segunda y así sucesivamente.

      En el siguiente ejemplo, se crea un nuevo conjunto ordenado que contiene las claves intersecantes de los conjuntos ordenados NewKids y Nsync. Pondera las puntuaciones de la clave de NewKids en un factor de tres y las de la clave de Nsync en un factor de siete:

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Si la opción WEIGHTS no se incluye, la ponderación por defecto es 1 tanto para zinterstore como para zunionstore.

      AGGREGATE acepta tres subopciones. La primera, SUM, implementa el comportamiento predeterminado de zinterstore y zunionstore añadiendo las puntuaciones de los componentes coincidentes en los conjuntos combinados.

      Si ejecuta una operación zinterstore o zunionstore en dos conjuntos ordenados que comparten un componente, pero este tiene una puntuación diferente en cada conjunto, puede hacer que la operación asigne por la fuerza la menor de las dos puntuaciones en el nuevo conjunto con la subopción MIN.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Debido a que los dos conjuntos ordenados solo tienen un componente coincidente con la misma puntuación (3), este comando creará un nuevo conjunto con el componente que tenga la menor de las dos puntuaciones ponderadas:

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      De la misma manera, AGGREGATE puede forzar zinterstore o zunionstore a asignar la mayor de las dos puntuaciones con la opción MAX:

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      A través de este comando, se crea un nuevo conjunto con un componente, "Joey", que tiene la mayor de las dos puntuaciones ponderadas.

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Puede ser útil considerar a WEIGHTS como una alternativa para manipular las puntuaciones de los componentes temporalmente antes de que se analicen. De la misma manera, es útil concebir a la opción AGGREGATE como una opción para decidir cómo controlar las puntuaciones de los componentes antes de añadirlos a sus nuevos conjuntos.

      Conclusión

      En esta guía, se detallan varios comandos que se utilizan para crear y administrar conjuntos ordenados en Redis. Si desea ver en esta guía descripciones de otros comandos, argumentos o procedimientos relacionados, deje sus solicitudes o sugerencias en la sección de comentarios a continuación.

      Para obtener más información sobre los comandos de Redis, consulte nuestra serie de tutoriales Cómo administrar bases de datos de Redis.



      Source link

      How to Provision an Unmanaged Kubernetes Cluster using Terraform


      Updated by Linode

      Contributed by
      Linode

      Use Terraform, the popular orchestration tool by HaschiCorp, to deploy a Kubernetes cluster on Linode. Linode’s Terraform K8s module creates a Kubernetes cluster running on the CoreOS ContainerLinux operating system. After creating a Master and worker nodes, the module connects through SSH to these instances and installs kubeadm, kubectl, and other Kubernetes binaries to /opt/bin. It also handles initializing kubeadm, joining worker nodes to the master, and configuring kubectl. For the cluster’s container networking interface, Calico is installed. Finally, a kubectl admin config file is installed to the local environment, which you can use to connect to your cluster’s API server.

      Using Linode’s Terraform k8s module simplifies many of the steps involved in manually deploying a Kubernetes cluster with kubeadm. To learn more about kubeadm, see our Getting Started with Kubernetes: Use kubeadm to Deploy a Cluster on Linode guide.

      Note

      Currently, Linode’s Terraform k8s module only supports Kubernetes version 1.1.14. Development work to update this module is currently in progress. The latest updates can be found in the project’s corresponding GitHub repository.

      Before You Begin

      1. If you are new to Terraform, read through our A Beginner’s Guide to Terraform guide to familiarize yourself with key concepts.

      2. For an introduction to Kubernetes concepts, see our A Beginner’s Guide to Kubernetes series of guides.

      3. You need a personal access token for Linode’s v4 API to use with Terraform. Follow the Getting Started with the Linode API to get a token.

        Note

        When you create a personal access token ensure that you set Read/Write access because you are creating new Linode servers.

      4. Install Terraform on your computer.

        Note

      5. Install kubectl on your computer. You need kubectl to connect to and manage your Kubernetes cluster. Deployment of your cluster using this Terraform module fails if kubectl is not installed locally.

      In this Guide

      You will complete the following tasks:

      Configure your Local Environment

      Linode’s k8s Terraform module requires a local environment with a kubectl instance, a system-wide installation of Python, SSH keys, SSH keys configured with your SSH agent, and the sed and scp command line utilities. The module’s script preflight.sh verifies that all these requirements are installed on your local environment and generates a $var not found error if any of the tools are missing. This section shows how to install and configure kubectl, set up your SSH agent, and create an environment variable to store your API v4 token for easy reuse.

      If you receive an error that your system is missing Python, scp, or sed, use your operating system’s package manager to install the missing utilities.



      Create a Python Alias

      If your Python installation is invoked using python3, you can alias the command so that Terraform can execute scripts locally using Python as its interpreter.

      Using the text editor of your choice, edit your ~/.bashrc file to include the following alias:

      Then, reinitialize your ~/.bashrc file for the changes to take effect.

      source ~/.bashrc
      

      Install kubectl

      macOS:

      Install via Homebrew:

      brew install kubernetes-cli
      

      If you don’t have Homebrew installed, visit the Homebrew home page for instructions. Alternatively, you can manually install the binary; visit the Kubernetes documentation for instructions.

      Linux:

      1. Download the latest kubectl release:

        curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
        
      2. Make the downloaded file executable:

        chmod +x ./kubectl
        
      3. Move the command into your PATH:

        sudo mv ./kubectl /usr/local/bin/kubectl
        

      Note

      Windows:

      Visit the Kubernetes documentation for a link to the most recent Windows release.

      SSH Agent

      By default, Terraform uses your operating system’s SSH agent to connect to a Linode instance through SSH. This section shows how to run the SSH agent and add your SSH keys to it.

      1. Run your SSH agent with the following command:

        eval `ssh-agent`
        

        The output is similar to:

          
        Agent pid 11308
           
        
      2. Add your SSH keys to the agent. For more information, see creating an authentication key-pair. This command adds keys from the default location, ~/.ssh/

        ssh-add
        

        The output is similar to:

          
        Identity added: /home/example_user/.ssh/id_rsa (/home/example_user/.ssh/id_rsa)
           
        

      Create an API Token Environment Variable

      When you run terraform commands that need to communicate with Linode’s API v4, you need to issue the command along with your Linode token. In this section, you create an environment variable to store the token for easy reuse.

      1. Create the TF_VAR_linode_token environment variable to store your Linode API v4 token. Enter your token after the prompt.

        read -sp "Linode Token: " TF_VAR_linode_token # Enter your Linode Token (it will be hidden)
        export TF_VAR_linode_token
        

        Note

        To use your environment variable, add the -var flag. For example, when you run the terraform apply command, you would do so using:

        terraform apply -var linode_token=$LINODE_TOKEN
        

      Create your Terraform Configuration Files

      1. In the directory where you installed terraform, create a new directory to store your Kubernetes cluster’s configuration files.

        cd terraform
        mkdir k8s-cluster
        
      2. Using the text editor of your choice, create your cluster’s main configuration file named main.tf. Add the following contents to the file.

        ~/terraform/k8s-cluster/main.tf
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        
        module "k8s" {
          source             = "linode/k8s/linode"
          version            = "0.1.2"
          linode_token       = var.linode_token
          server_type_master = var.server_type_master
          server_type_node   = var.server_type_node
          cluster_name       = var.cluster_name
          k8s_version        = var.k8s_version
          region             = var.region
          nodes              = var.nodes
        }
              

        This file contains your cluster’s main configuration arguments. The only required configurations are source and linode_token. source calls Linode’s k8s module, while the linode_token will give you access to viewing, creating, and destroying Linode resources.

        The rest of the configurations are optional and have sane default values. In this example, however, you make use of Terraform’s input variables so that your main.tf configuration can be easily reused across different clusters, if desired.

      3. Create your input variables file, named variables.tf, with the example content.

        ~/terraform/k8s-cluster/variables.tf
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        
        variable "linode_token" {
          description = " Linode API token"
        }
        
        variable "server_type_master" {
          default     = "g6-standard-2"
          description = " Linode API token"
        }
        
        variable "cluster_name" {
          description = " Linode API token"
          default     = "example-cluster-1"
        }
        
        variable "server_type_node" {
          description = " Linode API token"
          default     = "g6-standard-1"
        }
        
        variable "k8s_version" {
          description = " Linode API token"
          default     = "v1.14.0"
        }
        
        variable "region" {
          description = "Values: us-east, ap-west, etc."
          default     = "us-east"
        }
        
        variable "nodes" {
          description = " Linode API token"
          default     = 3
        }
              

        The example file creates input variables which are referenced in your main configuration file that you created in the previous step. The values for those variables are assigned in a separate file in the next step. You can override the k8s module’s default values and provide your own defaults, as done in the example file. For more details about input variables, see the Input Variables section in our A Beginner’s Guide to Terraform guide.

      4. Create your input variables values file to provide your main configuration file with values that differ from your input variable file’s defaults.

        ~/terraform/k8s-cluster/terraform.tfvars
        1
        2
        3
        
        server_type_master = "g6-standard-4"
        cluster_name = "example-cluster-2"
              

        In this example, your cluster’s master node uses a g6-standard-4 Linode plan, instead of the default g6-standard-2, and the cluster_name is set to example-cluster-2, instead of example-cluster-1.

      Deploy Your Kubernetes Cluster

      1. Change to ~/terraform/k8s-cluster/ directory and initialize Terraform to install the Linode K8s module.

        terraform init
        
      2. Verify that Terraform creates your cluster’s resources as you expect them to be created before making any actual changes to your infrastructure. To do this, run the plan command:

        terraform plan
        

        This command generates a report detailing what actions Terraform will take to set up your Kubernetes cluster.

      3. If you are satisfied with the generated report, run the apply command to create your Kubernetes cluster. This command prompts you to confirm that you want to proceed.

        terraform apply -var-file="terraform.tfvars"
        

        After a few minutes, when Terraform has finished applying your configuration, it displays a report of what actions were taken and your Kubernetes cluster is ready for you to connect to it.

      Connect to Your Kubernetes Cluster with kubectl

      After Terraform finishes deploying your Kubernetes cluster, your ~/terraform/k8s-cluster/ directory should have a file named default.conf. This file contains your kubeconfig file. You can use kubectl, along with this file, to gain access to your Kubernetes cluster.

      1. Save your kubeconfig file’s path to the $KUBECONFIG environment variable. In the example command, the kubeconfig file is located in the Terraform directory you created at the beginning of this guide. Ensure that you update the command with the location of your default.conf file

        export KUBECONFIG=~/terraform/k8s-cluster/default.conf
        

        Note

        It is common practice to store your kubeconfig files in ~/.kube directory. By default, kubectl searches for a kubeconfig file named config that is located in the ~/.kube directory. You can specify other kubeconfig files by setting the $KUBECONFIG environment variable, as done in the step above.

      2. View your cluster’s nodes using kubectl.

        kubectl get nodes
        

        Note

        If your kubectl commands are not returning the resources and information you expect, then your client may be assigned to the wrong cluster context. Visit our Troubleshooting Kubernetes guide to learn how to switch cluster contexts.

        You are now ready to manage your cluster using kubectl. For more information about using kubectl, see Kubernetes’ Overview of kubectl guide.

      Persist the Kubeconfig Context

      If you open a new terminal window, it does not have access to the context that you specified using the previous instructions. This context information can be made persistent between new terminals by setting the KUBECONFIG environment variable in your shell’s configuration file.

      Note

      These instructions are for the Bash terminal. They are similar for other terminals that you may use:

      1. Navigate to the $HOME/.kube directory:

        cd $HOME/.kube
        
      2. Create a directory called configs within $HOME/.kube. You can use this directory to store your kubeconfig files.

        mkdir configs
        
      3. Copy your default.conf file to the $HOME/.kube/configs directory.

        cp ~/terraform/k8s-cluster/default.conf $HOME/.kube/configs/default.conf
        

        Note

        Optionally, you can give the copied file a different name to help distinguish it from other files in the configs directory.

      4. Open up your Bash profile (e.g. ~/.bashrc) in the text editor of your choice and add your configuration file to the $KUBECONFIG PATH variable.

        If an export KUBECONFIG line is already present in the file, append to the end of this line as follows; if it is not present, add this line to the end of your file:

        export KUBECONFIG=$KUBECONFIG:$HOME/.kube/config:$HOME/.kube/configs/default.conf
        
      5. Close your terminal window and open a new window to receive the changes to the $KUBECONFIG variable.

      6. Use the config get-contexts command for kubectl to view the available cluster contexts:

        kubectl config get-contexts
        

        You should see output similar to the following:

          
        CURRENT   NAME                                 CLUSTER             AUTHINFO           NAMESPACE
        *         [email protected]   example-cluster-1   kubernetes-admin
        
        
      7. If your context is not already selected, (denoted by an asterisk in the current column), switch to this context using the config use-context command. Supply the full name of the cluster (including the authorized user and the cluster):

        kubectl config use-context [email protected]
        

        You should see output similar to the following:

          
        Switched to context "[email protected]".
        
        
      8. You are now ready to interact with your cluster using kubectl. You can test the ability to interact with the cluster by retrieving a list of Pods. Use the get pods command with the -A flag to see all pods running across all namespaces:

        kubectl get pods -A
        

        You should see output like the following:

          
        NAMESPACE            NAME                                               READY   STATUS    RESTARTS   AGE
        kube-system          calico-node-5bkc6                                  2/2     Running   0          17m
        kube-system          calico-node-gp5ls                                  2/2     Running   0          17m
        kube-system          calico-node-grpnj                                  2/2     Running   0          17m
        kube-system          calico-node-qd85t                                  2/2     Running   0          17m
        kube-system          ccm-linode-mjgzz                                   1/1     Running   0          17m
        kube-system          coredns-fb8b8dccf-5tlbm                            1/1     Running   0          17m
        kube-system          coredns-fb8b8dccf-7tpgf                            1/1     Running   0          17m
        kube-system          csi-linode-controller-0                            3/3     Running   0          17m
        kube-system          csi-linode-node-gfd8m                              2/2     Running   0          17m
        kube-system          csi-linode-node-hrfnd                              2/2     Running   0          16m
        kube-system          csi-linode-node-q6fmd                              2/2     Running   0          17m
        kube-system          etcd-mytestcluster-master-1                        1/1     Running   0          16m
        kube-system          external-dns-7885f88564-tvpjf                      1/1     Running   0          17m
        kube-system          kube-apiserver-mytestcluster-master-1              1/1     Running   0          16m
        kube-system          kube-controller-manager-mytestcluster-master-1     1/1     Running   0          16m
        kube-system          kube-proxy-cs9tm                                   1/1     Running   0          17m
        kube-system          kube-proxy-qljn5                                   1/1     Running   0          17m
        kube-system          kube-proxy-sr5h8                                   1/1     Running   0          17m
        kube-system          kube-proxy-ww2tx                                   1/1     Running   0          17m
        kube-system          kube-scheduler-mytestcluster-master-1              1/1     Running   0          16m
        kube-system          kubernetes-dashboard-5f7b999d65-jk99z              1/1     Running   0          17m
        kube-system          metrics-server-58db9f9647-tz8f8                    1/1     Running   0          17m
        reboot-coordinator   container-linux-update-agent-6kgqm                 1/1     Running   0          16m
        reboot-coordinator   container-linux-update-agent-7nck5                 1/1     Running   0          17m
        reboot-coordinator   container-linux-update-agent-nhlxj                 1/1     Running   0          17m
        reboot-coordinator   container-linux-update-agent-vv8db                 1/1     Running   0          17m
        reboot-coordinator   container-linux-update-operator-5c9d67d4cf-78wbp   1/1     Running   0          17m
        
        

      More Information

      You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

      This guide is published under a CC BY-ND 4.0 license.



      Source link

      Cómo usar módulos Node.js con npm y package.json


      El autor seleccionó a Open Internet/Free Speech Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Debido a características como su rápido rendimiento de entrada y salida (E/S) y su sintaxis de JavaScript conocida, Node.js se convirtió velozmente en un entorno en tiempo de ejecución popular para desarrollo web de backend. Sin ambargo, a medida que crece el interés, se crean aplicaciones más grandes y se hace más difícil gestionar la complejidad de la base de código y sus dependencias. Node.js organiza esta complejidad usando módulos, que son archivos de JavaScript cualesquiera que contengan funciones u objetos que otros programas o módulos puedan usar. Las colecciones de uno o más módulos suelen citarse como paquetes y los administradores de paquetes los organizan.

      El administrador de paquetes de Node.js (npm) es el administrador de paquetes predeterminado y más popular del ecosistema de Node.js, y se utiliza principalmente para instalar y administrar módulos externos de proyectos de Node.js. También se suele utilizar para instalar una amplia variedad de herramientas de CLI y ejecutar secuencias de comandos de proyectos. npm realiza un seguimiento de los módulos instalados en un proyecto con el archivo package.json, que reside en el directorio de un proyecto y contiene lo siguiente:

      • Todos los módulos necesarios para un proyecto y sus versiones instaladas
      • Todos los metadatos de un proyecto, como el autor y la licencia, entre otros
      • Secuencias de comandos que se pueden ejecutar para automatizar tareas del proyecto

      Al crear proyectos más complejos de Node.js, administrar sus metadatos y dependencias con el archivo package.json, proporcionará compilaciones más previsibles, ya que todas las dependencias externas se mantienen iguales. El archivo hará un seguimiento de esta información de forma automática; si bien puede cambiar el archivo directamente para actualizar los metadatos de su proyecto, rara vez deberá interactuar con él directamente para administrar módulos.

      A través de este tutorial, gestionará paquetes con npm. El primer paso será crear y comprender el archivo package.json. Luego, lo usará para realizar un seguimiento de todos los módulos que instale en su proyecto. Por último, enumerará las dependencias de sus paquetes, los actualizará, los desinstalará y realizará una auditoría para detectar errores de seguridad en ellos.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: Crear un archivo package.json

      El primer paso de este tutorial es establecer el proyecto de ejemplo: un módulo locator ficticio de Node.js que obtiene la dirección IP del usuario y muestra el país de origen. En este tutorial, no codificará el módulo. Sin embargo, los paquetes que administre serían pertinentes si lo desarrollara.

      Primero, creará un archivo package.json para almacenar los metadatos útiles sobre el proyecto y como ayuda para administrar los módulos de Node.js dependientes del proyecto. Como sugiere el sufijo, este es un archivo JSON (notación de objetos JavaScript). JSON es un formato estándar que se utiliza para compartir, basado en objetos de JavaScript, y consta de datos almacenados como pares clave-valor. Si desea obtener más información sobre JSON, consulte nuestro artículo Introducción a JSON.

      Debido a que un archivo package.json contiene numerosas propiedades, puede ser engorroso crearlo manualmente, sin copiar ni pegar una plantilla desde otro sitio. Para facilitar las cosas, npm proporciona el comando init. Se trata de un comando interactivo que le formula una serie de preguntas y crea un archivo package.json basado en sus respuestas.

      Usar el comando init

      Primero, configure un proyecto para poder poner en práctica la administración de módulos. En su shell, cree una nueva carpeta llamada locator:

      Luego, posiciónese en la nueva carpeta:

      Ahora, inicie el comando interactivo ingresando lo siguiente:

      Nota: Si en su código se usará Git para el control de versiones, cree el repositorio de Git primero y luego ejecute npm init. El comando entiende de forma automática que se encuentra en una carpeta habilitada para Git. Si se configura un Git remoto, completa de forma automática el repositorio, los errores y los campos de la página de inicio de su archivo package.json. Si inicializó el repositorio después de crear el archivo package.json, deberá añadir esta información de forma manual. Para obtener más información sobre el control de versiones de Git, consulte nuestra serie Git: Instalación, uso y ramificaciones.

      Recibirá el siguiente resultado:

      Output

      This utility will walk you through creating a package.json file. It only covers the most common items, and tries to guess sensible defaults. See `npm help json` for definitive documentation on these fields and exactly what they do. Use `npm install <pkg>` afterwards to install a package and save it as a dependency in the package.json file. Press ^C at any time to quit. package name: (locator)

      Primero, se le solicitará el valor de name de su nuevo proyecto. Por defecto, el comando prevé que es el nombre de la carpeta en la que usted se encuentra. Los valores predeterminados de cada propiedad se muestran entre paréntesis (). Debido a que el valor predeterminado de name funciona para este tutorial, presione ENTER para aceptarlo.

      El siguiente valor que se debe introducir es version. Junto con name, este campo se requiere si su proyecto se compartirá con otros en el repositorio de paquetes npm.

      Nota: Se espera que los paquetes de Node.js sigan la guía de Versionamiento semántico (semver). Por lo tanto, el primer número será el de versión MAJOR, que solo cambia cuando se modifica la API. El segundo número será el de versión MINOR, que cambia cuando se añaden funciones. El último número será el de versión de PATCH, que cambia cuando se solucionan errores.

      Pulse INTRO para aceptar la versión predeterminada.

      El siguiente campo es description: una cadena útil para explicar lo que hace su módulo de Node.js. Nuestro proyecto ficticio locator obtendría la dirección IP del usuario y mostraría el país de origen. Un campo description adecuado sería Finds the country of origin of the incoming request​​​; por lo tanto, ingrese algo similar y presione INTRO. El campo description es muy útil cuando las personas buscan su módulo.

      En la siguiente solicitud se pedirá el entry point. Si alguien instala y usa requires para su módulo, lo que configure en entry point será lo primero que se cargará de su programa. El valor debe ser la ubicación relativa de un archivo de JavaScript, y se añadirá a la propiedad main de package.json. Pulse INTRO para conservar el valor predeterminado.

      Nota: La mayoría de los módulos tienen un archivo index.js como punto de entrada principal. Este es el valor predeterminado de la propiedad main de un package.json, que es el punto de entrada para los módulos npm. Si no encuentra package.json, Node.js intentará cargar index.js por defecto.

      A continuación, se le solicitará un test command, una secuencia de comandos ejecutable o un comando para ejecutar las pruebas de su proyecto. En muchos módulos populares de Node.js, las pruebas se escriben y ejecutan con Mocha, Jest, Jasmine u otros marcos de pruebas. Dado que las pruebas se encuentran fuera del alcance de este artículo, por ahora deje esta opción vacía y presione INTRO para continuar.

      Luego, el comando init solicitará el repositorio GitHub del proyecto. En este ejemplo, no lo usará. Por lo tanto, déjelo vacío también.

      Después del repositorio, el comando solicita keywords. Esta propiedad es una serie de cadenas con términos útiles que las personas pueden usar para encontrar su repositorio. Se recomienda tener un pequeño conjunto de palabras claves realmente relevantes para su proyecto, a fin de direccionar más la búsqueda. Enumere estas palabras claves como cadena, separando cada valor con una coma. Para este proyecto de ejemplo, ingrese ip,geo,country cuando se le solicite. El package.json terminado tendrá tres elementos en la matriz de keywords.

      El siguiente campo de la solicitud es author. Es útil para los usuarios de su módulo que quieran ponerse en contacto con usted. Por ejemplo, si alguien descubre una vulnerabilidad de seguridad en su módulo, puede usarlo para indicarle el problema, a fin de que pueda solucionarlo. El campo author es una cadena que tiene el siguiente formato:  "Name <Email> (Website)".  Por ejemplo, “Sammy <sammy@your_domain> (https://your_domain)" es un autor válido. Los datos de correo electrónico y sitio web son optativos: un autor válido puede ser, simplemente, un nombre. Añada sus datos de contacto como autor y confírmelos con INTRO.

      Por último, se le solicitará indicar la license. Con esto, se determinan los permisos legales y las limitaciones que los usuarios tendrán al usar su módulo. Muchos módulos de Node.js son de código abierto. Por lo tanto, npm establece ISC como valor predeterminado.

      En este punto, revisaría sus opciones de concesión de licencias y decidirá lo mejor para su proyecto. Para obtener más información sobre los diferentes tipos de licencias de código abierto, consulte esta lista de licencias de la Open Source Initiative. Si no desea proporcionar una licencia para un repositorio privado, puede escribir UNLICENSED en la solicitud. Para este ejemplo, utilice la licencia ISC predeterminada y presione INTRO para terminar este proceso.

      El comando init ahora mostrará el archivo package.json que creará. Tendrá un aspecto similar a este:

      Output

      About to write to /home/sammy/locator/package.json: { "name": "locator", "version": "1.0.0", "description": "Finds the country of origin of the incoming request", "main": "index.js", "scripts": { "test": "echo "Error: no test specified" && exit 1" }, "keywords": [ "ip", "geo", "country" ], "author": "Sammy <sammy@your_domain> (https://your_domain)", "license": "ISC" } Is this OK? (yes)

      Una vez que la información coincida con lo que ve aquí, presione INTRO para completar el proceso y crear el archivo package.json. Con este archivo, puede llevar un registro de los módulos que instale para su proyecto.

      Ahora que tiene su archivo package.json, puede probar la instalación de módulos en el siguiente paso.

      Paso 2: Instalar módulos

      En el desarrollo de software, es habitual usar bibliotecas externas para realizar tareas auxiliares en los proyectos. Esto permite que el desarrollador se centre en la lógica empresarial y cree la aplicación de forma más rápida y eficiente.

      Por ejemplo, si el módulo locator de nuestro ejemplo tuviera que hacer una solicitud de API externa para obtener datos geográficos, podríamos usar una biblioteca HTTP para facilitar esa tarea. Debido a que nuestro objetivo principal es devolver al usuario datos geográficos pertinentes, podríamos instalar un paquete que nos facilite las solicitudes HTTP en lugar de tener que volver a escribir este código nosotros mismos, una tarea que va más allá del alcance de nuestro proyecto.

      Veamos este ejemplo. En su aplicación locator, usará la biblioteca axios, que lo ayudará a realizar solicitudes HTTP. Instálela ingresando lo siguiente en su shell:

      Este comando se inicia con npm install, que instalará el paquete (para abreviar, puede usar npm i). Luego, enumere los paquetes que desea instalar, separados por un espacio. En este caso, es axios. Por último, finalice el comando con el parámetro opcional --save, que especifica que axios se guardará como dependencia del proyecto.

      Cuando se instale la biblioteca, verá un resultado similar al siguiente:

      Output

      ... + axios@0.19.0 added 5 packages from 8 contributors and audited 5 packages in 0.764s found 0 vulnerabilities

      Ahora, abra el archivo package.json con el editor de texto que prefiera. En este tutorial, se usará nano:

      Verá una nueva propiedad, resaltada en lo siguiente:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        }
      }
      

      La opción --save indicó a npm que actualizara package.json con el módulo y la versión que se acaba de instalar. Esto es muy positivo, ya que otros desarrolladores que trabajen en sus proyectos podrán ver fácilmente las dependencias externas necesarias.

      Nota: Seguramente haya observado el ^ antes del número de versión de la dependencia axios. Recuerde que el control de versiones semántico consta de tres dígitos: MAJOR, MINOR y PATCH. El símbolo ^ indica que cualquier versión MINOR o PATCH superior cumpliría con esta restricción de versión. Si ve ~ al comienzo de un número de versión, solo las versiones PATCH superiores satisfacen la restricción.

      Cuando termine de revisar package.json, cierre el archivo.

      Dependencias de desarrollo

      Los paquetes que se utilizan para desarrollar proyectos, pero no para crearlos o ejecutarlos en producción, se conocen como dependencias de desarrollo. No son necesarios para que su módulo o aplicación funcionen en producción, pero pueden ser útiles al escribir el código.

      Por ejemplo, es común que los desarrolladores utilicen linters de código para asegurarse de que su código siga las prácticas recomendadas y mantener un estilo uniforme. Si bien esto es útil para el desarrollo, solo aumenta el tamaño del código que puede distribuirse y no proporciona un beneficio tangible cuando se implementa en producción.

      Instale un linter como dependencia de desarrollo para su proyecto. Pruebe esto en su shell:

      • npm i eslint@6.0.0 --save-dev

      En este comando, utilizó el indicador --save-dev. Este indicador guardará eslint como una dependencia que solo se requiere para el desarrollo. Tenga en cuenta, también, que añadió @6.0.0 al nombre de su dependencia. Cuando los módulos se actualizan, se etiquetan con una versión. La @ indica a npm que busque una etiqueta específica del módulo que está instalando. Si no se especifica una etiqueta, npm instala la última versión etiquetada. Vuelva a abrir package.json:

      Con esto, se mostrará lo siguiente:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        },
        "devDependencies": {
          "eslint": "^6.0.0"
        }
      }
      

      eslint se guardó como devDependencies, junto con el número de versión que especificó anteriormente. Cierre package.json.

      Archivos generados de forma automática: node_modules y package-lock.json

      La primera vez que se instala un paquete en un proyecto de Node.js, npm crea la carpeta node_modules para almacenar los módulos necesarios para su proyecto y el archivo package-lock.json que examinó antes.

      Confirme que estén presentes en su directorio de trabajo. En su shell, escriba ls y presione INTRO. Verá el siguiente resultado:

      Output

      node_modules package.json package-lock.json

      La carpeta node_modules contiene todas las dependencias instaladas de su proyecto. En la mayoría de los casos, no debe confirmar esta carpeta en su repositorio de versiones controladas. A medida que instale más dependencias, el tamaño de esta carpeta aumentará rápidamente. Además, el archivo package-lock.json lleva un registro de las versiones exactas instaladas de forma más concisa. Por lo tanto, no es necesario incluir node_modules.

      Si bien el archivo package.json enumera dependencias que indican las versiones adecuadas que se deben instalar en el proyecto, el archivo package-lock.json hace un seguimiento de todos los cambios que se realizan en package.json o node_modules y nos indica la versión exacta del paquete instalado. En general, confirma esto en su repositorio de versiones controladas, en lugar de node_modules, dado que es una representación más clara de todas sus dependencias.

      Realizar la instalación desde package.json

      Con sus archivos package.json y package-lock.json, puede configurar rápidamente las mismas dependencias del proyecto antes de comenzar a desarrollar uno nuevo. Para demostrarlo, suba un nivel en su árbol de directorios y cree una nueva carpeta denominada cloned_locator en el mismo nivel de directorio de locator:

      • cd ..
      • mkdir cloned_locator

      Posiciónese en su nuevo directorio:

      Ahora, copie los archivos package.json y package-lock.json de locator a cloned_locator:

      • cp ../locator/package.json ../locator/package-lock.json .

      Para instalar los módulos requeridos para este proyecto, escriba lo siguiente:

      npm buscará un archivo package-lock.json para instalar los módulos. Si no hubiera ningún archivo de bloqueo disponible, leería el archivo package.json para determinar las instalaciones. En general, la instalación se puede realizar de manera más rápida desde package-lock.json, ya que el archivo de bloqueo contiene la versión exacta de los módulos y sus dependencias, lo cual significa que npm no tiene que invertir tiempo en determinar una versión adecuada para la instalación.

      Al momento de la implementación en producción, tal vez prefiera omitir las dependencias de desarrollo. Recuerde que las dependencias de desarrollo se almacenan en la sección devDependencies de package.json y que no afectan el funcionamiento de su aplicación. Al instalar módulos como parte del proceso de CI y CD para implementar su aplicación, omita las dependencias de desarrollo ejecutando lo siguiente:

      El indicador --production ignora la sección devDependencies durante la instalación. Por ahora, siga adelante con su compilación de desarrollo.

      Antes de pasar a la siguiente sección, regrese a la carpeta locator:

      Instalaciones globales

      Hasta ahora, instaló módulos npm para el proyecto locator. npm también le permite instalar paquetes de forma global. Esto significa que el paquete está disponible para su usuario en el sistema más amplio, como cualquier otro comando shell. Esta capacidad es útil para muchos módulos de Node.js que son herramientas de CLI.

      Por ejemplo, tal vez desee hacer un blog sobre el proyecto locator en el que trabaja actualmente.  Para hacerlo, puede usar una biblioteca como Hexo para crear y administrar su blog de sitio web estático. Instale la CLI de Hexo de forma global, como se indica a continuación:

      Para instalar un paquete de forma global, anexe el indicador -g al comando.

      Nota: Si observa un error de permiso al intentar instalar este paquete de forma global, es posible que su sistema requiera privilegios de superusuario para ejecutar el comando. Vuelva a probar con sudo npm i hexo-cli -g.

      Pruebe que el paquete se haya instalado de forma correcta escribiendo lo siguiente:

      Verá un resultado similar a este:

      Output

      hexo-cli: 2.0.0 os: Linux 4.15.0-64-generic linux x64 http_parser: 2.7.1 node: 10.14.0 v8: 7.6.303.29-node.16 uv: 1.31.0 zlib: 1.2.11 ares: 1.15.0 modules: 72 nghttp2: 1.39.2 openssl: 1.1.1c brotli: 1.0.7 napi: 4 llhttp: 1.1.4 icu: 64.2 unicode: 12.1 cldr: 35.1 tz: 2019a

      Hasta ahora, aprendió a instalar módulos con npm. Puede instalar paquetes en un proyecto de forma local, ya sea como dependencia de producción o de desarrollo. También puede instalar paquetes basados en archivos package.json o package-lock.json preexistentes, lo que le permite realizar desarrollos con las mismas dependencias que sus pares. Por último, puede usar el indicador -g para instalar paquetes de forma global, a fin de poder acceder a ellos independientemente de que se encuentre en un proyecto de Node.js o no.

      Ahora que puede instalar módulos, en la siguiente sección, practicará técnicas para administrar sus dependencias.

      Paso 3: Administrar módulos

      Un administrador de paquetes completo puede hacer mucho más que instalar módulos. npm tiene más de 20 comandos disponibles relacionados con la administración de dependencias. En este paso, hará lo siguiente:

      • Enumerará módulos que instaló.
      • Actualizará módulos a una versión más reciente.
      • Desinstalará los módulos que ya no necesite.
      • Ejecutará una auditoría de seguridad en sus módulos para encontrar y solucionar errores de seguridad.

      Si bien estos ejemplos se ejecutarán en su carpeta locator, todos estos comandos se pueden ejecutar de forma global añadiéndoles el indicador -g al final, exactamente lo mismo que hizo al realizar la instalación global.

      Enumerar módulos

      Si quisiera saber qué módulos se instalan en un proyecto, sería más fácil usar el comando list o ls en lugar de leer directamente package.json. Para hacerlo, ingrese lo siguiente:

      Verá un resultado similar a este:

      Output

      ├─┬ axios@0.19.0 │ ├─┬ follow-redirects@1.5.10 │ │ └─┬ debug@3.1.0 │ │ └── ms@2.0.0 │ └── is-buffer@2.0.3 └─┬ eslint@6.0.0 ├─┬ @babel/code-frame@7.5.5 │ └─┬ @babel/highlight@7.5.0 │ ├── chalk@2.4.2 deduped │ ├── esutils@2.0.3 deduped │ └── js-tokens@4.0.0 ├─┬ ajv@6.10.2 │ ├── fast-deep-equal@2.0.1 │ ├── fast-json-stable-stringify@2.0.0 │ ├── json-schema-traverse@0.4.1 │ └─┬ uri-js@4.2.2 ...

      Por defecto, Is muestra todo el árbol de dependencias: los módulos de los que depende su proyecto y los módulos de los que dependen sus dependencias. Puede ser algo engorroso si desea obtener una descripción general de alto nivel de lo que se instala.

      Para imprimir únicamente los módulos que instaló sin sus dependencias, ingrese lo siguiente en su shell:

      El resultado será el siguiente:

      Output

      ├── axios@0.19.0 └── eslint@6.0.0

      La opción --depth le permite especificar el nivel del árbol de dependencias que desea ver. Cuando es 0, solo se ven dependencias de nivel superior.

      Actualizar módulos

      Se le recomienda mantener sus módulos npm actualizados. Al hacerlo, tiene más posibilidades de acceder a las últimas correcciones de seguridad para ellos. Utilice el comando outdated para verificar si hay actualizaciones para alguno de sus módulos:

      Obtendrá un resultado similar al siguiente:

      Output

      Package Current Wanted Latest Location eslint 6.0.0 6.7.1 6.7.1 locator

      Con este comando, primero se enumeran el Package (paquete) que está instalado y la versión Current (actual). En la columna Wanted (deseado), se muestra la versión que cumple su requisito de versión en package.json. La columna Latest (última) muestra la versión más reciente del módulo que se publicó.

      La columna Location (ubicación) indica dónde se encuentra el paquete en el árbol de dependencias. El comando outdated tiene el indicador --depth como Is. Por defecto, la profundidad es 0.

      Parece que puede actualizar eslint a una versión más reciente. Utilice los comandos update o up como se indica a continuación:

      El resultado del comando contendrá la versión instalada:

      Output

      npm WARN locator@1.0.0 No repository field. + eslint@6.7.1 added 7 packages from 3 contributors, removed 5 packages, updated 19 packages, moved 1 package and audited 184 packages in 5.818s found 0 vulnerabilities

      Si quisiera actualizar todos los módulos a la vez, debería ingresar lo siguiente:

      Desinstalar módulos

      El comando uninstall de npm se utiliza para eliminar módulos de sus proyectos. Esto significa que el módulo ya no se instalará en la carpeta node_modules ni se verá en sus archivos package.json y package-lock.json.

      Eliminar dependencias de un proyecto es una actividad normal del ciclo de vida de desarrollo de software. Es posible que una dependencia no resuelva el problema tal como se anuncia o que no proporcione una experiencia de desarrollo satisfactoria.  En estos casos, es mejor que desinstale la dependencia y cree su propio módulo.

      Imagine que axios no proporciona la experiencia de desarrollo que hubiera deseado para realizar solicitudes HTTP. Desinstale axios con el comando uninstall o un ingresando lo siguiente:

      El resultado será similar a este:

      Output

      npm WARN locator@1.0.0 No repository field. removed 5 packages and audited 176 packages in 1.488s found 0 vulnerabilities

      No se indica de forma explícita que se eliminó axios. Para verificar que se haya desinstalado, vuelva a enumerar las dependencias una vez más:

      Ahora, se ve que solo eslint está instalado:

      Output

      └── eslint@6.7.1

      Esto indica que desinstaló el paquete axios de forma exitosa.

      Auditar módulos

      npm proporciona un comando audit para resaltar posibles riesgos de seguridad de sus dependencias. Para ver la auditoría en acción, instale una versión obsoleta del módulo request ejecutando lo siguiente:

      Cuando instale esta versión obsoleta de request, obtendrá un resultado similar al siguiente:

      Output

      + request@2.60.0 added 54 packages from 49 contributors and audited 243 packages in 7.26s found 6 moderate severity vulnerabilities run `npm audit fix` to fix them, or `npm audit` for details

      npm le indica que hay vulnerabilidades en sus dependencias. Para obtener más información, audite todo el proyecto con lo siguiente:

      Con el comando audit se muestran tablas de resultados en las que se resaltan errores de seguridad:

      Output

      === npm audit security report === # Run npm install request@2.88.0 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request > tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/598 │ └───────────────┴──────────────────────────────────────────────────────────────┘ # Run npm update request --depth 1 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Remote Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/309 │ └───────────────┴──────────────────────────────────────────────────────────────┘ ...

      Puede ver la ruta de la vulnerabilidad y, a veces, npm le ofrece formas de corregirla. Puede ejecutar el comando update, como se sugiere, o el subcomando fix de audit. En su shell, ingrese lo siguiente:

      Verá un resultado similar a este:

      Output

      + request@2.88.0 added 19 packages from 24 contributors, removed 32 packages and updated 12 packages in 6.223s fixed 2 of 6 vulnerabilities in 243 scanned packages 4 vulnerabilities required manual review and could not be updated

      npm pudo actualizar de forma segura dos de los paquetes, lo que redujo sus vulnerabilidades en la misma cantidad. Sin embargo, aún tiene cuatro vulnerabilidades en sus dependencias. El comando audit fix no siempre soluciona todos los problemas. Si bien la versión de un módulo puede tener una vulnerabilidad de seguridad, si lo actualiza a una versión con una API diferente podría desglosar el código en un nivel más alto del árbol de dependencias.

      Puede usar el parámetro --force para garantizar que se hayan eliminado las vulnerabilidades, como se indica a continuación:

      Como se mencionó anteriormente, esto no se recomienda a menos que esté seguro de que la funcionalidad no se verá afectada.

      Conclusión

      A lo largo de este tutorial, realizó varios ejercicios para demostrar cómo se organizan los módulos de Node.js en paquetes y la forma en que npm los gestiona. En un proyecto de Node.js, utilizó paquetes npm como dependencias creando y manteniendo un archivo package.json: un registro de los metadatos de su proyecto que incluye los módulos que instaló. También utilizó la herramienta CLI de npm para instalar, actualizar y eliminar módulos, así como para enumerar el árbol de dependencias de sus proyectos y verificar y actualizar los módulos obsoletos.

      En el futuro, aprovechar el código existente usando módulos acelerará el tiempo de desarrollo, dado que no es necesario que repita funcionalidades. También podrá crear sus propios módulos npm y estos, a su vez, serán gestionados por otros a través de comandos npm.  En cuanto a los siguientes pasos, experimente con lo que aprendió en este tutorial instalando y probando los diferentes paquetes disponibles. Vea lo que se ofrece en el ecosistema para facilitar la resolución de problemas. Por ejemplo, puede probar TypeScript, un supraconjunto de JavaScript, o convertir su sitio web en aplicaciones móviles con Cordova. Si desea obtener más información sobre Node.js, consulte nuestros otros tutoriales de Node.js.



      Source link