Montar un disco duro o particion en Linux

Vamos al punto, aquí se describen los pasos de como montar un disco duro o una partición en Linux mediante la terminal.

1. Primero debemos crear la carpeta donde montaremos la partición.

$ mkdir /media/temp

Puede ser en cualquier ruta que queramos.

2. Verificar que disco y partición vamos a montar, existen varias opciones para ello, pero aquí solo describiremos dos.

a) usando fdisk

$ fdisk -l

Device     Boot     Start       End    Sectors  Size Id Type
/dev/sda1  *         2048 144799743  144797696   69G 83 Linux
/dev/sda2       144801790 146798591    1996802  975M  5 Extended
/dev/sda5       144801792 146798591    1996800  975M 82 Linux swap / Solaris
/dev/sdb1  *            1    243202 1953512448 2000G  c W95 FAT32 (LBA)

b) usando lsblk

$ lsblk -fm

FSTYPE      NAME    SIZE OWNER GROUP MODE
            sda     1.8T root  disk  brw-rw----
ext4        ├─sda1  500M root  disk  brw-rw----
LVM2_member └─sda2  1.8T root  disk  brw-rw----
ext4          ├─backups_root (dm-0)
                     50G root  disk  brw-rw----
swap          ├─backups-lv_swap (dm-1)
                   15.8G root  disk  brw-rw----
ext4          └─backups-lv_home (dm-2)
                    1.8T root  disk  brw-rw----
vfat        sdb     1.8T root  disk  brw-rw----
            └─sdb1  1.8T root  disk  brw-rw----


En nuestro caso el disco que queremos montar es /dev/sdb1 (un disco duro externo de 2T)

Nota: para utilizar ambos comandos se necesitan los permisos de un superusuario.

3. Ahora que ya sabemos que disco montar, solo queda montar la partición:

$ mount /dev/sdb1 /media/temp

Solo tenemos que listar la carpeta y nos debería mostrar el contenido.

Ahora si nuestro disco es FAT o NTFS tenemos que agregar unos parámetros para que se monte de manera correcta, agregamos el parámetro -t, seguido de la opción deseada:

FAT    --> vfat
NTFS --> ntfs-3g

Ejemplo(s):
$ mount -t ntfs-3g /dev/sdb1 /media/temp
$ mount -t vfat /dev/sdb1 /media/temp

Para utilizar la opción del ntfs es necesario instalar el paquete ntfs-3g, para el caso de distribuciones CentOS hay que agregar el repositorio EPEL y para el caso de distribuciones Ubuntu ya se encuentra en los repositorios predeterminados.

> Instalar en CentOS
Instalamos primero nuestro repositorio:

RHEL/CentOS 7
$ sudo rpm -Uvh https://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-7-11.noarch.rpm

RHEL/CentOS 6 (64 Bit)
$ sudo rpm -Uvh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm

Instalamos nuestro paquete:

# yum install ntfs-3g

> Instalar en Ubuntu
Aquí es más fácil el asunto:

# apt-get install ntfs-3g

Uso del comando cp (copiar) en Linux

Este comando cp, conocido como copy, se utiliza para la copia de archivos o carpetas, los cuales pueden ser copiados al mismo directorio o en uno diferente, con este comando, al ser ejecutado, el archivo original no es modificado o cambiado.

Aquí el uso básico:

cp [opciones] archivoorigen archivodestino
En el siguiente ejemplo, realizamos una copia de nuestro archivo en la misma ruta, cambiándole el nombre:

cp archivo.txt copia_del_archivo.txt
si quisiéramos copiarlo a otro directorio, solo tenemos que especificar la ruta:

cp archivo.txt /home/midirectorio/
sino se le va a cambiar el nombre, no es necesario especificarlo.

Si deseamos copiar varios archivos solo tendremos que indicarlos, y al final poner la ruta donde los copiaremos:
cp file1.txt file2.txt file3.txt /home/midirectorio/
Ahora si deseamos copiar directorios, tendremos que poner la opcion de -r para indicar que realizaremos una copia recursiva:
cp -r directorio directorioCopia

Este comando tiene muchas opciones, anteriormente solo hemos visto lo básico, pero veremos algunas que también son de utilidad:

-b
Crea un backup en el destino, esto para el caso que exista un archivo con el mismo nombre.

-f, --force
Realiza el borrado de los archivos destino sin consultar o avisar al usuario.

-i, --interactive
Informa antes de sobreescribir un archivo en el destino indicado.

-l, --link
Realiza un enlace en lugar de copiar los archivos.

-p
Realiza la copia de los archivos y directorio conservando la fecha de modificación de los archivos y directorios originales.

-r, -R, --recursive
Realiza la copia de forma recursiva (ideal para directorios).

-u, --update
Esta opción es muy útil para verificar si el archivo destino sufrió alguna modificación, si encuentra algún cambio realiza la copia, en caso contrario conserva el archivo.

-v, --verbose
Explica que es lo que se esta realizando, ideal cuando son varios archivos o de gran tamaño.

Para poner las opciones se pueden poner cada una de las que necesitamos de la siguiente forma:
cp -r -u -v fotos /home/directorio/fotos
o bien:
cp -ruv fotos /home/directorio/fotos
también podemos hacer esto:
cp -ru --verbose fotos /home/directorio/fotos
Como ven las opciones son muy amplias, así que solo queda puedan realizar sus propias pruebas y retroalimenten este pequeño blog.

Comprobar la ejecución de un CRON y guardar el log

Muchas veces cuando creamos un CRON necesitamos saber si la tarea se ejecutará correctamente o contiene errores, debido a que no se ejecuta en una consola visible, no podemos saber el resultado una vez que se pone en marcha. Para ello mostraremos algunos trucos que podemos usar.

Guardar la salida en un log

Con esta opción solo se guardaran los errores que se generen en un archivo que seleccionemos:

* * * * * /home/miusuario/script 1> /dev/null 2> /home/miusuario/logs/archivo.log

Hay que recordar los números de la salida (redireccionamiento con el simbolo >):

• 0 stdin (standard input): el comando
• 1 stdout (standard output): /dev/null la salida se descarta
• 2 stderr (standard error): /home/miusuario/logs/archivo.log la ruta y el archivo de log.

Con esta otra opción guardaremos tanto la salida como los errores:

* * * * * /home/miusuario/script &> /home/miusuario/logs/archivo.log

