En este sentido, la entrada/salida de datos a ficheros puede ser un factor importante. En desarrollos que no sean críticos en tiempo de ejecución, es habitual utilizar formatos estructurados como XML o JSON para almacenar los datos. Pero el proceso de conversión hacia y desde estos formatos consume recursos. Para optimizar el rendimiento, podemos optar por almacenar los datos en formato binario, como se explica en este artículo.

Apertura de un fichero de datos binarios

La apertura del fichero se realiza con una llamada a fopen(), pasando como argumentos el nombre del fichero, y un flag «rb» o «wb» según se vaya a abrir el fichero en modo de lectura o de escritura.

La función fopen devuelve un puntero a un descriptor de fichero, que será pasado como argumento a las llamadas que se realicen para acceder a los datos del fichero. Por ejemplo:

#include <stdio.h>

int main (int argc, char *argv[]) {

    FILE *fh = fopen("datos.dat","wb");

    ... 
}

Escritura de variables de tipo entero y punto flotante

Para escribir variables integer, float y double en un fichero de datos binario se utiliza la función fwrite, a la que se le pasan como argumentos:

• Un puntero a la variable a escribir que se puede obtener con el operador «&».
• el número de bytes que ocupa la variable. Para obtener este valor, lo más sencillo es utiizar la función sizeof. En el caso de un array, el número de bytes que ocupa cada uno de los elementos del array.
• El tercer argumento 1 para variables sencillas. Si se está escribiendo un array, es el número de elementos del array.
• El puntero al descriptor del fichero en donde se van a escribir los datos.

Ejemplo:

int dato;
    dato = 1;

    fwrite( &dato, sizeof dato, 1, fh);

Ejemplo de escritura de un array:

int datos[1024];
    datos[0] = 1;
    datos[1] = 7;
    ...
    fwrite(&datos[0],sizeof datos[0], 1024, fh);

Escritura de variables de tipo string

Para escribir una cadena de texto se utiliza una llamada a fwrite() como en el caso de variables de tipo entero, con la diferencia de que en lugar de utilizar «sizeof», podemos utilizar la función strlen() para obtener el número de bytes a escribir.

Por otra parte, aunque podríamos escribir el carácter «NULL» (0) para marcar el fin de la cadena de texto, puede resultar más conveniente escribir un valor entero precediendo a la cadena de texto, que indique la longitud de la misma.

Ejemplo:

char *texto;
    int nbytes; 

    texto = "Esto es un texto de prueba";
    nbytes = strlen(texto);

    fwrite (&nbytes, sizeof nbytes, 1, fh);
    fwrite (texto, nbytes, 1, fh);

Lectura de los datos de un fichero binario

Para leer los datos contenidos en un fichero binario, abrimos primero el fichero con una llamada a fopen(), con el flag «rb».

A continuación, utilizamos simplemente la función fread(), que recibe los mismos argumentos que la función fwrite().

Por ejemplo, para leer un número entero:

FILE *fh = fopen("datos.dat","rb");

    fread (&dato, sizeof dato, 1, fh);

Para leer un string, si el string está precedido por un valor entero que indica su longitud, podemos utilizar el siguiente código:

int nbytes;
    char *texto;
    fread (&nbytes, sizeof nbytes, 1, fh);
    texto = (char *)malloc(nbytes+1);
    fread (texto, nbytes, 1, fh);
    texto[nbytes] = 0;

    printf("Texto leido: %s\n",texto);

Como vemos:

• Comenzamos leyendo en la variable ‘nbytes’ la longitud del string
• Mediante una llamada a malloc(), asignamos a la variable ‘texto’ un buffer para contener el string. El tamaño del buffer es nbytes+1, para poder incluir el carácter NULL que marca el fin del string
• Leemos el texto en la variable ‘texto’
• Asignamos el caracter NULL al último byte del buffer.

—

Referencias:

• C Programming Files I/O

—-

El tiempo de carga es un factor importante porque influye directamente en la experiencia del usuario, y también es una señal que utiliza el buscador de Google para el posicionamiento de la página en la lista de resultados.

Uno de los consejos que pueden aparecer cuando se analiza una página web en PageSpeed Insights es «Eliminate Render blocking CSS». En este artículo vamos a presentar un procedimiento para eliminar este aviso y aumentar la puntuación que PageSpeed Insights asigna a la página.

Carga no bloqueante del código CSS de la página

Un página web típica utiliza una o varias hojas de estilo CSS a las que hace referencia mediante una serie de tags «<link>» incluidos en la cabecera del código HTML. Por ejemplo:

<html>
<head>
...
  <link href="/css/combined.css" rel="stylesheet" media="screen"> 
  <link href="/css/bootstrap.min.css" rel="stylesheet" media="screen"> 
  <link href="/css/font-awesome.css" rel="stylesheet"> 
  <link href="/css/jquery.nstSlider.min.css" rel="stylesheet" media="screen">
  <link href="/css/selectboxit.css" rel="stylesheet" media="screen">
...

Cuando el navegador web comienza a procesar la página, al encontrarse con estos tags realiza la descarga de los ficheros css especificados, y espera a que estén descargados antes de continuar el proceso.

