Tabla de Contenidos

Copiar ficheros por scp
Ejecutar ordenes en servidores remotos
Variables de entorno
Parámetros del Script
Interpretar las Variables de Bash
Conexión con claves pública/privada
Cortafuegos
Instalar Java JDK
Instalar NodeJS
Java vs NodeJS
Unicode
UTF-8

1. Repaso de sistemas

Antes de empezar el proyecto vamos a repasar conceptos de sistemas.

Copiar ficheros por scp
Ejecutar ordenes en servidores remotos
Variables de entorno
Parámetros del Script
Interpretar las Variables de Bash
Conexión con claves pública/privada
Cortafuegos
Instalar Java JDK
Instalar NodeJS
Unicode
UTF-8

Copiar ficheros por scp

Para copiar ficheros locales a un servidor remoto se usa la sintaxis:

scp /mi_carpeta_local/mi_fichero mi_usuario_remoto@ip_remota:/mi_carpeta_remota

Ejemplo para copiar el fichero local /home/logongas/app.jar en la máquina remota 192.168.1.1 en la carpeta /opt usando el usuario remoto logongas:

scp /home/logongas/app.jar logongas@192.168.1.1:/opt

Para copiar ficheros remoto en una carpeta local se usa la sintaxis:

scp mi_usuario_remoto@ip_remota:/mi_carpeta_remota/mi_fichero /mi_carpeta_local

Ejemplo para copiar el fichero remoto app.jar que está en /opt en la máquina remota 192.168.1.1 y guardarlo en nuestra carpeta local /home/logongas usando el usuario remoto logongas:

scp logongas@192.168.1.1:/opt/app.jar /home/logongas

Ejecutar ordenes en servidores remotos

Para ejecutar ordenes en ordenadores remoto se usa la sintaxis:

ssh mi_usuario_remoto@ip_remota "comando"

Ejemplo de crear el directorio /home/logongas/miapp en la máquina remota 192.168.1.1 usando el usuario remoto logongas:

  ssh logongas@192.168.1.1 "mkdir /home/logongas/miapp"

Variables de entorno

Es posible personalizar los scripts en Bash usando variables de entorno.

Ejemplo de declaración de variables

  USER_NAME=logongas
  IP_SERVER=192.168.1.1

Para usar las variables se usa ${} y dentro de las llaves el nombre de la variable. Tambien se puede usar solo $ delante del nombre de la variable.

Ejemplo de uso de las variables

scp /home/logongas/app.jar ${USER_NAME}@$IP_SERVER:/opt

Podemos tener en un fichero externo las variables.

Ejemplo de config.env

  USER_NAME=logongas
  IP_SERVER=192.168.1.1

Para cargar un fichero de variables se usa el comando source.

Ejemplo de cargar las variables de config.env

source config.env

Parámetros del Script

Los Script de bash pueden tener parámetros, para acceder a ellos se usa $1, $2, $3, etc. siendo cada uno de ellos la posición del parámetro.

Ejemplo de script con 1 parámetro

./deploy.sh config.env

Continuando con el ejemplo se usar $1 para acceder al parámetro

echo El primera parámetro es $1

source $1

Interpretar las Variables de Bash

Al pasar argumentos a un script se puede hacer de varias maneras.

Imaginemos el script test.sh, que muestra por pantalla el primer argumento

#!/bin/bash
echo $1

Y ahora lo vamos a ejecutar de 3 formas distintas:

a=Hola
b=Adios
./test.sh $a $b
./test.sh '$a $b'
./test.sh "$a $b"
./test.sh "$a \$b"

¿Va a mostrar siempre Hola?

Veamos el resultado:

Hola
$a $b
Hola Adios
Hola $b

¿Qué es lo que ha pasado?