Enviar el resultado por email

Es similar a la anterior pero envía la información a un correo predeterminado.

* * * * * /home/miusuario/script 1> /dev/null 2>&1 | mail  -s "Errores del cron" correo@correo.com

Cabe mencionar que para ello debe estar instalado y configurado correctamente el comando mail.

Simular el entorno de ejecución

Esta opción permite ejecutar un cron en el momento que deseemos

$ env -i /home/miusuario/script

De esta forma no tenemos que esperar hasta cuando se ejecute de acuerdo a lo programado, podemos realizar las pruebas que sean necesarias en un entorno similar a las que hace el cron.

Instalar wkhtmltopdf

La herramienta wkhtmltopdf nos permite generar el PDF de una pagina html, muy útil si queremos generar reportes PDF de nuestros sistemas, es gratuita asi que mas conveniente para su uso. La instalación es algo complicada ya que no existe mucha documentación al respecto pero al final resulto con éxito, he aquí describo los pasos que me funcionaron:

1. Instalar dependencias previas

Centos

# yum install -y xorg-x11-fonts-75dpi

# yum install -y xorg-x11-fonts-Type1

Ubuntu

# apt-get install xfonts-75dpi

2. Instalar la libreria wkhtmltopdf

Anteriormente se podía instalar directo de sourceforge (downloads.sourceforge.net) pero actualmente la version 0.12.5 wkhtmltopdf tiene su propio repositorio:

Centos 6

wget https://downloads.wkhtmltopdf.org/0.12/0.12.5/wkhtmltox-0.12.5-1.centos6.i686.rpm
Centos 7
wget https://downloads.wkhtmltopdf.org/0.12/0.12.5/wkhtmltox-0.12.5-1.centos7.i686.rpm
Ubuntu 14.04
wget https://downloads.wkhtmltopdf.org/0.12/0.12.5/wkhtmltox_0.12.5-1.trusty_i386.deb
Ubuntu 16.04
wget https://downloads.wkhtmltopdf.org/0.12/0.12.5/wkhtmltox_0.12.5-1.xenial_i386.deb

Solo hay que seleccionar el archivo .rpm o .deb adecuado a nuestra versión del linux y la arquitectura correcta, podemos checar el listado en:

https://wkhtmltopdf.org/downloads.html

Una vez descargado el archivo procederemos a instalarlo

Centos 6

rpm -Uvh wkhtmltox-0.12.5-1.centos6.i686.rpm

Ubuntu 16.04
dpkg -i wkhtmltox_0.12.5-1.xenial_i386.deb

3. Realizar una prueba

Una vez que lo tengamos instalado para probarlo, bastara con teclear el comando y como parametro poner la url de la pagina que queremos convertir

$ wkhtmltopdf http://www.google.com.mx miarchivo.pdf

Si todo funciona correctamente nos debe entregar un informe de lo realizado y el archivo PDF generado:

Loading pages (1/6)

Counting pages (2/6) 

Resolving links (4/6) 

Loading headers and footers (5/6) 

Printing pages (6/6)

Done

En la carpeta donde hayamos ejecutado el comando tendremos nuestro archivo PDF. Esta misma librería la podemos utilizar con PHP, pero eso lo dejamos para otro post.

Crear usuario con minimos privilegios para realizar respaldo de MySQL

Este post es complemento del script para realizar respaldos mediante archivos crontab. Pero se puede utilizar de forma manual para realizar los respaldos.

1. Iniciar mysql y crear usuario

$ sudo mysql -u usuario -p 
mysql> CREATE USER usuario_respaldo@localhost IDENTIFIED BY "MiClave";

2. Asignamos los privilegios

mysql> GRANT SELECT, SHOW VIEW, RELOAD, REPLICATION CLIENT, EVENT, TRIGGER ON *.* TO usuario_respaldo@localhost;

Algunos privilegios no estan disponibles en versiones anteriores de MySQL:

• EVENT, este privilegio es requerido para crear, modificar, eliminar o ver eventos del EVENT SHEDULER. Este privilegio fue agregado en MySQL 5.1.6
• TRIGGER, este privilegio habilita las operaciones de los disparadores. Este privilegio fue agregado en MySQL 5.1.6
• REPLICATION_CLIENT, este privilegio habilita el uso de SHOW_MASTER_STATUS y SHOW_SLAVE_STATUS. En MySQL 5.1.6 y versiones superiores habilita ademas el uso de la sentencia SHOW_BINARY_LOGS

3. Agregamos el privilegio para bloquear las tablas

mysql> GRANT LOCK TABLES ON *.* TO usuario_respaldo@localhost;

4. Probamos el respaldo de una base de datos
 
Nos salimos de mysql y probamos el comando mysqldump

$ mysqldump -u usuario_respaldo -p --databases dbmibase > dbmibase.sql

Si todo fue correcto en nuestro directorio debe existir nuestro respaldo dbmibase.sql.

Script para generar respaldos MySQL mediante el CRON

Cuando tenemos varias bases de datos en nuestros servidor y ya por algun tiempo, es necesario contar con alguna herramienta que permita generar respaldos de forma automatica, con la finalidad de prevenir inconvenientes con la información que manejamos y poder recuperarnos de la eventualidad lo mas antes posible.

A continuación describiremos los pasos para poder generar nuestro script y asignarlos a las tareas automaticas de nuestro servidor.

1. Preparando todo

Generalmente el servicio de crond viene instalado por defecto en nuestro servidor y es el que se encarga de ejecutar programas, comandos o script en un horario determinado. Para saber el estado en el que se encuentra el servicio escriba la siguiente sentencia:

$ sudo service crond status

En caso de no contar con este servicio, sera necesario su instalación. Seguido sera necesario contar con una carpeta donde ingresaremos nuestros script, en mi caso dentro de la carpeta home

$ mkdir /home/miusuario/ejecutar

Creamos nuestra carpeta donde iremos guardando nuestros respaldos (lo ideal es contar con otro servidor donde tengamos estos respaldos)

$ mkdir /home/miusuario/respaldos

Para nuestro caso sera necesario contar con un usuario en MySQL que tenga los permisos suficientes para poder ejecutar los comando mysql y mysqldump, así como el permiso para generar los respaldos correspondientes a todas las bases de datos.

Verificamos que la fecha y hora de nuestro servidor sea la correcta para no tener algunos resultados no deseados,