Para evitar este comportamiento, se puede solicitar la carga de las hojas de estilo con un código distinto:

...
  <link href="/css/combined.css" rel="preload" media="screen" as="style"
        onload="this.rel='stylesheet'">
  <noscript>
    <link href="/css/combined.css" rel="stylesheet" media="screen">
  </noscript>
  <link href="/css/bootstrap.min.css" rel="preload" media="screen" as="style"
        onload="this.rel='stylesheet'">
  <noscript>
    <link href="/css/bootstrap.min.css" rel="stylesheet" media="screen">
  </noscript>
...

Como vemos, en este caso se carga la hoja de estilo con el atributo ‘rel=»preload»‘, y sólo después de cargada se cambia este atributo mediante javascript (onload=»this.rel=’stylesheet'»).

Para considerar el caso de navegadores que no soportan javascript, se añade un bloque <noscript>…</noscript> en el que se incluye también la carga «normal» de la hoja des estilo.

Con este cambio, la carga de las hojas de estilo deja de ser bloqueante, como se puede comprobar volviendo a analizar la página con Google Page Speed Insights.

El problema que se presenta al aplicar este cambio es que en este caso el navegador presenta primero el contenido de la página antes de haber aplicado ningún estilo. Después de descargar las hojas CSS, aplica los estilos y vuelve a presentar la página en pantalla, lo que provoca un efecto indeseable.

Identificación del código CSS «crítico»

Para evitar este efecto, se puede incluir «inline» en el propio código HTML de la página (entre los tags <style>…</style>), el conjunto mínimo de código CSS que permite la visualización definitiva de la parte visible de la página.

Pero identificar manualmente este código CSS es una tarea tremendamente laboriosa. Afortunadamente, existen aplicaciones que permiten automatizar este trabajo. En este artículo, vamos a utilizar la aplicación «Critical» de github (https://github.com/addyosmani/critical).

Instalación de npm

El package manager «npm» se instala como parte del paquete «nodejs».

La manera más sencilla de obtener la versión más reciente de Node.js es añadir el PPA (personal package archive) mantenido por NodeSource.
Este repositorio contiene versiones de Node.js más actualizadas que las existentes en los repositorios oficiales de Debian.

En primer lugar, añadimos el PPA de NodeSource:

$ curl -sL https://deb.nodesource.com/setup_6.x -o nodesource_setup.sh
$ sudo bash nodesource_setup.sh

Y a continuación realizamos la instalación del paquete nodejs

$ sudo apt-get install nodejs

Por último, comprobamos las versiones de nodejs y npm instaladas:

$ nodejs --version
v6.11.5
lokku@ip-172-31-12-45:~$ npm --version
3.10.10

Instalación de critical

La aplicacion se instala con el package manager «npm»:

$ sudo npm install -g critical

Ejecución de critical y obtención del código CSS crítico

Con esto, ya estamos en condiciones de analizar el contenido de una página web de nuestro site, para obtener el código CSS crítico.

En primer lugar descargamos el código html de la página, utilizando por ejemplo el comando wget:

$ wget -O pru.html http://www.ejemplo.com/pagina-a-optimizar

y después realizamos el análisis:

$ critical pru.html --base /var/www --inline > pru.critical.html

La opción «–base /var/www» indica la ubicación del «DocumentRoot» del sitio, y es utilizada por la aplicación «critical» para obtener los ficheros auxiliares (imágenes, ficheros javascript, hojas de estilo css,…) utilizados por la página. Deberemos sustituir el valor /var/www por el que corresponda para el sitio web que está siendo analizado.

El fichero pru.critical.html generado contiene en el interior del header un bloque <style type=»text/css»>…</style> con el código CSS crítico para la visualización de la página.

Ya sólo nos queda incorporar dicho código en las páginas de nuestro site, y comprobar el resultado.

Hay que tener en cuenta que el código CSS crítico puede ser distinto para cada una de las páginas del sitio.

Referencias

• Critical CSS and Webpack: Automatically Minimize Render-Blocking CSS
• How To Install Node.js on Debian 8
• How to Install NodeJS on Debian 9 Stretch Linux
• How To Install Node.js on Ubuntu 16.04

—

#include <stdio.h>

int main() {

    char linea[1024];
    FILE *fich;

    fich = fopen("fichero.txt", "r");
    //Lee línea a línea y escribe en pantalla hasta el fin de fichero
    while(fgets(linea, 1024, (FILE*) fich)) {
        printf("LINEA: %s FIN_DE_LINEA\n", linea);
    }
    fclose(fich);
}

A continuación, compilamos el programa:

$ gcc -o lee_fichero lee_fichero.c

Y por último lo ejecutamos.

Si el fichero de texto a leer «fichero.txt» contiene las líneas:

Linea primera
Linea segunda
Linea tercera

al ejecutar el script desde la línea de comandos, obtendremos lo siguiente:

$ ./lee_fichero
LINEA: Linea primera
 FIN_DE_LINEA
LINEA: Linea segunda
 FIN_DE_LINEA
LINEA: Linea tercera
 FIN_DE_LINEA
$

NOTAS

Carácter de fin de línea

Como podemos ver en la salida generada por el programa de ejemplo, cada línea leída incluye el carácter de fin de línea ‘\n’. Si deseamos eliminarlo, podemos simplemente añadir dentro del bucle las sentencias:

#include <stdio.h>
#include <string.h>
...
while(fgets(linea, 1024, (FILE*) fich)) {
    int n = strlen(linea);
    linea[n-1] = 0;
    ...
}
...

Tamaño del buffer de lectura.

En el código de ejemplo, para leer las líneas, hemos creado un buffer de 1024 bytes con la sentencia «char linea[1024];». En la llamada a fgets, le pasamos como segundo argumento el tamaño del buffer.

Esto nos permite leer líneas de hasta 1022 (1024-2) caracteres, ya que es necesario un byte adicional para almacenar el carácter de fin de línea (‘\n’), y otro para el caracter nulo (0) que finaliza la cadena de texto.

Si el fichero a leer contiene líneas de mayor tamaño, deberemos dimensionar adecuadamente el buffer.

Podemos añadir al código una condición para comprobar si se da el caso de que una línea del fichero leído es mayor que el tamaño del buffer:

#include <stdio.h>
#include <string.h>
...
while(fgets(linea, 1024, (FILE*) fich)) {
    int n = strlen(linea);
    if (linea[n-1] != '\n') {
        printf ("Error. leída línea incompleta\n");
    }
    ...
}
...

—

En Java también es posible utilizar expresiones regulares, como se explica en este artículo.

Determinar si una cadena contiene un patrón especificado en forma de expresión regular

La funcionalidad para el tratamiento de expresiones regulares en Java está implementada en el paqueta java.util.regex.

Este paquete contiene las clases «Pattern» y «Matcher».

Con la clase Pattern creamos un objeto correspondiente a un determinado patrón (expresión regular) que queremos utilizar en el programa. Por ejemplo:

Pattern p = Pattern.compile("a*b");

La clase Matcher implementa el método «matches()», con el cual podemos comprobar si una determinada cadena de texto cumple con la expresión regular:

Matcher m = p.matcher("aaaaab");
 boolean b = m.matches();

Por conveniencia, la clase Pattern también implementa un método estático «matches()», que compila la expresión regular, crea una instancia de la clase Matcher, y llama a su método matches(). De este modo, las tres sentencias del ejemplo anterior se pueden escribir como una única sentencia:

boolean b = Pattern.matches("a*b", "aaaaab");

Sustituir con una subcadena las ocurrencias de un patrón en una cadena de texto

Para realizar la sustitución de la primera ocurrencia de la expresión regular, se utiliza el método replaceFirst() de la clase Matcher.

También podemos utilizar el método replaceAll() para sustituir todas las ocurrencias del patrón.

Ejemplo:

Pattern p = Pattern.compile("(verde|rojo)");
        Matcher m = p.matcher("amarillo, rojo, morado, verde, naranja");
        String resultado = m.replaceFirst("azul");
        System.out.println("Colores: " + resultado);
        resultado = m.replaceAll("azul");
        System.out.println("Colores: " + resultado);

El código del ejemplo genera la siguiente salida:

Colores: amarillo, azul, morado, verde, naranja
Colores: amarillo, azul, morado, azul, naranja

Grupos de captura

La expresión regular puede contener grupos de captura encerrados entre paréntesis.

Después de aplicar el patrón (con el método «find()») a una cadena de texto, el método group(n) permite recuperar las subcadenas coindicientes con cada uno de los grupos de captura presentes en la expresión regular. Por ejemplo:

p = Pattern.compile("([^ ]*) ([^ ]*) (.*)");
        m = p.matcher("uno dos tres cuatro cinco");
        if (m.find()) {
            System.out.println("grupo A: " + m.group(1));
            System.out.println("grupo B: " + m.group(2));
            System.out.println("grupo C: " + m.group(3));
        }

En este ejemplo, la subcadena correspondiente al grupo $1 es «uno», $2 es «dos» y $3 es «tres cuatro cinco». El resultado que se presenta en pantalla es:

grupo A: uno
grupo B: dos
grupo C: tres cuatro cinco

Mediante la expresión «$n» (en donde n es el número de secuencia del grupo), las subcadenas correspondientes a los grupos de captura pueden ser utilizadas en el argumento de los métodos replaceFirst() y replaceAll(). Por ejemplo:

p = Pattern.compile("([^ ]*) ([^ ]*) (.*)");
        m = p.matcher("uno dos tres cuatro cinco");
        resultado = m.replaceFirst("$3 - $2 - $1");
        System.out.println("Resultado: " + resultado);

Al ejecutar estass sentencias, el resultado que se presenta en pantalla es:

Resultado: tres cuatro cinco - dos - uno

Referencias

JavaDoc – java.util.regex.Pattern

—

Indice de artículos sobre programación en lenguaje Java

—

Para ello, hay que instalar y configurar un certificado SSL en el servidor. El proceso de solicitar un certificado, instalarlo y configurarlo ha sido tradicionalmente engorroso, y además era necesario adquirir el certificado desembolsando una cierta cantidad de dinero. La iniciativa Let’s Encrypt (promovida por Google), ha venido a solucionar este problema.

En este artículo se explica el procedimiento de instalación y configuración de un certificado SSL de Let’s Encrypt sobre un servidor Debian/Ubuntu que ejecuta un servidor web Apache.

Instalación del software

Comenzamos por actualizar  el sistema, e instalar el paquete git para poder acceder al repositorio de Let’s Encrypt

sudo apt-get update
sudo apt-get install git

A continuación, instalamos el software Let’s Encrypt bajo el directorio «/opt/letsencrypt»:

sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt

Configuración de apache

Exceptuando los casos más sencillos, la configuración más habitual de los servidores web utiliza el mecanismo de «VirtualHosts» para albergar más de un dominio en un mismo servidor.

Normalmente, el dominio principal es de la forma «www.ejemplo.com», pero también pueden existir subdominios como por ejemplo «blog.ejemplo.com», etc. Además, es conveniente configurar también el dominio base «ejemplo.com», que suele ser redirigido con una redirección permanente 301 al dominio principal «www.ejemplo.com».

Actualmente, el procedimiento de instalación de certificado SSL de Let’s Encrypt no permite que haya más de un VirtualHost en un mismo fichero de configuración, por lo que deberemos crear bajo el directorio «/etc/apache2/sites-available» un fichero para cada uno de ellos:

/etc/apache2/sites-available/www.ejemplo.com.conf – Dominio principal

<VirtualHost *:80>
    ServerName www.ejemplo.conf
    ...
</VirtualHost>

/etc/apache2/sites-available/blog.ejemplo.com.conf – Subdominio para el blog

<VirtualHost *:80>
    ServerName blog.ejemplo.conf
    ...
</VirtualHost>

/etc/apache2/sites-available/ejemplo.com.conf – Dominio base, que simplemente contiene una redirección a www.ejemplo.com

<VirtualHost *:80>
    ServerName ejemplo.com

    RewriteEngine On
    RewriteRule ^/(.*)$ https://www.ejemplo.com/$1 [L,R=301]

</VirtualHost>

Generación e instalación del certificado

Una vez preparada la configuración de apache, creamos el certificado, incluyendo el dominio principal y todos los subdominios a los que se aplica:

cd /opt/letsencrypt

./letsencrypt-auto --apache -d ejemplo.com -d www.ejemplo.com -d blog.ejemplo.com

Al finalizar, se presenta el siguiente mensaje:

 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/ejemplo.com/fullchain.pem. Your cert will
   expire on 2016-11-22. To obtain a new or tweaked version of this
   certificate in the future, simply run letsencrypt-auto again with
   the "certonly" option. To non-interactively renew *all* of your
   certificates, run "letsencrypt-auto renew"
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Comprobamos que la instalación del certificado ha realizado algunas modificaciones en los ficheros de configuración de apache:

• En el fichero de configuración de cada dominio, añade una redirección 301 permanente de http a https:
  

  <VirtualHost *:80>
      ServerName www.ejemplo.conf
      ...
      RewriteEngine on
      RewriteCond %{SERVER_NAME} =www.ejemplo.conf
      RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,QSA,R=permanent]
  </VirtualHost>

• También crea para cada dominio un fichero de configuración específico para el acceso por SSL, en el que incluye las directrices de configuración del certificado SSL:
  /etc/apache2/sites-available/www.ejemplo.com-le-ssl.conf
  

  <IfModule mod_ssl.c>
  <VirtualHost *:443>
      ServerName www.ejemplo.conf
      ...
      SSLCertificateFile /etc/letsencrypt/live/ejemplo.com/fullchain.pem
      SSLCertificateKeyFile /etc/letsencrypt/live/ejemplo.com/privkey.pem
      Include /etc/letsencrypt/options-ssl-apache.conf
  </VirtualHost>
  </IfModule>

Verificación

La configuración del sitio se puede comprobar haciendo uso del servicio online de ssllabs.com:

https://www.ssllabs.com/ssltest/analyze.html?d=www.ejemplo.conf

Renovación del certificado

La renovación de todos los certificados SSL instalados en el servidor se realiza ejecutando el comando letsencript-auto con la opción «renew»:

root@servidor:/# cd /opt/letsencrypt/
root@oservidor:/opt/letsencrypt# ./letsencrypt-auto renew

-------------------------------------------------------------------------------
Processing /etc/letsencrypt/renewal/ejemplo.com.conf
-------------------------------------------------------------------------------

The following certs are not due for renewal yet:
  /etc/letsencrypt/live/ejemplo.com/fullchain.pem (skipped)
No renewals were attempted.

Como vemos, se puede ejecutar el comando en cualquier momento, porque si los certificados no necesitan ser renovados no realiza ninguna acción.

Para automatizar la renovación, basta con introducir el comando como una entrada en crontab del usuario root:

30 2 * * 1 /opt/letsencrypt/letsencrypt-auto renew >> /var/log/le-renew.log

Extensión del certificado a subdominios adicionales

Para añadir un subdominio a un certificado, se ejecuta de nuevo el mismo comando con el que se generó el certificado original, añadiendo el nuevo subdominio, y utilizando la opción «–expand».

Por ejemplo, para añadir el subdominio «img.ejemplo.com» al certificado, utilizaremos el comando:

./letsencrypt-auto --expand --apache \
             -d ejemplo.com \
             -d www.ejemplo.com \
             -d blog.ejemplo.com \
             -d img.ejemplo.com

Instalación del certificado en otro tipo de servidor web

Al pasarle la opción «–apache» al comando letsencrypt-auto, se actualiza automáticamente la configuración del servidor web para hacer uso del certificado generado.

Pero si estamos utilizando otro tipo de servidor, o queremos realizar manualmente las modificaciones necesarias en los ficheros de configuración del servidor web, podemos utilizar en su lugar la opción «certonly», junto con las opciones «–webroot» y «–webroot-path </path/del/documentroot>».

Por ejemplo, si el DocumentRoot de nuestro dominio «ejemplo.com» es «/var/www/ejemplo.com», el comando a utilizar sería de la forma:

./letsencrypt-auto certonly --webroot --webroot-path /var/www/ejemplo.com \
        -d ejemplo.com \
        -d www.ejemplo.com \
        -d blog.ejemplo.com

Atención: Durante el proceso de generación del certificado, el comando letsencrypt-auto crea un subdirectorio «.well-known/acme-challenge» bajo el directorio especificado en la opción webroot-path (el DocumentRoot), y deposita en el mismo una serie de ficheros de prueba, a los que después intenta acceder con urls de la forma «http://www.ejemplo.com/.well-known/acme-challenge/*».

Por esta razón, hay que asegurarse de que no haya ninguna sentencia en la configuración del servidor web que impida el acceso a ficheros en dicha ruta.

Referencias

• The Pros And Cons Of Implementing SSL / HTTPS
• Official Google Webmaster blog – HTTPS as a ranking signal
• How to Set Up Let’s Encrypt Certificates for Multiple Apache Virtual Hosts on Ubuntu 14.04
• Certbot / Letsencrypt Documentation
• Geolocation API removed from unsecured origins in Chrome 50

—

1. Hacer un volcado del repositorio

En primer lugar, utilizamos el comando svnadmin para realizar una copia de seguridad del repositorio:

$ svnadmin dump /path/to/repo > reponame.dump

Opcinalmente, podemos comprimir el fichero que contiene el volcado. Después, copiamos el fichero al nuevo servidor por cualquier procedimiento: ftp, scp, rsync,…

2. crear y cargar el repositorio en su nueva ubicación

En el servidor de destino, creamos un nuevo repositorio, y lo cargamos con la copia de seguridad. Utilizamos la opción «–force-uuid» para que el nuevo repositorio se cree con el mismo uuid que el repositorio original, de modo que los clientes no tengan problemas en seguir utilizando el repositorio en su nueva localización:

nuevoservidor$ svnadmin create /path/to/new/repo
nuevoservidor$ svnadmin load /path/to/new/repo --force-uuid < reponame.dump

3. Indicar a los clientes la nueva ubicación del repositorio

Por último, en cada una de las «working copies», actualizamos la ubicación del repositorio.

Opcionalmente, con el comando «svn info» podemos comprobar primero la ubicación que estaba utilizando la working copy.

cliente$ cd proyecto
cliente$ svn info | grep URL:
URL: file:///path/to/old/repo/trunk

después, con el comando «svn relocate» cambiamos la ubicación:

cliente$ svn relocate svn+ssh://usuario@www.nuevoservidor.com/path/to/new/repo/trunk

( Para distintos clientes, podemos especificar distintos protocolos de conexión: file:, svn+ssh:, http:,… en función de las características de nuestra instalación ).

Y eso es todo!

Referencias

• svnadmin Reference
• svn reference – svn relocate

—

Previamente, para desarrollar un programa en C, deberemos haber instalado el entorno de desarrollo habitual: compilador gcc, utilidad make, etc…

Adicionalmente, deberemos instalar el paquete de desarrollo de cliente de MySQL, que incluye las librerías y ficheros header (*.h) necesarios:

# apt-get install libmysqlclient-dev

A continuación, escribimos el programa de ejemplo «conexion_mysql.c», con el siguiente contenido (sustituyendo el literal «PASSWORD» por la contraseña del usuario root):

/* Sencillo programa C que establece una conexión a un servidor de base de datos MySQL */
#include <stdlib.h>
#include <stdio.h>
#include <mysql.h>
main() {
 MYSQL *conn;
 MYSQL_RES *res;
 MYSQL_ROW row;
 char *server = "localhost";
 char *user = "root";
 char *password = "PASSWORD"; /* Poner la contraseña */
 char *database = "mysql";
 conn = mysql_init(NULL);
 /* Conectarse a la base de datos */
 if (!mysql_real_connect(conn, server, user, password, database, 0, NULL, 0)) {
     fprintf(stderr, "%s\n", mysql_error(conn));
     exit(1);
 }
 /* enviar la consulta SQL */
 if (mysql_query(conn, "show tables")) {
     fprintf(stderr, "%s\n", mysql_error(conn));
     exit(1);
 }
 res = mysql_use_result(conn);
 /* imprimir los nombres de las tablas */
 printf("Tablas en la base de datos 'mysql':\n");
 while ((row = mysql_fetch_row(res)) != NULL) printf("%s \n", row[0]);
 /* liberar los recursos y cerrar la conexion */
 mysql_free_result(res);
 mysql_close(conn);
}

Para compilar el programa, debemos pasar al compilador una serie de opciones que incluyen las referencias a las librerías y a los directorios en donde se encuentran los ficheros header. El paquete de desarrollo de cliente MySQL que hemos instalado incluye una utilidad «mysql_config» que genera la correspondiente lista de opciones a pasar al compilador. Haciendo uso de la misma, podemos compilar el programa de ejemplo con un comando de la forma:

$ gcc -o conexion_mysql $(mysql_config --cflags) $(mysql_config --libs) conexion_mysql.c

Y por último, podemos comprobar el resultado ejecutando el programa:

$ ./conexion_mysql
Tablas en la base de datos 'mysql':
columns_priv 
db 
event 
func 
general_log 
help_category 
help_keyword 
help_relation 
help_topic 
host 
ndb_binlog_index 
plugin 
proc 
procs_priv 
proxies_priv 
servers 
slow_log 
tables_priv 
time_zone 
time_zone_leap_second 
time_zone_name 
time_zone_transition 
time_zone_transition_type 
user

Referencias:

• Howto: Connect MySQL server using C program API under Linux or UNIX

En este artículo veremos cómo se puede crear un disco en RAM, y cómo configurar MySQL para que haga uso del mismo, en un sistema Debian/Ubuntu. El procedimiento se puede aplicar con ligeras modificaciones a casi todas las demás distribuciones de Linux.

1 – Determinar la cantidad de memoria física disponible

Para poder utilizar un disco en memoria, el sistema debe disponer de una cantidad suficiente. El comando «free» nos indica la cantidad total de memoria disponible, y del uso que está haciendo el sistema de la misma:

# free -m
             total       used       free     shared    buffers     cached
Mem:         40323      22586      17737        816         42       1223
-/+ buffers/cache:      21320      19002
Swap:         2047         82       1965

En este ejemplo, vemos que el sistema dispone de un total de 40323 MBytes de memoria principal (40 GBytes), de los cuales hay 17 GBytes no utilizados.

2 – Crear el punto de montaje, y montar el disco RAM

La configuración por defecto de un sistema Debian/Ubuntu ya incluye un filesystem tmpfs montado en «/dev/shm», que hace uso de la mitad de la memoria física disponible. Con el comando «df» podemos examinar los filesystems existentes:

$ df
Filesystem     1K-blocks      Used Available Use% Mounted on
/dev/sda2      825324976 461508928 321868864  59% /
udev               10240         0     10240   0% /dev
tmpfs            8258348    811312   7447036  10% /run
tmpfs           20645868         0  20645868   0% /dev/shm
tmpfs               5120         0      5120   0% /run/lock
tmpfs           20645868         0  20645868   0% /sys/fs/cgroup
/dev/sda1         230925     32084    182611  15% /boot
$

En otro tipo de distribuciones Linux, en donde no exista ya un filesystem tmpfs configurado, podemos crearlo de la siguiente forma:

En primer lugar, creamos un directorio en el cual se va a montar el disco RAM:

# mkdir /mnt/ramdisk

y a continuación montamos el disco con el comando:

# mount -t tmpfs -o size=10240m tmpfs /mnt/ramdisk

Con el comando «df», podemos comprobar que el disco está creado y preparado para su uso:

# df -h /mnt/ramdisk
Filesystem      Size  Used Avail Use% Mounted on
tmpfs            10G     0   10G   0% /mnt/ramdisk

Opcionalmente, para que el disco se vuelva a montar cuando se reinicie el servidor, podemos añadir una línea al fichero /etc/fstab:

tmpfs       /mnt/ramdisk tmpfs   nodev,nosuid,noexec,nodiratime,size=10240M   0 0

3 – Configurar MySQL para que utilice el disco en memoria

La directriz «tmpdir» en el fichero de configuración /etc/mysql/my.cnf especifica la ubicación del directorio en el cual MySQL creará las tablas temporales que necesite para la ejecución de determinadas consultas. En primer lugar, creamos un directorio «mysqltmp» bajo el directorio en el que hemos montado el disco en memoria, y le asignamos como propietario el usuario con el que se ejecuta el servicio mysql:

# mkdir /mnt/ramdisk/mysqltmp
# chown mysql:mysql /mnt/ramdisk/mysqltmp

A continuación, editamos /etc/mysql/my.cnf para establecer dicho directorio como valor de la directriz «tmpdir»:

tmpdir          = /mnt/ramdisk/mysqltmp

Por último reiniciamos el servicio mysql para que tenga efecto la nueva configuración:

# /etc/init.d/mysql restart

4 – Crear tablas e índices en el disco en memoria

Otra posible optimización es utilizar el disco en memoria para almacenar no sólo las tablas temporales, sino las tablas permanentes.

Sin embargo, hay que ser consciente de que todo el contenido del disco en memoria desaparece cada vez que se reinicia el sistema, por lo que hay que establecer un procedimiento que permita recuperar esta información en el reinicio.

Supongamos que la base de datos contiene una tabla ‘mitabla’, que es accedida frecuentemente por las aplicaciones que se ejecutan en el servidor. Podemos crear en el disco en memoria una nueva tabla ‘mitabla_ram’, con la misma estructura que la tabla ‘mitabla’, y copiar a la misma el contenido de ‘mitabla’;

mysql> CREATE table `mitabla_ram`(
           .... 
           )
           DATA DIRECTORY '/mnt/shm/mysql'
           INDEX DIRECTORY '/mnt/shm/mysql';
mysql> INSERT INTO mitabla_ram (SELECT * FROM mitabla);

A continuación, cambiamos el nombre de las tablas para que la tabla en memoria pase a llamarse ‘mitabla’, y sea la tabla utilizada por la aplicación:

mysql> ALTER TABLE mitabla RENAME TO mitabla_disco;
mysql> ALTER TABLE mitabla_ram RENAME TO mitabla;

Por último debemos establecer un mecanismo para:

• Guardar en disco el contenido de la tabla en memoria, con la periodicidad que se considere necesaria
• En el reinicio del sistema, crear nuevamente la tabla en memoria, y cargarla con el contenido guardado en disco.

Referencias:

• Create a RAM disk in Linux
• Create a RAM Disk in Linux & Use It to Speed Up MySQL…

—

En este caso, el sistema rechaza la ejecución de los nuevos procesos.

Para evitar esto, se puede configurar un espacio de swap en disco. De este modo, el sistema guarda temporalmente en dicho espacio los bloques de memoria que tienen menos accesos, para liberar espacio y permitir la ejecución de los nuevos procesos.

En un servidor dedicado, es habitual crear una partición de disco dedicada a swap. Pero en otros casos no es posible particionar el disco. Este es en muchas ocasiones el caso de una máquina virtual contratada a un proveedor de hosting (Amazon Web Services, DigitalOcean, …)

En este caso, es posible crear un fichero y configurar el sistema para que lo utilize como espacio de swap. En este artículo se explica cómo realizar una configuración de este tipo.

1. Crear el fichero de swap

En este paso vamos a crear un fichero dedicado a swap bajo el directorio «/var». Por seguridad, establecemos los permisos de manera que sólo el usuario root pueda leer y escribir en el mismo. Como usuario root, ejecutamos:

# cd /var
# touch swap.img
# chmod 600 swap.img

2. Dar un tamaño al fichero de swap

Lo habitual es dar al fichero un tamaño entre una y dos veces la cantidad de memoria física disponible en el sistema. En el siguiente ejemplo, crearemos un fichero con 2048 bloques de 1024k cada uno, para obtener un total de 2 GBytes. Como usuario root:

# dd if=/dev/zero of=/var/swap.img bs=1024k count=1000
1000+0 records in
1000+0 records out
1048576000 bytes (1.0 GB) copied, 4.0868896 s, 253 MB/s
#

3. Inicializar el fichero en forma de swap filesystem

El comando mkswap realiza un formateo del fichero, que lo prepara para ser utilizado como espacio de swap

# mkswap /var/swap.img
Setting up swapspace version 1, size = 1020 GiB
no label, UUID=72761533-8xbe-436l-b07e-c0sabe9cedf3

4. Habilitar el fichero de swap para ser usado por el sistema

Finalmente, con el comando swapon indicamos al sistema que utilice el fichero creado como espacio de swap

# swapon /var/swap.img

De la misma forma, podemos utilizar el comando ‘swapoff’ si en algún momento queremos dejar de usar el fichero como espacio de swap.

5. Configurar el sistema para que monte el fichero de swap durante el reinicio

La manera más sencilla de indicar al sistema que monte el fichero como swap durante el reinicio es añadir una entrada al fichero de configuración ‘/etc/fstab’, como en el siguiente ejemplo:

# echo "/var/swap.img    none    swap    sw    0    0" >> /etc/fstab

Nota: El espacio de swap sólo es útil si el sistema dispone habitualmente de suficiente memoria física para atender la carga de proceso que recibe, y sólo esporádicamente sufre picos de carga que durante breves momentos requieren más memoria de la que hay disponible. En caso contrario, el sistema estará continuamente leyendo y escribiendo del disco los bloques de memoria física que necesita (en lo que se conoce como «trashing»), y el rendimiento del sistema se degradará hasta el punto de inutilizarlo en la práctica.

Referencias:

• How to configure Virtual Memory (Swap File) on a VPS

—

En este artículo se explica una de las posibles soluciones a este problema, mediante la creación de túneles de comunicación SSH.

Utilizando un túnel SSH, se puede configurar el servidor para que sólo abra en su dirección local (localhost, 127.0.0.1) el puerto TCP correspondiente al servicio que ofrece. El cliente se conectará a su vez a un puerto local (el número de puerto puede ser distinto del número de puerto en el que escucha el servidor). El túnel se encarga de encriptar toda la información enviada por el cliente, y enviarla al puerto local del servidor. De la misma forma, el túnel lee toda la la información que escribe el servidor en su puerto local, la encripta y la envía al puerto local en el que lee el cliente.

Vamos a tomar como ejemplo una máquina cliente «cliente» que necesita conectarse a una base de datos MySQL que reside en un servidor «ejemplo.com». Si no se usa un túnel, el servidor debe permitir el establecimiento de conexiones en su dirección pública ejemplo.com:3306.

Redirección de puerto local (local port forwarding)

En primer lugar, configuramos el servidor para que sólo permita conexiones locales a la dirección localhost:3306.

A continuación, iniciamos una sesión ssh desde el cliente al servidor, en la que solicitamos la creación de un túnel entre el puerto 5000 del cliente al puerto 3306 del servidor, con el siguiente comando:

$ ssh -L 5000:localhost:3306 usuario@ejemplo.com

Una vez establecida la sesión, desde otro terminal del cliente podemos conectarnos a la base de datos del servidor con el comando:

$ mysql -h 127.0.0.1 -P 5000

Los datos que escribe el cliente en el puerto 5000 de su dirección local, son encriptados y enviados por el túnel al puerto 3306 del servidor, y los datos que devuelve el servidor son también encriptados, y enviados al cliente a través del túnel.

Como vemos en este ejemplo, para crear el túnel hemos tenido que establecer primero una sesión interactiva ssh, y después conectarnos desde otro terminal a la base de datos. Para evitar esto se pueden utilizar los flags «-nNT», de manera que el comando ssh no establezca la sesión interactiva, y simplemente realice la redirección de puertos:

$ ssh -nNT -L 5000:localhost:3306 usuario@ejemplo.com

Creación de túneles persistentes

El túnel ssh creado en el apartado anterior sólo permanece mientras está establecida la sesión ssh en la que se estableció.

Para poder crear un túnel persistente, que no dependa de una sesión interactiva, podemos utilizar el comando «autossh». autossh se encarga de establecer una sesión ssh en background, y comprueba periódicamente que la sesión permanezca activa. Si por cualquier razon (problema de red o de otro tipo) la sesión ssh finaliza, autossh se encarga de establecer una nueva sesión.

Para crear el túnel con autossh, utilizamos el comando:

$ /usr/lib/autossh/autossh -f -N -L 5000:localhost:3306 usuario@ejemplo.com

Script de creación de túneles ssh en el reinicio

Para que se creen los túneles ssh durante el renicio del servidor, debemos crear un script «/etc/init.d/autossh», como el script de ejemplo que se puede descargar pulsando aqui.

Este script puede crear múltiples túneles a distintos servidores. La configuración de túneles para cada uno de los servidores se guarda en un fichero «/etc/autossh/<server>». Por ejemplo:

# cat /etc/autossh/server1 
# Comprueba la conexión cada 10 segundos.
# Tras 3 intentos fallidos, cierra la conexión y la vuelve a establecer
ServerAliveInterval="10"
ServerAliveCountMax="3"
StrictHostKeyChecking="no"
 
LocalUser="root"
IdentityFile="~/.ssh/id_rsa"
 
RemoteUser="usuario"
RemoteHost="server1"
RemotePort="22"
 
# Lista de túneles locales y remotos a establecer
# 
# En este ejemplo:
#    - conecta el puerto remoto 10550 con el puerto local 10050
#    - conecta el puerto local 10051 con el puerto remoto 10051
ForwardPort=(
    "R 127.0.0.1:10550:localhost:10050"
    "L 127.0.0.1:10051:localhost:10051"
)

Redirección de puerto remoto (Remote port forwarding)

Un caso similar que también se puede solucionar mediante un túnel ssh se da cuando desde un máquina cliente conectada a internet queremos acceder a un servicio ofrecido por un servidor «server1» que no tiene conexión directa a internet.

En este caso, podemos utilizar un segundo servidor «server2.com» que sí está conectado a internet, para establecer la comunicación:

• Desde el servidor «server1», extablecemos una sesión ssh en la que creamos un túnel remoto:
  

  ssh -R 5000:localhost:3306 usuario@server2.com

  
  Como se puede ver, en este caso utilizamos la opción «-R» para establecer un túnel remoto, en lugar de la opción «-L» que establecer un túnel local. Con este comando, el servidor «server2.com» queda a la espera de conexiones en el puerto 9000, y transmite la información que reciba al puerto 3306 del servidor «server1».
• Una vez establecido el túnel, desde el cliente podemos establecer una sesión interactiva al servidor «server2.com», y desde allí conectarnos a la base de datos MySQL del servidor «server1»:
  

  cliente$ ssh usuario@server2.com
    ...
  server2$ mysql -h 127.0.0.1 -P 5000

Referencias:

SSH Tunnel – Local and Remote Port Forwarding Explained With Examples

—