Parametros	Resultados	Explicación
`$a $b`	`Hola`	Lo toma como 2 argumentos separados y solo muestra `Hola` porque solo se muestra el primer argumento
`'$a $b'`	`$a $b`	Todo ahora es un único argumento, pero con la peculiaridad de que no interpreta las variables (y otras cosas) de BASH
`"$a $b"`	`Hola Adios`	Todo ahora es un único argumento, pero si que se interpretan las variables de bash
`"$a \$b"`	`Hola $b`	Todo ahora es un único argumento, pero si que se interpretan las variables de bash aunque no se evalúa la variable `$b` ya que está escapada con `\`.

Conexión con claves pública/privada

Para conectarse a un servidor, ya no se usan contraseñas sino que se crear pares de claves (una pública y otra privada).

Para generar el par de claves se usa la orden ssh-keygen.

Generar el par de clave con formato RSA con una logitud de 4096 bits, con el correo juan@alumno.fpmislata.com y que se genera el par de claves en los ficheros $HOME/.ssh/id_rsa y $HOME/.ssh/id_rsa.pub

ssh-keygen -f $HOME/.ssh/id_rsa -t rsa -b 4096 -C "juan@alumno.fpmislata.com"

Esa orden genera 2 ficheros:

$HOME/.ssh/id_rsa: Es la clave privada
$HOME/.ssh/id_rsa.pub: Es la clave pública que hay que copiar en el servidor al que nos queremos conectar

Ejemplo de Contenido de los ficheros

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC9aN2Srvty5Yc+GmV7JBTxDS4OYuqCjsJc0i09u58ULxlnmWOn2awvEv3HQfCNEukhzQl0kdvN/lNHmrswE8SqnbRuqbqCOE4Hntzx3aMeypc2SHN/v88VzUnnRrz++3EDq90d0WAStRRb2IH2k1WT56UdSr32ovf1Wd3JdMvoI/nojEHJl/j9DsT4jXkp/iYSknLlvpJvqH0pjcKD1NlkZQAO+5n/pVPVJtJFwd0wvaWhlugdv0JnzXKNiuTvpdvbpVx6ynPVn59XhGW6wOne6ou6umDG4AdEfi8QGgMCrjibw8uIs6qTCOKOuw0N6+Hiw3TmeB3rLtsGCqwPTvhcmi6NzV/9v1NPUrBZ+MauoJKw4FPNi3YNZ1a4MLb9mF/KOlwQn9/5a7omYkxGpPMIbFQcQVN6JsBE7Fr+6qT/LCGdqEasCU5hTIkF0CqZJ5SxTtjhQ3N3lmgZoBHDktQKM6LElO/w/Bt1pio4OZqcQoW71gpNQ5r8fJvwN/XpajEeXVqFDqZYzB8UQ74zaplUJMk77ixUzChZq8FL0zBuie4Bht+vDPMJBUbo+YG6zSdauVnb+QzRGeRqLx9j336tKRpIIWDkQ78CQ1tGYsxEWEtVEVLl3EasT+v+/Y2IpfwAaaCiqwGqITG9lQ4gS1Q571J7c6J8/1Y21HhyGBiHnQ== juan@alumno.fpmislata.com

Ahora tenemos que ir al servidor remoto al que nos queremos conectar e ir a la carpeta del usuario al que nos queremos conectar. Y añadir al fichero $HOME/.ssh/authorized_keys el contenido de nuestra clave publica

En el siguiente ejemplo vemos que ya existe una clave y añadimos la nueva que acabamos de crear.

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDEq0zGyX+fP1av8Si9ywOhX2XaWKp/cUaLuFSp0mz0u8mAYoiKojOygBmwJgxwXIMtyHZBCV3ijJlyRaXOLcq+ii3NrPu1hZ7NQGqJRkMXiYcm8BUaJSajHzguOA01a9mE8rOcklmUtroFH9TcgH6BUSfNNnQJ7wZQ4EgQG6sdYODbd299FL8FC9xnfrCpNiuq0nt4qEUEoNeRHSDh8KQt02j0DqNYhKikeEMobATjuwTJQjNLACNWh+VXvv1hX12xV79voMoDwUVhPI4GlnOVUdz11ot3RK/j5kNT0IQtjU+iS4DfXeZ6UHvcPikH4zS/007bMf24TB2t/9sz7CXhd78JSpplLbh28EVR7YnqeKfzMqTGWMHpYCvPupjQpCwOAcdhPox5QU0yWu07QRU+efjH2GpUaIzB+RqcgV8ENgAj0Ua5RmjkAz0j4OrzttcIyEsdpJoYGiFw8g+6mR44gSLZ2d5nN+9B3x80pJwzc12UG5Pt/wPn0YI0s5YAJoHsV9dXd+q8xvc9m4M70pCLFfDL94k08Q+0WYQFQhpTl/n/0b4HyvwMK1pAA3CmCcXgfkRppjtsbHkF8nyBDhhXGa4ESEUUk0PlxEDyfmYUtfOjNvUSVZ/LByCZOqds0XWmyuDJq+EQAMwBAcwQtKAnhYnB59OHua+hHIw13suOaw== pedro@alumno.fpmislata.com
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC9aN2Srvty5Yc+GmV7JBTxDS4OYuqCjsJc0i09u58ULxlnmWOn2awvEv3HQfCNEukhzQl0kdvN/lNHmrswE8SqnbRuqbqCOE4Hntzx3aMeypc2SHN/v88VzUnnRrz++3EDq90d0WAStRRb2IH2k1WT56UdSr32ovf1Wd3JdMvoI/nojEHJl/j9DsT4jXkp/iYSknLlvpJvqH0pjcKD1NlkZQAO+5n/pVPVJtJFwd0wvaWhlugdv0JnzXKNiuTvpdvbpVx6ynPVn59XhGW6wOne6ou6umDG4AdEfi8QGgMCrjibw8uIs6qTCOKOuw0N6+Hiw3TmeB3rLtsGCqwPTvhcmi6NzV/9v1NPUrBZ+MauoJKw4FPNi3YNZ1a4MLb9mF/KOlwQn9/5a7omYkxGpPMIbFQcQVN6JsBE7Fr+6qT/LCGdqEasCU5hTIkF0CqZJ5SxTtjhQ3N3lmgZoBHDktQKM6LElO/w/Bt1pio4OZqcQoW71gpNQ5r8fJvwN/XpajEeXVqFDqZYzB8UQ74zaplUJMk77ixUzChZq8FL0zBuie4Bht+vDPMJBUbo+YG6zSdauVnb+QzRGeRqLx9j336tKRpIIWDkQ78CQ1tGYsxEWEtVEVLl3EasT+v+/Y2IpfwAaaCiqwGqITG9lQ4gS1Q571J7c6J8/1Y21HhyGBiHnQ== juan@alumno.fpmislata.com

Por último para conectarnos al servidor con ssh o scp deberemos indicar el fichero de la clave privada y para ello se usará el parámetro -i.

Ejemplo con ssh indicado que la clave privada a usar está en $HOME/.ssh/id_rsa

ssh -i $HOME/.ssh/id_rsa logongas@192.168.1.1 "mkdir /home/logongas/miapp"

Ejemplo con scp indicado que la clave privada a usar está en $HOME/.ssh/id_rsa

scp -i $HOME/.ssh/id_rsa /home/logongas/app.jar admin@192.168.1.1:/opt

Si guardamos nuestro par de claves con los nombres de $HOME/.ssh/id_rsa y $HOME/.ssh/id_rsa.pub se usarán por defecto al conectarnos a cualquier servidor y no hará falta indicar que las usemos.

Por otro lado en el fichero $HOME/.ssh/config podemos especificar para cada servidor la clave que queremos usar.

Host servidor.ejemplo.com
    User usuario
    IdentityFile /ruta/de/mi_clave_privada

Por lo tanto las 3 reglas (en orden de prioridad) para saber que clave privada usar son:

Se indica en el propio comando ssh o scp con -i
Se indica en el fichero $HOME/.ssh/config para cada servidor
Se usa $HOME/.ssh/id_rsa
La clave añadida con ssh-agent (No explicada)

El fichero con la clave privada obligatoriamente debe solo puede tener permisos el propio usuario por lo que hay que ejecutar:

chmod 600 id_rsa

Cortafuegos

Para que funcione la aplicación, es necesario abrir los puertos. Para ello se usa la orden ufw allow numero_puerto.

Ejemplo para abrir el puerto 80

ufw allow 80

Para permitir que un usuario pueda gestionar el cortafuegos se debe ejecutar la orden:

sudo visudo

Y añadir una linea.

Ejemplo a añadir para el usuario logongas

logongas ALL=(ALL) NOPASSWD: /usr/sbin/ufw

Instalar Java JDK

Vamos a ver como instalar y usar el JRE:

Para instalar el JRE:

Descargar el fichero tar.gz desde Temurin download
Descomprime el fichero tar.gz en la carpeta actual y se creará una carpeta con el JRE:

tar -xf OpenJDK21U-jdk_x64_linux_hotspot_21.0.8_9.tar.gz  -C .

Comprobar que todo está instalado:

Crea la variable de entorno JAVA_HOME:

export JAVA_HOME=/carpeta/instalacion/jdk-21.0.8+9

Muestra la versión de java con:

$JAVA_HOME/bin/java -version

Ejecutar un jar:

export JAVA_HOME=/carpeta/instalacion/jdk-21.0.8+9
$JAVA_HOME/bin/java -jar mi_app.jar

El nombre del fichero OpenJDK21U-jdk_x64_linux_hotspot_21.0.8_9.tar.gz y de la carpeta jdk-21.0.8+9 será distintas según la versión de java que estés usando.

Si en GitHub no deja subir el OpenJDK21U-jdk_x64_linux_hotspot_21.0.8_9.tar.gz porque es un fichero demasiado grande, se puede partir en pequeños ficheros.

Para dividir un fichero en trozos se usa esta orden:

split --bytes=45m nombre_fichero_grande nombre_fichero_grande.trozo_

Que generará una lista de ficheros del estilo:

nombre_fichero_grande.trozo_aa
nombre_fichero_grande.trozo_ab
nombre_fichero_grande.trozo_ac
...
Etc.

Para unir los trozos se usará la orden:

cat nombre_fichero_grande.trozo_* > nombre_fichero_grande

Para terminar, en vez de instalar el JDK se puede seguir el mismo procedimiento para instalar el JRE.

Instalar NodeJS

NodeJS (o simplemente node) es un lenguaje de programación basado en JavaScript. Al ser un lenguaje interpretado, su forma de trabajar es mas similar a BASH que a Java. ¿Porque vamos a usar NodeJS? Porque muchas herramientas para el desarrollo web están hechas en node. Además del lenguaje de programación, node incluye un gestor de paquetes similar al de Linux (como apt) que se llama "npm" (Node package manager )

Instalación de NodeJS

Para instalar Node la mejor forma es usar un gestor de versiones llamado nvm. Que es un programa que se encarga de instalar distintas versiones de Node.

Instalar nvm

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Usar nvm para instalar NodeJS 22

nvm install 22

Decirle a nvm que por defecto se use NodeJS 22

nvm alias default 22

Comprueba que está instalado node y npm

node -v
npm -v

Instalar Node en Windows

Instalar NodeJS desde la página oficial de Node.JS

Proyectos con node

Inicializar un proyecto en Node. Se crea el fichero package.json que es fundamental en node ya que contiene toda la información del proyecto

npm init

Instalar un paquete nuestro poyecto. Se guarda en la carpeta node_modules

Instalar la librería de JavaScript llamada "jQuery"

npm install jquery

Instalar un paquete de forma global. Se guarda en "/usr/bin"

npm install typescript -g

Instalar todo de nuevo y bajando node_modules. Hace un clean install (ci)

npm ci

En muchos sitios se indica usar npm install. Pero según la documentación de npm ci:

This command is similar to npm install, except it's meant to be used in automated environments such as test platforms, continuous integration, and deployment – or any situation where you want to make sure you're doing a clean install of your dependencies.

Programar en NodeJS

Ahora vamos a ver como ejecutar código node.

El programa mas sencillo es hacer el "Hola Mundo". Para ello creamos un fichero llamado "index.js" con el contenido siguiente:

#!/usr/bin/env node

console.log('Hola Mundo');

Para ejecutarlo hay que lanzar la orden:

node index.js

Y mostrará por consola el mensaje "Hola mundo"

Como en NodeJS se usa JavaScript, podemos usar todo lo que sabemos de JavaScript en un programa de node.

Java vs NodeJS

Para entender ambos lenguajes para a hacer una tabla comparativa a efectos educativos.

Concepto	Node.js	Java
Ejecutable principal	`node` o `node.exe` → ejecuta código JS	`java` o `java.exe` → ejecuta bytecode .class / .jar
Compilador	no aplica, es interpretado	`javac` → compila .java a .class
Gestor de dependencias	npm	Maven
Repositorio central	npmjs.com	Maven Central / jCenter
Archivo de dependencias	`package.json`	`pom.xml`
Instalación de paquetes	`npm install express`	Añadirlo al `pom.xml`
Scripts/automatización	npm run <script> (definidos en package.json)	maven plugins o tareas de gradle

Unicode

Unicode es un estándar de codificación que tiene como objetivo permitir la representación de todos los caracteres utilizados en los sistemas de escritura del mundo, además de símbolos y emojis. A diferencia del ASCII (7 bits ) y ANSI (8 bits), Unicode asigna a cada carácter un número único, denominado "punto de código" y los puntos de código son desde U+0000 hasta U+10FFFF (2.097.152 de caracteres).

Además de unicode están:

ASCII: ASCII es un código de 7 bits que permite representar 128 caracteres diferentes, incluyendo las letras mayúsculas y minúsculas del alfabeto inglés, los números, algunos símbolos de puntuación y caracteres de control (como el salto de línea o el tabulador). Fue desarrollado en los años 60 y está diseñado principalmente para manejar textos en inglés, ya que no incluye acentos ni caracteres especiales de otros idiomas.
ANSI: Amplían el estándar ASCII a 8 bits. Sin embargo hay distintas codificaciones ANSI en los nuevos 128 caracteres para distintos idiomas como ruso o griego. Es decir es como que hay distintos estándares ANSI llamados ISO-8859-x. Por ejemplo hay un estándar ANSI para el griego (ISO 8859-7), otro para el cirílico (ISO 8859-5) , etc. Y son distintos en los 128 caracteres últimos. Cada uno de estos estándares se llama Pagina de código.
Windows: Windows tiene sus propio estándar que es muy similar al ANSI

Página de código	ANSI	Similar en Windows
Latin 1	ISO 8859-1	Windows-1252 (Incluye el € como `0x80`)
Griego	ISO 8859-7	Windows-1253
Cirílico	ISO 8859-5	Windows-1251
Latin 9	ISO 8859-15 (Incluye el € como `0xA4`)

Cambios de ISO-8859-1 a ISO 8859-15
Posición	0xA4	0xA6	0xA8	0xB4	0xB8	0xBC	0xBD	0xBE
8859-1	¤	¦	¨	´	¸	¼	½	¾
8859-15	€	Š	š	Ž	ž	Œ	œ	Ÿ

ISO 8859-1
Carácter	Code Point
á	`0xE1`
é	`0xE9`
í	`0xED`
ó	`0xF3`
ú	`0xFA`
ñ	`0xD1`

En la web, realmente el ISO 8859-1 es el mismo que el Windows-1252. Véase:What is the exact difference between Windows-1252 and ISO-8859-1?

Windows-1252 is commonly known as Windows Latin 1 or as Windows West European or something like that. It differs from ISO Latin 1, also known as ISO-8859-1 as a character encoding, so that the code range 0x80 to 0x9F is reserved for control characters in ISO-8859-1 (so-called C1 Controls), wheres in Windows-1252, some of the codes there are assigned to printable characters (mostly punctuation characters), others are left undefined.

ANSI comes here as a misnomer. Microsoft once submitted Windows-1252 to American National Standards Institute (ANSI) to be adopted as a standard; the proposal was rejected, but Microsoft still calls their code “ANSI”. For further confusion, they may use “ANSI” for different encodings (basically, the “native 8-bit encoding” of a Windows installation).

In the web context, declaring ISO-8859-1 will be taken as if you declared Windows-1252. The reason is that C1 Controls are not used, or useful, on the web, whereas the added characters are often used, even on pages mislabelled as ISO-8859-1. So in practical terms it does not matter which one you declare.

There might still be some browsers that actually interpret data as ISO-8859-1 if declared so, but they must be very rare (the last I remember seeing was a version of Opera about ten years ago).

UTF-8

UTF-8 (Unicode Transformation Format - 8 bits) es un esquema de codificación variable que utiliza entre 1 y 4 bytes para representar cada carácter Unicode. Es altamente eficiente para textos en idiomas que utilizan caracteres latinos comunes, ya que estos se representan en un solo byte. UTF-8 se ha convertido en la codificación más utilizada en la web debido a su compatibilidad con sistemas más antiguos que utilizan ASCII y su capacidad para codificar cualquier carácter Unicode. Además, es muy eficiente en términos de almacenamiento para la mayoría de los lenguajes occidentales.

Codificación UTF-8

Code point	Byte 1	Byte 2	Byte 3	Byte 4
`U+0000..007F`	`0xxxxxxx`
`U+0080..07FF`	`110xxxxx`	`10xxxxxx`
`U+0800..FFFF`	`1110xxxx`	`10xxxxxx`	`10xxxxxx`
`U+10000..10FFFF`	`11110xxx`	`10xxxxxx`	`10xxxxxx`	`10xxxxxx`

Carácter	Code point	UTF-8	Interpretacion erronea en ISO 8859-1
á	`U+00E1`	`C3 A1`	Ã¡
é	`U+00E9`	`C3 A9`	Ã©
í	`U+00ED`	`C3 AD`	Ã³
ó	`U+00F3`	`C3 B3`	Ã-
ú	`U+00FA`	`C3 BA`	Ãº
ñ	`U+00F1`	`C3 B1`	Ã±
💩	`U+1F4A9`	`F0 9F 92 A9`	ðŸ’©

En caso contrario , que tengamos un texto en ANSI y digamos que es utf-8 puede ocurrir que algunos carácteres no se puedan mostrar , en ese caso se muestra es carácter � U+FFFD.

Mas información:

Ejercicios

Ejercicio 1

NodeJS tiene una librería llama Math.js que permite trabajar con números complejos.

Haz una aplicación en node que sume los números complejos (2+4i) y (-5+3i) y muestre el resultado por pantalla.Indica como ejecutar la aplicación