$ date
mié ago 10 15:00:01 CDT 2015

y en caso de ser necesario definimos el horario correcto:

$ sudo date --set "2015-08-19 15:12:10"

Por ultimo, cuando ejecutemos el crond se ejecutara el editor por defecto, en la mayoría de los casos el editor vi es el que viene configurado, aquí dependerá de con cual se sienta uno más cómodo. En mi caso habilite el nano, he aquí la instrucción para habilitarlo momentáneamente:

$ sudo export EDITOR="nano"

Si deseamos que sea permanente habrá que agregarlo en el .bashrc o en el .bash_profile del usuario deseado.


2. Generamos nuestro script

Una vez que tenemos todo listo generamos nuestro script en la carpeta deseada (/home/miusuario/ejecutar):

$ nano /home/miusuario/ejecutar/respaldarMySQL.sh


#!/bin/bash

# Configurar variables de entorno
FECHA=`date +%d%m%Y-%H%M%S`
DIRECTORIO="/home/miusuario/respaldos"

# Obtener los nombres de las bases de datos
misbases=`mysql -uusuariomysql -pmiclave --skip-column-names -e'SHOW DATABASES'`

# Crear el respaldo de las bases de datos
for db in $misbases; do
    # Nombre del archivo de respaldo
    archivo="$db-$FECHA.sql.gz"
    if [ $db != "mysql" ] && [ $db != "information_schema" ]; then
        # Crear respaldo, comprimirlo
        # y si fue exitoso guardar una bitacora
        mysqldump -uusuariomysql -pmiclave --databases $db | gzip -9 > \
        $DIRECTORIO/$archivo && echo "Respaldo realizado con exito: \
        $archivo" >> $DIRECTORIO/bitacora.log
    fi
done

Nota: El caracter \ indica que la cadena continua con la linea inferior

Describiremos algunas lineas para que quede mas claro este script:

• La variable FECHA guardara la fecha y hora actual, que se concatenara para formar el nombre del archivo. (%d%m%Y-%H%M%S => 19082015-100001)
• DIRECTORIO sera la ruta donde guardaremos los respaldos
• misbases obtendra todas las bases de datos de nuestro servidor
• archivo tendra la concatenacion de la base de datos y la fecha y hora para formar el nombre de nuestro respaldo
• el if verificara que no sean las bases mysql e information_schema, las cuales no respaldaremos
• Ahora viene lo interesante:
• mysqldump generara el respaldo de cada una de las bases de datos
• el caracter | indica que una vez que se tenga el resultado de mysqldump sera como parametro del siguiente comando (gzip)
• gzip realiza la compresion del respaldo de la bd y con el caracter > se indica que se guardara en el archivo $DIRECTORIO/$archivo, si no existe el archivo se crea uno nuevo y si existe reemplazara al anterior.
• con el caracter && se indica que el siguiente comando se ejecutara solo si el anterior se ejecuto satisfactoriamente
• Si se ejecuto correctamente el respaldo y la compresion, se guarda el registro de que todo fue un exito en el archivo bitacora.log, con el caracter >> se indica que si el archivo bitacora.log no existe se creara uno nuevo y si existe se agregara una nueva linea al final del archivo
• Este proceso se realiza por cada una de las bases de datos

Para probar que funciona este script, simplemente lo ejecutamos y verificamos el resultado, no se olvide cambiar los permisos necesarios para que el archivo sea ejecutable.

3. Creamos el cron

Bueno hasta este momento ya tenemos listo el script  probado, procederemos a definir cuando se ejecutara para que se realicen los respaldos correspondientes, primero aqui una explicación de como se compone un archivo crontab:

.---------------------- Minuto (0 - 59)
| .-------------------- Hora (0 - 23)
| |  .----------------- Día del mes (1 - 31)
| |  | .--------------- Mes (1 - 12)
| |  | | .------------- Día de la semana (0 - 6) (0 = domingo)
| |  | | | .----------- Usuario
| |  | | | |    .------ Script o programa a ejecutar
↓ ↓  ↓ ↓ ↓ ↓    ↓
5 15 * * * user /home/user/ejecutar/miscript.sh
En este ejemplo se ejecutara miscript.sh a las 15:05 todos los días, todos los meses, cada dia de la semana como usuario user. Aqui se listan algunos caracteres especiales que se pueden usar:

• utilice un espacio para separar cada campo
• para varios valores separelos por comas
• para un rango de valores separelos por un guión
• el * se utiliza como comodin para incluir todos los valores
• el # al inicio de la linea se utiliza como comentario

Todos los comandos del archivo crontab deben ir en una sola linea por muy larga que sea esta, ya que no se reconocen los retorno de carros adicionales.

Ahora si creamos nuestro archivo crontab, el cual se ejectuara todos los dias de la semana de todos los meses a la 1:00am para realizar nuestro respaldo:

$ sudo crontab -e -u miusuario
00 1 * * * miusuario /home/miusuario/ejectuar/respaldarMySQL.sh

Guardamos nuestro archivo y listo, tenemos un archivo crontab preparado.

4. Algunos comentarios

Para consultar nuestros archivos crontab, utilicemos la siguiente instruccion

$ sudo crontab -l

Para editar el archivo crontab de algun usuario

$ sudo crontab -e -u miusuario

Los archivos crontab se guardan en la siguiente ruta /var/spool/cron, debe tener privilegios de root para consultar el listado.

5. Actualización (10/01/2019)

Para evitar que en nuestro script queden expuestas las credenciales de nuestro usuario que realizara el respaldo, podemos agregar las lineas de acceso al archivo my.cnf (generalmente esta en /etc/my.cnf) de la configuración del mysql, asi nuestro script solo tendra las lineas sin el usuario:

respaldarMySQL.sh

# Obtener los nombres de las bases de datos

misbases=`mysql --skip-column-names -e'SHOW DATABASES'`

.

.

.

# y si fue exitoso guardar una bitacora

        mysqldump --databases $db | gzip -9 > \

.

.

.

En nuestro archivo my.cnf agregamos las siguientes lineas:

[mysqldump]

# Usuario para el respaldo

user=usuariomysql

password=miclave

[mysql]

# Usuario para la consulta de las bases

user=usuariomysql

password=miclave

Reiniciamos nuestro servicio para que podamos ejecutar nuestro script, y listo.

Saber distribución y versión de linux

1. El siguiente comando sirve para saber la distribución del linux y su versión:

$ sudo cat /etc/issue
// ejemplo 1
CentOs release 5.10 (Final)
Kernel \r on an \m

// ejemplo 2
Ubuntu 14.10 \n \l

2. El siguiente comando sirve para saber la arquitectura del servidor:

$ sudo uname -m
// para 64 bits
x86_64 

// para 32 bits
i386
i686

También puede usar el siguiente comando:

$ arch

Crear, eliminar o modificar usuarios en Linux

Aquí dejo algunos comandos básicos que serán útiles para crear, eliminar y/o modificar usuarios en nuestro sistema Linux.

Crear usuarios
Para crear un usuario usaremos el comando useradd:

$ sudo useradd -g migrupo -G ftp -s /bin/shell -d /home/micarpeta -m usuario_demo

he aquí una pequeña descripción de los parámetros
-d directorio home del usuario
-m crear carpeta home sino existe
-s shell del usuario
-g grupo primario al que pertenece el usuario
-G grupos a los que pertenece también el usuario

Se recomienda que el nombre del usuario lo  manejemos en minúsculas, podemos incluir también números y guiones. Una vez creado el usuario hay que utilizar el comando passwd para agregarle un password al usuario:

$ sudo passwd usuario_demo
Changing password for usuario_demo.
(current) UNIX password: 

Eliminar usuarios
Para eliminar usuarios usaremos el comando userdel:

$ sudo userdel usuario_demo

Este comando es mas sencillo, si queremos que además se borre el contenido de la carpeta home del usuario, hay que agregar el parámetro -r antes del nombre de usuario.


Modificar usuarios
Para modificar usuarios se utiliza el comando usermod:

$ sudo usermod -d /home/nuevacarpeta usuario_demo

los parámetros son parecidos a los de crear un usuario:
-d modificar home del usuario
-s modificar shell del usuario
-g modificar grupo primario al que pertenece el usuario
-G modificar grupos a los que pertenece también el usuario

Conectar a MySQL de forma remota

En la mayoría de los casos podemos acceder a MySQL a través de la consola o por medio de phpMyAdmin, pero sabemos que algunas funciones están limitadas por este medio, para ello necesitamos acceder a MySQL de forma remota.

Primero tendremos que comprobar que nuestro firewall (cortafuegos) del servidor no este impidiendo la comunicación con el puerto 3306 (normalmente el puerto de MySQL) en caso de ser así tendremos que desactivarlo o en su caso configurarlo adecuadamente para que permita el acceso al puerto.

Bueno una vez dicho esto describiremos los pasos para configurar el MySQL para acceder de forma remota.

1. Primero probaremos el puerto 3306 (normalmente el puerto de MySQL) a través de nuestro cliente:

telnet miip_o_eldominio.xxx.xxx 3306
conectandose a miip_o_eldominio.xxx.xxx...
No se pudo abrir la conexión al host, en puerto 3306: Error en la conexión

Como vemos en el ejemplo no tenemos acceso al puerto, aunque este desactivado el firewall o configurado adecuadamente, si no se permiten conexiones remotas en el MySQL no se podrá acceder.

2. Revisamos nuestro archivo my.cnf, que generalmente se encuentra en /etc/mysql/my.cnf

$ sudo nano /etc/mysql/my.cnf

Verificamos las variables bind-address y skip-networking. Si se encuentra skip-networking y no está comentada, la comentamos para que no tenga efecto y se permitan conexiones externas.

# comentamos esta linea
# skip-networking

Si encontramos bind-address = 127.0.0.1 o bind-address = localhost también hay que editarlo y cambiar el valor por el de la ip externa desde la que se quiera conectar (sólo se permite una), o por 0.0.0.0 para que cualquier dirección se conecte, en este ultimo caso habrá después que filtrarlas por otros medios (firewall o seguridad a nivel de control de acceso).

bind-address=0.0.0.0

3. Guardamos nuestro archivo y reiniciamos el MySQL.

Para Ubuntu, Debian
$ sudo service mysql restart

Para CentOS, Fedora
$ sudo service mysqld restart

4. Realizamos nuestra prueba de Telnet y nos tiene que permitir el acceso al puerto

telnet miip_o_dominio.xxx.xxx 3306
Conectando miip_o_dominio.xxx.xxx
5.5.9.riocp$%=+_:t0mysql_native_password

5. Una vez hecho esto realizamos una prueba de conexión para conectarnos de forma remota a nuestro servidor MySQL (puede realizarse con algún programa cliente), si aun así no es posible conectarse necesita verificar que el usuario ha sido creado correctamente.

Para ello verificamos en la base de datos mysql la tabla users, en el campo host el valor deberá sera la ip desde la cual deseamos conectarnos o en su defecto el % para que permita conectarse desde cualquier ip. Esto lo podemos realizar con la consola del MySQL.

mysql>GRANT ALL PRIVILEGES ON mibase.* to usuario@'%' IDENTIFIED BY 'elpassword';

Para ver mas sobre como crear usuarios checa el siguiente post:
http://mgermano.blogspot.mx/2014/04/crear-y-borrar-usuarios-de-mysql-por.html

Actualizar PHP 5.1 a PHP 5.4 en CentOS 5.9

En este artículo, veremos como actualizar de PHP 5.1 o 5.2 a PHP 5.4, así mismo actualizaremos el MySQL a la versión 5.5.

1. Primero tenemos que instalar los repositorios epel y remi, con la siguiente instrucción:

$ wget http://dl.fedoraproject.org/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm
$ wget http://rpms.famillecollet.com/enterprise/remi-release-5.rpm
$ sudo rpm -Uvh remi-release-5*.rpm epel-release-5*.rpm

2. Después tenemos que habilitar el repositorio remi en el siguiente archivo:

$ sudo nano /etc/yum.repos.d/remi.repo

dentro de este archivo tenemos que habilitar en la sección [remi] el repositorio.

enabled = 1

3. Ahora tenemos que actualizar el php

$ sudo yum install php

4. Después de esto tenemos que reiniciar nuestros servicios de Apache y MySQL

$ sudo service httpd restart
$ sudo service mysqld restart

5. En caso de que no tengamos configurado para que nuestros servicios arranquen de inicio, tendremos que habilitarlo, probamos reiniciando nuestro servidor:

# chkconfig --levels 235 httpd on
# chkconfig --levels 235 mysqld on

Por ultimo probamos en nuestro navegador que este actualizada nuestra versión.

Sensibilidad de mayusculas y minusculas en nombres de tablas MySQL

Hace poco me encontré con un problema al pasar una base de datos de Windows a Linux, el problema fue que en Windows los nombres de las bases de datos y las tablas no son sensibles a mayúsculas y minúsculas, una posible solución seria manejar todo en minusculas para que no exista ese problema, pero sabemos que eso, sobre todo si se tiene un estandar de base de datos, no es una solución viable.

La solución es cambiar el valor a una variable de MySQL: lower_case_table_names. He aqui una explicación obtenida del manual de referencia de MySQL.

Valor	Significado
0	Los nombres de tablas y bases de datos se almacenan en disco usando el esquema de mayúsculas y minúsculas especificado en las sentencias CREATE TABLE o CREATE DATABASE. Las comparaciones de nombres son sensibles a mayúsculas. Esto es lo predeterminado en sistemas Unix. Nótese que si se fuerza un valor 0 con --lower-case-table-names=0 en un sistema de ficheros insensible a mayúsculas y se accede a tablas MyISAM empleando distintos esquemas de mayúsculas y minúsculas para el nombre, esto puede conducir a la corrupción de los índices.
1	Los nombres de tablas se almacenan en minúsculas en el disco y las comparaciones de nombre no son sensibles a mayúsculas. MySQL convierte todos los nombres de tablas a minúsculas para almacenamiento y búsquedas. En MySQL 5.0, este comportamiento también se aplica a nombres de bases de datos y alias de tablas. Este valor es el predeterminado en Windows y Mac OS X.
2	Los nombres de tablas y bases de datos se almacenan en disco usando el esquema de mayúsculas y minúsculas especificado en las sentencias CREATE TABLE o CREATE DATABASE, pero MySQL las convierte a minúsculas en búsquedas. Las comparaciones de nombres no son sensibles a mayúsculas.Nota: Esto funciona solamente en sistemas de ficheros que no son sensibles a mayúsculas. Los nombres de las tablas InnoDB se almacenan en minúsculas, como cuandolower_case_table_names vale 1.

1. Para verificar que valor tiene esta variable, podemos hacerlo de 3 formas:
  a) buscar la opción de mostrar variables (show variables) en nuestro cliente de MySQL
  b) en la pestaña variables mediante phpMyAdmin buscarla
  c) entrar mediante la consola de comandos a mysql y escribir el siguiente comando:
  mysql> show variables like "%lower%";

2. En Windows por defecto el valor es 1, para cambiar el valor podemos usar el phpMyAdmin, si es que tenemos un usuario con los suficientes privilegios, y mediante la pestaña variables podemos editarla cambiando su valor a 0, posterior a ello tendremos que reiniciar el servicio de MySQL.

En caso de no tener phpMyAdmin o el usuario, habrá que ubicar el archivo de configuración de MySQL (my.ini o my.cnf), la ubicación dependerá de la versión y como hayan instalado, he aquí algunas ubicaciones donde podría estar:

c:\Windows\my.ini
c:\ruta_de_mysql\MySQL\my.ini
c:\Program Data\MySQL\MySQLversion\my.ini

Editamos este archivo actualizando o agregando la siguiente linea en caso de que no exista:
[mysqld]
...
lower_case_table_names = 0

Guardamos y reiniciamos nuestro servicio MySQL. Verificamos que el valor de nuestra variable este en 0.

Posterior a ello tendremos que renombrar nuestras bases de datos y/o tablas sensibles a mayúsculas y minúsculas antes de hacer una migración a nuestro servidor en producción de Linux.

Actualizar Tomcat 6 al 7 en Ubuntu

Aquí describiremos como actualizar nuestro Tomcat 6 a la versión 7, esta actualización conservara nuestros archivos en webapps, sin embargo se recomienda realizar un respaldo de nuestras aplicaciones para evitar alguna perdida.

Primero detenemos el servicio de tomcat que tenemos en nuestro servidor, posteriormente para actualizar solo escribimos el siguiente comando:

$ sudo apt-get purge tomcat6 && sudo apt-get autoremove && sudo apt-get install tomcat7

Iniciamos nuestro servicio, después solo tendremos que copiar nuestras aplicaciones a la nueva ruta de tomcat: /var/lib/tomcat7/webapps, posterior a ello sera necesario instalar las herramientas de administración y configurar nuestros usuarios en /etc/tomcat7/tomcat-users.xml. (http://mgermano.blogspot.mx/2014/04/configurar-usuario-admin-en-tomcat.html)

$ sudo apt-get install tomcat7-admin

Instalar Tomcat 6 en Ubuntu

Instalar tomcat en Ubuntu es más sencillo que en CentoOs, aquí describimos los pasos a seguir:

1. Instalamos nuestro servidor mediante el siguiente comando

$ sudo apt-get install tomcat6

De esta forma se instalara el servidor con ROOT webapp que muestra una página sencilla que dice It works (http://localhost:8080).

Por defecto el tomcat trabaja en el puerto 8080 (conector http), si deseas cambiarlo, toda la configuración del tomcat se encuentra en /etc/tomcat6/server.xml, las lineas a modificar serian las siguientes:

<Connector port="8080" protocol="HTTP/1.1" 
           connectionTimeout="20000"
           redirectPort="8443" />

2. Para que tomcat trabaje tenemos que tener instalado el JDK, lo hacemos mediante la siguiente linea:

$ sudo apt-get install default-jdk

3. Para la administración del tomcat instalamos el paquete correspondiente:

$ sudo apt-get install tomcat6-admin

Podemos instalar también la documentación y ejemplos del tomcat:

$ sudo apt-get install tomcat6-docs tomcat6-examples

4. Antes de reiniciar nuestro servidor, no se olvide que tenemos que crear nuestro usuario de administración del tomcat, como se describe en: http://mgermano.blogspot.mx/2014/04/configurar-usuario-admin-en-tomcat.html, y tendremos nuestro servidor tomcat listo para trabajar (http://localhost:8080).

$ sudo service tomcat6 restart

Montar particiones al inicio en Linux

1. Primero tenemos que identificar que partición es la que vamos a montar con el siguiente comando:

$ sudo fdisk -l

Disco /dev/sda: 500.1 GB, 500107862016 bytes
Identificador del disco: 0x40a6023f

Disposit. Inicio    Comienzo    Fin    Bloques  Id    Sistema
/dev/sda1    *       2048    206847    102400    7    HPFS/NTFS/exFAT
/dev/sda2          206848 204799999 102296576    7    HPFS/NTFS/extFAT
/dev/sda3       204800000 400112499  97656250   83    Linux
/dev/sda4       400112500 404113407   1999872   82    Linux swap

La partición que usaremos sera la /dev/sda3

2. Identificamos el UUID (Universally Unique IDentifier) con el siguiente comando

$ sudo blkid /dev/sda3

/dev/sda3: UUID="8ff9f53e-732c1935aa" TYPE="ext4"

3. Creamos una carpeta donde se montara la partición dentro de /media, en este caso la llamaremos appweb

$ sudo mkdir /media/appweb

4. Editamos el archivo fstab para que se monte inicialmente

$ sudo nano /etc/fstab

Ahora dependiendo del tipo de partición configuramos según sea el caso:

# <file system>  <mount point>  <type>  <options>  <dump>  <pass>
NTFS
UUID=8ff9f53e-732c1935aa  /media/appweb  ntfs-3g default 0 0

FAT
UUID=8ff9f53e-732c1935aa  /media/appweb  vfat rw,uid=1000,gid=1000 0 0

Ext4
UUID=8ff9f53e-732c1935aa  /media/appweb  ext4  errors=remount-ro 0 1

En este caso nuestra partición es Ext4, recuerda agregar tu UUID y la carpeta donde montaras esta partición, así como los espacios en blanco se refieren a tabuladores.

Guardamos nuestro archivo y reiniciamos nuestro servidor, al cargar nuestro sistema deberíamos tener montada nuestra partición.

Directorios virtuales para Apache en Ubuntu

Cuando instalamos apache, la carpeta por defecto donde alojamos nuestras aplicaciones se encuentra en /var/www, pero en la práctica es mejor tener un directorio donde montar nuestras aplicaciones, a continuación describiremos los pasos a seguir.

1. Creamos la carpeta donde alojaremos nuestras aplicaciones, aquí por ejemplo creamos una carpeta llamada appweb dentro de nuestro home de usuario.

$ sudo mkdir /home/miusuario/appweb

2. Definimos y configuramos nuestro directorio virtual, para ello creamos un archivo con un nombre que haga referencia a nuestro directorio dentro de /etc/apache2/sites-available.

$ cd /etc/apache2/sites-available

$ sudo nano appweb.conf

Dentro de este archivo agregamos las siguientes lineas

# domain appweb

# public /home/miusuario/appweb

<VirtualHost *:80>

# definimos como accederemos al directorio

ServerName appweb

ServerAlias appweb

DirectoryIndex index.php index.html

# definimos el directorio donde estaran las aplicaciones

Documentroot /home/miusuario/appweb

# definimos nuestro log de acceso y de errores

ErrorLog /home/miusuario/appweb/log/error_log.log

CustomLog /home/miusuario/appweb/log/access_log.log combined

# definimos los permisos en nuestro directorio

<Directory /home/miusuario/appweb/>

    Options All

    Require all granted

</Directory>

</VirtualHost>

Terminado de agregar las líneas, guardamos nuestro archivo.

Nota: La configuración de los permisos es para Apache 2.4, para versiones anteriores debe cambiar dentro del Directory a las siguientes lineas:

<Directory /home/miusuario/appweb/>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride All
    Order deny,allow
    Allow from all
</Directory>

3. Creamos los archivos del log dentro de nuestro directorio ya que no existen.

$ sudo touch /home/miusuario/appweb/log/error_log.log
$ sudo touch /home/miusuario/appweb/log/access.log

4. Ahora activamos el directorio

$ sudo a2ensite appweb

5. Después tenemos que configurar el archivo hosts en /etc

$ sudo nano /etc/hosts

en el archivo agregamos nuestro sitio:

127.0.0.1    localhost
127.0.0.1    appweb

# The following lines are desirable for IPv6 capable hosts

6. Ahora reiniciamos o cargamos nuevamente la configuración de nuestro servidor apache

$ sudo service apache2 restart
   ó
$ sudo service apache2 reload

7. Por ultimo creamos un index.php agregandole la función phpinfo() en nuestro directorio virtual /home/miusuario/appweb, lo guardamos y probamos desde nuestro navegador

http://appweb

y nos debería listar la configuración de nuestro PHP.

Nota: si la carpeta donde guardaras tus aplicaciones se encuentra en /media y no se monta al inicio cuando arrancas tu servidor, podría generarte un error de permisos, por lo cual recomiendo que se monte esta unidad al arrancar el sistema, como se describe en el siguiente post: Montar particiones al inicio en linux

Agregar headers de expiración (Add Expires headers)

Los encabezados (headers) de expiración nos sirven para indicar cuando expira un determinado tipo de archivo, esto hace que no sea necesaria una nueva carga del mismo si es que aun no ha expirado. Esto es muy útil para archivos del tipo imagen, vídeo, javascript y hojas de estilo entre otros, ya que nos reduce las solicitudes HTTP lo que nos lleva a la carga de nuestra página en un menor tiempo.

Si tenemos acceso a nuestro servidor podremos editar el archivo de configuración del apache.

Para CentOS, RedHat Fedora
$ sudo nano /etc/httpd/conf/httpd.conf

Para Ubuntu, Debian
$ sudo nano /etc/apache2/apache2.conf

Si no tuviesemos acceso al servidor podemos editar el archivo .htaccess de nuestro sitio o crearlo en caso de que no exista.

$ sudo nano /larutademisitio/.htaccess
Para cualquiera de los casos dentro del archivo, las lineas que debemos agregar o editar son las siguientes:

<IfModule mod_expires.c>
# Habilitar la expiración
ExpiresActive On

# Para las imágenes (1 mes)
ExpiresByType image/gif "access plus 1 months"
ExpiresByType image/png "access plus 1 months"
ExpiresByType image/jpg "access plus 1 months"
ExpiresByType image/jpeg "access plus 1 months"

# Para archivos CSS (1 semana)
# 60*60*24*7, de acuerdo a la modificación del archivo
ExpiresByType text/css M604800

# Para archivos JavaScript (2 meses)
ExpiresByType application/javascript "access plus 60 days"

# Directiva por default para los demás archivos
ExpiresDefault "access plus 1 months"

</IfModule>
Puedes adecuar el tiempo en que expirara cada archivo de acuerdo a tus necesidades, como recomendación es mejor darle mas tiempo a aquellos archivos que no cambien regularmente como las imagenes o javascript.

Posterior a ello, guardamos el archivo y reiniciamos el servicio de apache.

Para Ubuntu, Debian
$ sudo service apache2 restart

Para Centos, RedHat, Fedora
$ sudo service httpd restart

Nota: 
A continuación listamos los tipos de expiración que podemos agregar

• years
• months
• weeks
• days
• hours
• minutes
• seconds

Así por ejemplo podemos colocar "access plus 4 weeks" para indicar que durara 4 semanas. 

También es posible asignar el tiempo de forma manual multiplicando segundos, minutos, horas, días según sea el caso. Por ejemplo para indicar 30 dias, seria 60(segundos) * 60(minutos) * 24 (horas) * 30 (días) = A2592000.

Ahora podemos usar M o A según se ajuste a nuestra necesidades:

• M - Tiempo base sería la ultima modificación del archivo
• A - Tiempo base sería el ultimo acceso del usuario al archivo

Instalación y configuración de vsftpd en Linux

VSFTPD (Very Secure FTP Daemon) se utiliza para implementar servidores de archivos a través del protocolo de transferencia de archivos FTP (File Transfer Protocol), de esta forma tendremos un servidor rápido, ligero, seguro y de fácil configuración.

Instalación

---

Para instalarlo, solo tenemos que escribir el siguiente comando en nuestra consola:

Para CentOs, Fedora o RedHat
$ sudo yum -y install vsftpd

Para Ubuntu, Debian
$ sudo apt-get install vsftpd

Configuración

---

Una vez que tenemos instalado el vsftpd procederemos a configurarlo, crear usuarios y enjaularlos.

1. Editaremos el archivo vsftpd.conf que se encuentra en /etc/vsftpd/,

$ sudo nano /etc/vsftpd/vsftpd.conf

El archivo es fácil de entender, pero aquí explicaremos lo básico para configurar nuestro servidor FTP.

Usuario anónimo
Por defecto viene como YES, lo cambiamos a NO para no permitir el acceso de usuarios anónimos.
anonymous_enable=NO

Mensaje de Bienvenida
Aqui podemos colocar un mensaje de bienvenida al conectarse por FTP
ftpd_banner=Bienvenida al servidor FTP de pruebas

Permitir escritura en el servidor
Esta opción es importante ya que nos permitirá escribir en el servidor, por defecto viene como YES.
write_enable=YES

Sesiones locales
Permite que los usuarios locales puedan también iniciar sesión.
local_enable=YES

Enjaular usuarios
Aquí vienen tres lineas importante para enjaular a los usuarios y restringir el acceso a otras carpetas que no sean su directorio HOME.

Evita que los usuarios registrados puedan salir de su directorio HOME
chroot_local_user=YES

Habilita la lista de usuarios que serán enjaulados
chroot_list_enable=YES

Ruta de la lista de usuarios a enjaular, este archivo no existe lo crearemos después.
chroot_list_file=/etc/vsftpd/chroot_list

2. Creamos el archivo chroot_list en /etc/vsftpd/

$ sudo touch /etc/vsftpd/chroot_list
$ sudo nano /etc/vsftpd/chroot_list

En el archivo solo agregamos en forma de lista los usuarios a enjaular, una ves terminado de agregar, guardamos los cambios.

usuario1
usuarioftp2
otrousuario

3. Creamos los usuarios ftp
$ sudo useradd -d /var/www/html/homeusuario1 -s /bin/false -g ftp usuario1

-d, indicamos la carpeta HOME del usuario
-s, indicamos el shell del usuario
-g, indicamos el grupo al que pertenecerá el usuario

Nota:
Podemos colocar tanto /bin/false como /sbin/nologin en el shell del usuario con la finalidad de impedir el acceso al shell completo,  cada uno con algunas diferencias, /sbin/nologin evita la entrada por consola y ssh, en cambio /bin/false evita la entrada por consola, ssh y ftp, por eso en nuestro caso usaremos /bin/false ya que es mas restrictivo.

Sin embargo vsftpd utiliza PAM (Pluggable Authentication Modules) para autentificar a los usuarios y por ello no admite ningun shell que no este listado en /etc/shells, para ello tendremos que agregar este shell a nuestro archivo.

$ sudo nano /etc/shells

en el archivo agregamos /bin/false y guardamos los cambios

...
/bin/tcsh
/bin/csh
/bin/ksh
/bin/false

Sino realizamos estos cambio no podremos ingresar a través de FTP, mostrandonos un error de login del usuario.

4. Agregamos la contraseña al usuario
# passwd usuario1
Changing password for user usuario1
New UNIX password:

5. Iniciamos el servicio FTP
Iniciamos nuestro servicio vsftpd con cualquiera de los dos comandos:

# service vsftpd start
ó
# /etc/init.d/vsftpd start

Nota:
Es necesario verificar que el puerto 21 por TCP no este bloqueado en nuestro firewall, para ello tenemos que checarlo en nuestro servicio iptables.

6. Probamos nuestro servidor FTP
Podemos probar que todo funcione correctamente accesando a través de nuestro navegador con la IP de nuestro servidor (ftp://190.190.200.1)  donde se nos pedirá un usuario y contraseña que serán los que agregamos en el paso 4. Como observaremos solo tendremos acceso a nuestra carpeta HOME permitida.

Podemos también usar otro software como Filezilla© o el complemento Fireftp de Mozilla Firefox©.

Actualización 13/Abril/2016
Si se cuenta con un firewall perimetral para no abrir todos los puertos al permitir un FTP Pasivo, realizar las siguientes modificaciones:

1. Permitir un rango de puertos para la conexión del FTP Pasivo, para ello agregamos las siguientes lineas al archivo /etc/vsftpd/vsftpd.conf. El rango puede ser del 1024 al 65535, este rango es el que se debe habilitar en nuestro firewall perimetral.

pasv_min_port=60000
pasv_max_port=60009

2. Para no realizar más cambios a IPTABLES podemos utilizar el módulo Connection Track FTP, el cual abrira y cerrara el puerto (del rango definido) necesario para realizar la conexión mediante el siguiente comando:

/sbin/modprobe ip_conntrack_ftp

Si se desea que este comando sea persistente desde el inicio, habrá que agregar la línea anterior al archivo /etc/rc.local

Solucionar el error "Got a packet bigger than 'max_allowed_packet' bytes" en MySQL

Cuando importamos o realizamos una carga de datos a una instancia ya existente en MySQL, y se nos muestra un error como el siguiente:

ERROR 1153 (08S01) at line 625: Got a packet bigger than 'max_allowed_packet' bytes

Es porque desde nuestro cliente enviamos un paquete mayor del que esta configurado nuestro servidor, por defecto esta variable (max_allowed_packet) esta configurada con 1Mb. Tanto el cliente como el servidor tienen su propia variable max_allowed_packet así que si se desea gestionar paquetes grandes, se debe aumentar esta variable tanto en el cliente como en el servidor.

A) Para cambiar esta variable en nuestro servidor tenemos que modificar el archivo my.cnf (my.ini en Windows),

$ sudo nano /etc/my.cnf

y cambiar el tamaño de la variable o agregarla si es que no existe:

[mysqld]
max_allowed_packet = 16M

En versiones inferiores a MySQL 4.0 el tamaño maximo permito es de 16Mb, en versiones superiores es de 1Gb. Es seguro incrementar el valor de esta variable porque la memoria extra tan solo es utilizada cuando se necesita.

Despues de modificar el archivo, tendremos que reiniciar nuestro servicio:

$ sudo service mysqld restart

B) Para cambiar la configuración del cliente, solo necesita en su instancia indicar el tamaño a usar, aunque una vez configurado nuestro servidor ya no sera necesario en nuestro cliente:

mysql> mysqld --max_allowed_packet=16Mb

Actualizar manualmente phpMyAdmin en Linux

Explicaremos como actualizar de forma manual el phpMyAdmin a la versión más reciente, para ello primero bajaremos el paquete comprimido mas actual de la siguiente dirección http://www.phpmyadmin.net/home_page/downloads.php, antes de ello tendremos que verificar los requerimientos mínimos del paquete. En mi caso bajare la versión 4.1.13 donde se indica que se requiere como mínimo PHP 5.2 y MySQL 5, aunque se recomienda PHP 5.3 y MySQL 5.5. Les recomiendo que el archivo que bajemos se descomprima por consola en nuestro servidor.

1. Subir el archivo a nuestro servidor
Puede ser en nuestra carpeta home o directamente en la ubicación del phpMyAdmin: /usr/share

2. Renombrar el phpMyAdmin anterior

$ sudo mv /usr/share/phmyadmin /usr/share/phpmyadmin-backup

Esto con la finalidad de tener un respaldo por si algo llega a salir mal.

3. Descomprimir el archivo
La ruta donde lo tenemos que descomprimir es en /usr/share

$ sudo tar -xvf phpMyAdmin-4.1.13-all-languages.tar.gz

Renombramos la carpeta que se genero al descomprimir como: phpMyAdmin

$ sudo mv phpMyAdmin-4.1.13-all-languages phpMyAdmin

4. Probamos el acceso a phpMyAdmin

En el navegador probamos que podamos acceder: http://localhost/phpMyAdmin, y listo ya tenemos phpMyAdmin actualizado.

Una vez que no existan problemas al acceder, podemos eliminar el archivo comprimido (.tar.gz) y el phpMyAdmin con la versión anterior (phpMyAdmin-backup). Recordemos que en caso que se requiera editar la configuración podemos acceder a /etc/phpmyadmin/config.inc.php el cual es nuestro archivo de configuración del phpMyAdmin.

Instalar FreeTDS en Ubuntu para usar mssql en PHP

A partir de PHP 5.3 la extensión (mssql) para permitir el acceso a base de datos MS SQL Server ya no esta disponible en Windows, en lugar de ello tendremos que usar la extensión de ODBC pero ese es otro tema, aqui veremos una opción para acceder a bases de datos de SQL Server utilizando la libreria FreeTDS (Tabular Data Stream).

FreeTDS es un conjunto de librerias distribuidas libremente bajo licencia GNU/GPL, que nos permite comunicar PHP con bases de datos de SQL Server y Sybase.

1. Desde linea de comandos instalamos freeTDS asi como la libreria sybase de PHP

$ sudo apt-get install freetds-common freetds-bin tdsodbc php5-sybase

Reiniciamos nuestro servidor web y probamos en el navegador, creando un archivo php con la función phpinfo(), verificando que la libreria mssql se encuentra ya instalada.

2. Configuramos FreeTDS
Editamos el archivo freetds.conf que se encuentra en /etc/freetds

$ sudo nano /etc/freetds/freetds.conf

Dentro del archivo vienen algunos ejemplos de configuración, he aquí un ejemplo de como configurar:

[nombreservidor]
host = 100.100.100.1
port = 1433
tds version = 7.2

con [nombreservidor] es como haremos referencia a nuestro servidor , en host agregamos nuestra IP del servidor, el puerto (port) para servidores de SQL Server es el 1433, tds version es la versión del SQL que estaremos usando.

1.  7.0 -- Microsoft SQL Server 7
2.  7.1 -- Microsoft SQL Server 2000
3.  7.2 -- Microsoft SQL Server 2005 o posterior

Una vez terminado de configurar el archivo, lo guardamos.

3. Probando nuestra conexión
Para ver si todo esta correcto realizamos una prueba:

$ tsql -S nombreservidor -U usuariosql

en seguida se pedira el password, si no hay problema, habremos ingresado a nuestro servidor SQL. Recordemos que nombreservidor es nuestra referencia que ingresamos en nuestro archivo de configuración freetds.conf.

4. Probando nuestra conexión en PHP
Ya tenemos todo listo para comenzar a trabajar en php con mssql, podemos crear un archivo en php y probar nuestra conexion.

<?php
/** Conexión a SQL Server **/
$host    = "nombreservidor"; // esta es nuestra referencia
$usuario = "sa";
$pass    = "12345;
$bd      = "miBase";
$conexion = mssql_connect($host, $usuario, $pass);
if (!$conexion) die ("Error al conectar a SQL server");
mssql_select_db($bd) or die ("Error al seleccionar la Base de datos");
echo "Conexion establecida con éxito";
?>

Guardamos nuestro archivo y lo probamos en nuestro navegador, si no hubiese problemas debe mostrarse el mensaje de Conexión establecida con éxito.