Agcapa

programador web

Autor: arturo (página 2 de 6)

Cómo encontrar y reemplazar texto en varios archivos desde el terminal

En el siguiente ejemplo, usaremos sed para reemplazar todas las ocurrencias de la palabra “mongo” por la palabra “aurelio” en todos los archivos que tengan la extensión .txt y que se encuentren en la carpeta /home/usuario/micarpeta/.

find /home/usuario/micarpeta/ -name *.txt -exec sed -i "s/mongo/aurelio/g" {} ;

o
sed -i 's/Pepe/Jose/g' *.txt

How To Install nginx on CentOS 6 with yum

EPEL stands for Extra Packages for Enterprise Linux. Because yum as a package manager does not include the latest version of nginx in its default repository, installing EPEL will make sure that nginx on CentOS stays up to date.

To install EPEL, open terminal and type in:

sudo yum install epel-release

Step Two—Install nginx

To install nginx, open terminal and type in:

sudo yum install nginx

After you answer yes to the prompt twice (the first time relates to importing the EPEL gpg-key), nginx will finish installing on your virtual private server.

Step Three—Start nginx

nginx does not start on its own. To get nginx running, type:

sudo /etc/init.d/nginx start

You can confirm that nginx has installed on your VPS by directing your browser to your IP address.

You can run the following command to reveal your server’s IP address.

ifconfig eth0 | grep inet | awk '{ print $2 }'


Configure nginx

Open up the nginx configuration.

sudo nano /etc/nginx/sites-available/example

The following configuration will set you up to use nginx as the front end server. It is very similar to the default set up, and the details are under the configuration.

server {
        listen   80; 

        root /var/www/; 
        index index.php index.html index.htm;

        server_name example.com; 

        location / {
        try_files $uri $uri/ /index.php;
        }

        location ~ \.php$ {
        
        proxy_set_header X-Real-IP  $remote_addr;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:8080;

         }

         location ~ /\.ht {
                deny all;
        }
}

The following changes were implemented in the configuration:

  • The root was set to the correct web directory
  • index.php was added on the index line
  • try_files attempts to serve whatever page the visitor requests. If nginx is unable, then the file is passed to the proxy
  • proxy_pass lets nginx the address of the proxied server
  • Finally the “location ~ /\.ht {” location block denies access to .htaccess files, if Apache’s document root concurs with nginx’s one

This configuration sets up a system where all extensions with a php ending are rerouted to the apache backend which will run on port 8080.

Activate the virtual host.

sudo ln -s /etc/nginx/sites-available/example /etc/nginx/sites-enabled/example

Additionally, delete the default nginx server block.

sudo rm /etc/nginx/sites-enabled/default

The next step is to install and configure apache.

Install Apache

With nginx taken care of, it’s time to install our backend, apache.

sudo apt-get install apache2

Since nginx is still not turned on, Apache will start running on port 80.

Configure Apache

We need to configure apache to take over the backend, which as we told nginx, will be running on port 8080. Open up the apache ports file to start setting apache on the correct port:

sudo nano /etc/apache2/ports.conf

Find and change the following lines to have apache running on port 8080, accessible only from the localhost:

NameVirtualHost 127.0.0.1:8080
Listen 127.0.0.1:8080

Save and Exit.

Subsequently, open up a new virtual host file, copying the layout from the default apache file:

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/example
sudo nano /etc/apache2/sites-available/example

The main issue that needs to be addressed here is that the virtual host needs to be, once again, running on port 8080 (instead of the default 80 given to nginx).

The line should look like this:

<VirtualHost 127.0.0.1:8080>

Make sure your Document Root is correct. Save and exit the file and activate that virtual host:

sudo a2ensite example

Before we start testing anything out, we need to equip apache with php. Go ahead and install it now:

 sudo apt-get install php5

Restart both servers to make the changes effective:

sudo service apache2 restart
sudo service nginx restart

Finish Up

We have set up the VPS with nginx running on the front end of our site and apache processing php on the back end. Loading our domain will take us to our site’s default page.

We can check that information is being routed to apache is working by running a common php script.

Go ahead and create the php.info file:

sudo nano /var/www/info.php

Paste the following lines into that file:

<?
phpinfo( );
?>

Save and exit.

Visiting your domain/info.php should show you php info screen, and you’ll be able to see that this was handled by apache. (screenshot here)

Finally, you can see which ports are open and which application is on each one by typing in this command.

sudo netstat -plunt

Cómo optimizar Apache para usar menos memoria RAM

ApacheBuddy, que es muy similar a MySQLTuner, revisa tu configuración de Apache, y te hace sugerencias basadas en la cantidad de memoria que consume cada proceso Apache de tu servidor y la memoria RAM total que tengas.

Aunque es un programa bastante básico, ya que se centra solo en la directiva “MaxClients”, ApacheBuddy es útil, y se puede instalar y ejecutar de manera sencilla en el servidor teniendo acceso root mediante SSH.

“MaxClients” indica el numero máximo de peticiones que se pueden servir al mismo tiempo por el servidor, cualquier número que vaya más allá del límite se pone en cola. Si es demasiado bajo, las conexiones enviadas a la cola pueden agotar el tiempo de espera; Si es demasiado alto puedes tener problemas de memoria y empezar a usar la memoria SWAP del servidor. En Linode.com tenéis una buena explicación de todos los parámetros.

Cómo instalar y usar Apachebuddy para optimizar Apache

1.-Descargamos ApacheBuddy:

wget https://raw.github.com/gusmaskowitz/apachebuddy.pl/master/apachebuddy.pl

2.-Le damos permisos de ejecución:

chmod +x apachebuddy.pl

y ejecutamos el script para que revise nuestra configuración de Apache:

./apachebuddy.pl

3.-Y lo que vamos a obtener es algo como esto:

apachebuddy

 

donde podemos ver unas cuantas cosas importantes:

  1. Cuanta memoria RAM usa cada proceso de Apache en nuestro servidor (máximo, mínimo y media): 28,13MB, 20,21MB, 26.45MB
  2. Cuanta memoria RAM puede usar potencialmente Apache (máxima y media): 529MB y 562.61MB de RAM (alrededor de un 20% de la memoria RAM total del servidor)

En el archivo /etc/httpd/conf/httpd.conf, que es donde se encuentra la configuración de Apache en CENTOS, podemos cambiar el parámetro MaxClients en función de la recomendación del programa. En este caso, al tener “20” y alcanzar solo el 21% de la memoria RAM total del sistema, ApacheBuddy ha considerado que el ajuste es correcto.

Un problema muy común de las configuraciones por defecto de Apache es que suelen dejar MaxClients=150, y eso no hay servidor con 2GB de RAM que lo soporte en un pico de visitas. Tened en cuenta que además de Apache, el servidor tiene que manejar MYSQL (digamos que usa el 50% o 60% de la memoria RAM del servidor) y tu panel de control (cPanel/WHM puede llevar a consumir 512MB mínimo -otro 20%- y Virtualmin unos 100MB), así que no podemos dejar que en un pico de visitas Apache use toda la memoria RAM. Sí dejas MaxClients en 150, cuando tengas muchas visitas el servidor no lo va a aguantar… mejor que esperen en la cola…

script para cuando la memoria esta saturada

se genera un fichero, ejemplo memoria.sh y se le da permisos de escritura 755, luego generamos el crond para que lo haga cada minuto y cuando lo revisa resetea el apache, bajando la memoria

#!/bin/sh

DATE=`date ‘+%d%m%Y_%H%M%S’`
CONSUMO=`ps aux |grep Apache |awk ‘{SUM+=$4}END {print SUM}’`
UMBRAL=80
FLAG=/tmp/control_memoria.lock
if [[ -f $FLAG ]];then
logger -p ERROR  “[Monitor de Memoria Apache] Hay Otro proceso de monitor ejecutandose”
exit 0
fi

touch $FLAG

if [[  $CONSUMO -gt $UMBRAL ]];then

logger -p ERROR  “[Monitor de Memoria Apache] el consumo es superior a ${UMBRAL}% $CONSUMO”
/etc/init.d/httpd stop 2>/dev/null  |logger
sleep 15
/etc/init.d/httpd start 2>/dev/null  |logger
else

logger -p INFO “[Monitor de Memoria Apache] el consumo es inferior al ${UMBRAL}% $CONSUMO”
if [[ $CONSUMO -eq 0 ]];then
logger -p INFO “[Monitor de Memoria Apache] El consumo es igual a 0”
/etc/init.d/httpd stop 2>/dev/null  |logger
sleep 15
/etc/init.d/httpd start 2>/dev/null  |logger
fi
fi

rm $FLAG

Cómo cambiar el password del usuario root de MySQL por terminal

service mysql stop

Esto detuvo el servicio, ahora vamos a iniciarlo pero de forma diferente, una forma que no nos pedirá password luego:

mysqld_safe --skip-grant-tables &

Listo, ahora accedamos a la terminal de MySQL:

mysql -u root

Verán que no les pidió password, verán que ya entraron a la consola o terminal de MySQL y pueden hacer lo que les plazca, procedamos a cambiar el password del root de MySQL.

Primero entraremos a la base de datos de MySQL como tal:

use mysql;

Luego, cambiemos el password:

update user set password=PASSWORD("ElNuevoPassword") where user='root';

Ahora refresquemos los privilegios:

flush privileges;

Y por último salimos:

quit;

Listo, ya cambiamos el password del usuario root de MySQL, ahora vamos a detener el servicio e iniciarlo como debe ser:

service mysql stop

service mysql start

Generar un CSR en SHA-1 o SHA-2

El certificado expedido depende del tipo de codificación asociada con la CSR.

De forma predeterminada, OpenSSL genera CSRs en SHA1, por lo que si usted desea conseguir un certificado SHA2, tendrás que añadir la opción -sha256 o -sha512 al comando openssl, tal como se describe a continuación.

Solicitud de certificado SHA-1

Para generar una CSR SHA-1 con OpenSSL, utilice el siguiente comando:

openssl req -nodes -newkey rsa:2048 -sha1 -keyout miservidor.key -out servidor.csr

Solicitud de certificado SHA-2

Para generar una CSR SHA2:

openssl req -nodes -newkey rsa:2048 -sha256 -keyout miservidor.key -out servidor.csr

Esta orden creará 2 ficheros: uno público de tipo .csr y uno privado de tipo .key, el cual convendrá mantener a buen recaudo.

Country Name (2 letter code) [AU]: ES
State or Province Name (full name) [Some-State]: .
Locality Name (eg, city) []: Barcelona
Organization Name (eg, company) [Internet Widgits Pty Ltd]: MiSociedad
Organizational Unit Name (eg, section) []: TIC
Common Name (eg, YOUR name) []: subdominio.dominio.tld
Email Address []:
A challenge password []: 
An optional company name []:

Los campos Email Address, optional company name y challenge password son facultativos.

subdominio.dominio.tld indica la dirección que quiere proteger.

La mejor manera de configurar su certificado para proteger el dominio con y sin las www (ej: ejemplo.com y www.ejemplo.com) es generar la CSR con sólo el dominio y no con el sub-dominio www. Al generar el CSR con sólo el dominio, el www está incluido implícitamente.

Se le solicitará el contenido del fichero CSR generado para la creación de su certificado.

Debe entrar en la ventana de administración de Gandi y ejecutar en su servidor:

cat miservidor.csr

copiar la salida del comando anterior, para después pegarla en la ventana de administración de Gandi.

En el caso de ser un certificado multi-direcciones (Wildcard), debe introducir en Common Name : *.dominio.tld
Atención: Un certificado multi-direcciones (Wildcard) protegerá todos los sub-dominios de segundo nivel, pero no será válido para los sub-dominios de nivel superior. El certificado SSL será válido para segundo.dominio.tld y cualquier otro sub-dominio distinto de ‘segundo’. Pero no será válido para tercero.segundo.dominio.tld

Cómo agregar una ruta estática a la tabla de enrutamiento

Cómo agregar una ruta estática a la tabla de enrutamiento

  1. Visualice el estado actual de la tabla de enrutamiento.

    Utilice su cuenta de usuario habitual para ejecutar el siguiente comando netstat:

    % netstat -rn
    

    Obtendrá un resultado similar al siguiente:

    Routing Table: IPv4
      Destination           Gateway           Flags  Ref   Use   Interface
    -------------------- -------------------- ----- ----- ------ ---------
    192.168.5.125        192.168.5.10          U      1   5879   ipge0
    224.0.0.0            198.168.5.10          U      1  0       ipge0
    default              192.168.5.10          UG     1  91908
    127.0.0.1            127.0.0.1             UH     1  811302   lo0
  2. Asuma el rol de administrador principal, o conviértase en superusuario.

    La función de administrador principal incluye el perfil de administrador principal. Para crear el rol y asignarlo a un usuario, consulte el Capítulo 2, Working With the Solaris Management Console (Tasks) de System Administration Guide: Basic Administration.

  3. (Opcional) Vacíe las entradas existentes en la tabla de enrutamiento.
    # route flush
    
  4. Agregue una ruta que persista tras el reinicio del sistema.
    # route -p add -net network-address -gateway gateway-address
    
    -p
    Crea una ruta que debe persistir tras el reinicio del sistema. Si desea que la ruta sea válida sólo para la sesión actual, no utilice la opción -p.

    add
    Indica que está a punto de agregar la siguiente ruta.

    -net dirección_red
    Especifica que la ruta se dirige a la red con la dirección de dirección_red.

    -gateway dirección_portal
    Indica que el sistema de portal para la ruta especificada tiene la dirección IP dirección_portal.


Ejemplo 5–5 Cómo agregar una ruta estática a la tabla de enrutamiento

El siguiente ejemplo muestra cómo agregar una ruta estática a un sistema. El sistema es el enrutador 2, el enrutador predeterminado para la red 172.20.1.0 que se muestra en la Figura 5–3. En el Ejemplo 5–4, el enrutador 2 está configurado para el enrutamiento dinámico. Para actuar como enrutador predeterminado para los hosts de la red 172.20.1.0, el enrutador 2 necesita además una ruta estática al enrutador de límite del SA, 10.0.5.150 .

Para ver la tabla de enrutamiento del enrutador 2, debe configurar lo siguiente:

# netstat -rn
Routing Table: IPv4
  Destination           Gateway           Flags  Ref   Use   Interface
-------------------- -------------------- ----- ----- ------ ---------
default              172.20.1.10          UG        1    249 ce0
224.0.0.0            172.20.1.10          U         1      0 ce0
10.0.5.0             10.0.5.20            U         1     78 bge0
127.0.0.1            127.0.0.1            UH        1     57 lo0

La tabla de enrutamiento indica las dos rutas que conoce el enrutador 2. La ruta predeterminada utiliza la interfaz 172.20.1.10 del enrutador 2 como portal. La segunda ruta, 10.0.5.0, fue descubierta por el daemon in.routed que se ejecuta en el enrutador 2. El portal de esta ruta es el enrutador 1, con la dirección IP 10.0.5.20.

Para agregar una segunda ruta a la red 10.0.5.0, que tiene su portal como enrutador de límite, debe configurar lo siguiente:

# route -p add -net 10.0.5.0/24 -gateway 10.0.5.150/24
add net 10.0.5.0: gateway 10.0.5.150

Ahora la tabla de enrutamiento cuenta con una ruta para el enrutador de límite, que tiene la dirección IP 10.0.5.150/24.

# netstat -rn
Routing Table: IPv4
  Destination           Gateway           Flags  Ref   Use   Interface
-------------------- -------------------- ----- ----- ------ ---------
default              172.20.1.10          UG        1    249 ce0
224.0.0.0            172.20.1.10          U         1      0 ce0
10.0.5.0             10.0.5.20            U         1     78 bge0
10.0.5.0             10.0.5.150           U         1    375 bge0
127.0.0.1            127.0.0.1            UH        1     57 lo0

MySQL: script Bash para crear un backup de todas las bases de datos

He creado un simple script Bash para hacer un backup de todas las bases de datos de un servidor MySQL en archivos diferentes. El script utiliza la herramienta mysqldump para volcar cada base de datos, en forma de código SQL, en archivos separados (un archivo para cada base). Una característica interesante, es que no requiere conocer a priori los nombres de las bases de datos, sino que los obtiene automáticamente con una consulta SQL. Para que el script funcione correctamente, sólo requiere un usuario con privilegio de lectura en todas las bases de datos (generalmente un usuario para backups).

A continuación dejo el script, junto con una explicación de su funcionamiento.

La ventaja de utilizar un archivo para cada base, es que al momento de restaurar es posible hacerlo de forma selectiva. Es decir, es posible recuperar sólo la/s base/s de datos que haga/n falta, a partir de su/s volcado/s (copias de seguridad).

#!/bin/bash

myuser=admin
mypass=1234

args=”-u”$myuser” -p”$mypass” –add-drop-database –add-locks –create-options –complete-insert –comments –disable-keys –dump-date –extended-insert –quick –routines –triggers”

mysql -u$myuser -p$mypass -e ‘show databases’ | grep -Ev “(Database|information_schema)” > databases.list

echo “Se volcarán las siguientes bases de datos:”
mysql -u$myuser -p$mypass -e ‘select table_schema “DATABASE”,convert(sum(data_length+index_length)/1048576, decimal(6,2)) “SIZE (MB)” from information_schema.tables where table_schema!=”information_schema” group by table_schema;’
CONT=1
while [ $CONT -eq 1 ]
do
echo -n “¿Desea continuar? (S/N): ”
read -n 1 K
[[ “$K” == “N” || “$K” == “n” ]] && { echo “”; exit 0; }
[[ “$K” == “S” || “$K” == “s” ]] && { CONT=0; }
echo “”
done

while read DB
do
dump=”dump_”$DB”.sql”
echo -n $dump”… ”
mysqldump ${args} $DB > $dump
echo “OK.”
done < databases.list

rm databases.list

Tanto para consultar los nombres de las bases de datos, como para hacer los volcados, hace falta un usuario (que tenga los privilegios necesarios, es decir, acceso de lectura en todas las bases) y su contraseña. Las variables myuser y mypass almacenan usuario y contraseña (MySQL).

La variable args almacena todas las opciones que se le pasarán a mysqldump durante el volcado de cada base de datos:

–add-drop-database: agrega la sentencia “DROP DATABASE” antes de cada sentencia “CREATE DATABASE”.
–add-locks: encierra cada volcado de tabla con un lock (resulta en inserts más rápidos al momento de restaurar).
–create-options: incluye todas las opciones específicas de MySQL en las sentencias “CREATE TABLE”.
–complete-insert: incluye los nombres de columnas en las sentencias “INSERT”.
–comments: incluye información útil como versiones de la aplicación y servidor, hostname, etc.
–disable-keys: crea los índices luego de insertar todas las filas (acelera el proceso de recuperación)
–dump-date: agrega la fecha de volcado.
–extended-insert: realiza insert de múltiples filas en una única sentencia.
–quick: útil para hacer dump de tablas grandes, recupera una fila por vez.
–routines: incluir en el dump las rutinas almacenadas (stored procedures y funciones).
–triggers: incluir triggers en el dump.

Luego de definir estas variables, obtiene los nombres de todas las bases de datos ejecutando la consulta show databases y los guarda en el archivo “databases.list”.

A continuación, obtiene nuevamente los nombres de todas las bases de datos, junto con el tamaño en disco que ocupa cada base, para que el administrador pueda decidir proceder o abortar el volcado porque considera que no hay espacio suficiente en la ubicación actual (los archivos de volcado se guardarán en el directorio actual, desde donde se ejecuta el script).

En el siguiente segmento de código, espera a que el usuario presione la tecla ‘S’ (para responder “Sí”) o ‘N’ (para responder “No”). Si el usuario presiona ‘N’, finaliza la ejecución del script. Si en cambio presiona ‘S’, procede con el volcado de cada base de datos.

En la última sección de código, realiza el dump de cada base de datos a partir de los nombres almacenados en el archivo “databases.list”. Ejecuta mysqldump utilizando los parámetros especificados en la variable args. Al finalizar el bucle, elimina el archivo “databases.list”.

Ya que el archivo almacena credenciales de usuario de MySQL en forma de texto plano (especialmente la contraseña), por seguridad debe ser protegido cuidadosamente. Sólo el administrador (root) debe tener permiso de lectura sobre el archivo:

root@debian7# chown root:root backup_all_databases.sh
root@debian7# chmod 500 backup_all_databases.sh

Ejemplo de ejecución del script:

root@debian7# ./backup_all_databases.sh
Se volcarán las siguientes bases de datos:
+———————————-+———–+
| DATABASE | SIZE (MB) |
+———————————-+———–+
| blog-linuxito_2012 | 1.59 |
| joomla27-2012 | 10.32 |
| joomla-bd-testing | 1.69 |
| joomla-db-desarrollo | 2.27 |
| managementdb | 0.41 |
| mysql | 0.66 |
| producciondb | 0.77 |
| producciondb2 | 0.27 |
| sitio-back-www-2012-10-05_full | 1137.63 |
| sitio-back-www-2012-10-06_diff | 0.06 |
| soft-2014 | 37.42 |
| test_2009 | 0.22 |
| test_pepito_www | 0.82 |
| test_joomla1.1 | 0.11 |
| test_joomla-6.5912 | 2.46 |
| www1 | 602.71 |
| www1logs | 0.23 |
| www-test | 0.06 |
+———————————-+———–+
¿Desea continuar? (S/N): s
dump_blog-linuxito_2012.sql… OK.
dump_joomla27-2012… OK.
dump_joomla-bd-testing… OK.
dump_joomla-db-desarrollo… OK.
dump_managementdb… OK.
dump_mysql… OK.
dump_producciondb… OK.
dump_producciondb2… OK.
dump_sitio-back-www-2012-10-05_full… OK.
dump_sitio-back-www-2012-10-06_diff… OK.
dump_soft-2014… OK.
dump_test_2009… OK.
dump_test_pepito_www… OK.
dump_test_joomla1.1… OK.
dump_test_joomla-6.5912… OK.
dump_www1… OK.
dump_www1logs… OK.
dump_www-test… OK.
root@debian7#

Listado de los archivos creados en el directorio actual:

root@debian7# ls -lh dump_*
-rw-r–r– 1 root root 1.2M Jun 26 10:26 dump_blog-linuxito_2012.sql
-rw-r–r– 1 root root 7.6M Jun 26 10:26 dump_joomla27-2012.sql
-rw-r–r– 1 root root 1.7M Jun 26 10:26 dump_joomla-bd-testing.sql
-rw-r–r– 1 root root 2.2M Jun 26 10:26 dump_joomla-db-desarrollo.sql
-rw-r–r– 1 root root 337K Jun 26 10:26 dump_managementdb.sql
-rw-r–r– 1 root root 521K Jun 26 10:26 dump_mysql.sql
-rw-r–r– 1 root root 587K Jun 26 10:26 dump_producciondb.sql
-rw-r–r– 1 root root 78K Jun 26 10:26 dump_producciondb2.sql
-rw-r–r– 1 root root 1.2G Jun 26 10:27 dump_sitio-back-www-2012-10-05_full.sql
-rw-r–r– 1 root root 26K Jun 26 10:27 dump_sitio-back-www-2012-10-06_diff.sql
-rw-r–r– 1 root root 26M Jun 26 10:27 dump_soft-2014.sql
-rw-r–r– 1 root root 78K Jun 26 10:27 dump_test_2009.sql
-rw-r–r– 1 root root 578K Jun 26 10:27 dump_test_pepito_www.sql
-rw-r–r– 1 root root 76K Jun 26 10:27 dump_test_joomla1.1.sql
-rw-r–r– 1 root root 2.2M Jun 26 10:27 dump_test_joomla-6.5912.sql
-rw-r–r– 1 root root 623M Jun 26 10:27 dump_www1.sql
-rw-r–r– 1 root root 39K Jun 26 10:27 dump_www1logs.sql
-rw-r–r– 1 root root 26K Jun 26 10:27 dump_www-test.sql

¡Espero que sea útil!

Comandos para visudo

Archivo /etc/sudoers

El archivo /etc/sudoers se edita con visudo, herramienta que a través de vi permite realizar cambios y verificar sintaxis y errores. Si se intenta modificar directamente /etc/sudoers, éste tendrá permisos de sólo lectura.

La sintaxis básica de una lista de control de acceso sería:

XXXX_Alias NOMBRELISTA = elemento1, elemento2, elemento3

La sintaxis básica de una regla de control de acceso sería:

[usuario, %grupo, NOMBRELISTA] [anfitrión] = (id de usuario a usar) programas

Se pueden definir Aliases y reglas. Los aliases permiten definir listas de programas, listas de usuarios, listas de anfitriones o bien listas de identidades de usuarios para ejecutar programas.

Cmnd_Alias.

Se utiliza para definir listas de programas a utilizar con sudo y/o excluir su ejecución con sudo. Ejemplo:

Cmnd_Alias PROGRAMAS4 = /sbin/service httpd reload, \
        /usr/bin/vim /etc/httpd/conf.d/variables.conf, \
        /usr/bin/vim /etc/php.ini

Lo anterior define una lista de programas que podrían utilizarse para hacer que el servicio httpd vuelva a leer su configuración, modificar los archivo /etc/httpd/conf.d/variables.conf y /etc/php.ini.

fulano ALL = PROGRAMAS4

Lo anterior define que el usuario fulano puede ejecutar los programas de la lista PROGRAMAS4 desde cualquier anfitrión.

También se pueden definir programas prohibidos junto con programas permitidos. Por ejemplo:

Cmnd_alias ALTACUENTAS = /usr/sbin/useradd, /usr/bin/passwd *, \
                            !/usr/bin/passwd root

fulano	ALL = (ALL) ALTACUENTAS

Lo anterior define que fulano puede ejecutar useradd con cualquier opción y argumentos y ejecutar passwd con cualquier argumento, pero tendrá prohibido ejecutar éste utilizando root como argumento, es decir tendrá prohibido cambiar la contraseña de root.

En el siguiente ejemplo, el usuario fulano podría utilizar virtualmente cualquier programa del sistema, excepto passwd con root como argumento y ejecutar bash, userdel, usermod y su.

Cmnd_alias PROHIBIDOS = !/bin/su, !/bin/bash, !/usr/sbin/usermod, \
    !/usr/sbin/userdel, !/usr/bin/passwd root

fulano	ALL = (ALL) ALL, PROHIBIDOS

User_Alias.

Se utiliza para definir listas de usuarios y/o grupos que podrán utilizar sudo y/o aquellos que tendrán prohibido utilizarlo. Ejemplo:

User_Alias WEBADMINS = fulano, mengano, zutano

Lo anterior define una lista denominada WEBADMINS, integrada por los usuarios fulano, mengano y zutano.

WEBADMINS ALL = /usr/bin/vim

La regla anterior define que los usuarios que conforman la lista WEBADMINS pueden ejecutar vim desde cualquier anfitrión.

También es posible definir grupos a los cuales pertenecen los usuarios del sistema. Ejemplo:

User_Alias ADMINS = %wheel, !pepe

Lo anterior define una lista denominada ADMINS, integrada por los usuarios que pertenezcan al grupo de sistema denominado wheel, excluyendo el usuario denominado pepe.

ADMINS ALL = /usr/bin/vim

La regla anterior define que los usuarios que conforman la lista ADMINS, es decir todos los miembros del grupo de sistena denominado wheel, excepto el usuario denominado pepe, pueden ejecutar vim desde cualquier anfitrión.

Host_Alias.

Se utiliza para definir listas de anfitriones desde los cuales se tendrá permitido utilizar sudo o bien desde los cuales se tendrá prohibido utilizarlo. Ejemplo:

Host_Alias WEBHOSTS = 192.168.70.25, \
            192.168.70.26, \
            192.168.70.23

Lo anterior define que la lista WEBHOSTS está integrada por las 3 direcciones IP listadas anteriormente. Si además se añade la siguiente regla:

WEBADMINS WEBHOSTS =  ADMINHTTPD

Lo anterior define que los usuarios de la lista WEBADMINS pueden utilizar los programas listados en ADMINHTTPD solamente si están conectados desde las direcciones IP listadas en WEBHOSTS.

Runas_Alias.

Se utiliza para definir listas de identidades permitias para utilizar sudo o bien aquellas que estarán prohibido utilizar. Ejemplo:

Si por ejemplo se quisiera que los usuarios de la lista WEBADMINS pudieran además ejecutar ls, rm, chmod, cp, mv, mkdir, touch y vim como el usuarios juan, pedro y hugo, se requiere definir una lista para estos programas y otra para los aliases de usuarios alternos y la regla correspondiente.

User_Alias WEBADMINS = fulano, mengano, zutano

Runas_Alias WEBUSERS1 = juan, pedro, hugo

Cmnd_Alias PROGRAMAS1 = /bin/ls, /bin/rm, /bin/chmod, \
        /bin/cp, /bin/mv, /bin/mkdir, /bin/touch, \
        /usr/bin/passwd [A-z]*, !/usr/bin/passwd root

WEBADMINS WEBHOSTS = (WEBUSERS1) PROGRAMAS3

Lo anterior permite a los usuarios definidos en WEBADMINS ( es decir fulano, mengano y zutano), utilizar los programas definidos en PROGRAMAS1 (es decir podrán utilizar ls, rm, chmod, cp, mv, mkdir, touch, vim y passwd, pero para el este último estará prohibido cambiar la contraseña de root), identificándose como los usuarios definidos en la lista WEBUSERS1 (juan, pedro y hugo), sólo si sudo se ejecuta desde los anfitriones con las direcciones IP listadas en WEBHOSTS (192.168.70.25, 192.168.70.26, 192.168.70.23).

Al momento de establecer las reglas, es posible especificar el permiso de ejecución de ciertos programas con uno o más usuarios y el de otros programas con otros usuarios distintos.

User_Alias WEBADMINS = fulano, mengano, zutano

Runas_Alias WEBUSERS1 = juan, pedro, hugo

Runas_Alias WEBUSERS2 = mario, beto, paco

Cmnd_Alias PROGRAMAS1 = /bin/ls, /bin/rm, /bin/chmod, \
        /bin/cp, /bin/mv, /bin/mkdir, /bin/touch, \
        /usr/bin/passwd [A-z]*, !/usr/bin/passwd root

Cmnd_Alias PROGRAMAS2 = /usr/bin/vim, /bin/cat, \
        /usr/bin/less

WEBADMINS WEBHOSTS = (WEBUSERS1) PROGRAMAS1 (WEBUSERS2) PROGRAMAS1

Lo anterior establece que los miembros de la lista WEBADMINS (fulano, mengano y zutano) pueden ejecutar desde lo anfitriones definidos en WEBHOSTS los programas definidos en la lista PROGRAMAS1, pero sólo adoptando las identidades de juan, pedro y hugo y los programas definidos en la lista PROGRAMAS2, pero sólo pueden ser ejecutados adoptando las identidades de mario, beto y paco.

Basado sobre el ejemplo anterior, estaría permitido ejecutar algo como lo siguiente:

sudo -u juan mkdir /home/juan/public_html/images

Pero estaría prohibido ejecutar lo siguiente, porque sólo se permite ejecutar /bin/cp con las identidades juan, pedro y hugo:

sudo -u mario cp -r /home/mario/public_html/images2/* \
    /home/mario/public_html/images2/

Candados de seguridad.

Algunos programas, como el caso de less, vi, vim y more, permiten ejecutar otros programas desde el intérprete de mandatos —lo que se conoce como Shell Escape o escape al intérprete de mandatos. En estos casos se puede utilizar NOEXEC para impedir que algunos programas permitan la ejecución de otros programas con privilegios. Ejemplo:

fulano ALL = (ALL) ALL \
    NOEXEC: /bin/vi, /usr/bin/less, /usr/bin/vim, /bin/more

Lo anterior permitiría al usuario fulano poder editar o visualizar con privilegios cualquier archivo del sistema ejecutando vim y more, pero deshabilita la posibilidad de poder ejecutar otros programas con privilegios desde el escape al intérprete de mandatos de vim.

Es importante señalar que sudo incluye varios candados de seguridad (predeterminados) que impiden se puedan realizar tareas peligrosas, como redirigir la salida estándar de la ejecución de un programa (STDOUT) hacia archivos fuera del directorio de inicio del usuario utilizado.

Si se define en el archivo /etc/sudoers que un usuario puede ejecutar con privilegios /usr/bin/vim, es decir algo como lo siguiente:

fulano ALL = (ALL) /bin/echo, \
    NOEXEC: /bin/vi, /usr/bin/vim, /bin/more, /usr/bin/less

Sudo permitirá que el usuario regular definido pueda ejecutar /usr/bin/vim de los siguientes modos:

sudo /usr/bin/vim
sudo vim

Pero se impedirá ejecutar vim del siguiente modo:

cd /usr/bin
sudo ./vim

Si, por ejemplo se define en el archivo /etc/sudoers que un usuario puede ejecutar con privilegios /bin/echo, es decir algo como lo siguiente:

fulano ALL = (ALL) /bin/echo, \
    NOEXEC: /bin/vi, /usr/bin/vim, /bin/more, /usr/bin/less

El usuario sólo podrá ejecutar echo de los siguientes modos, asumiendo que se trata del usuario fulano:

sudo /bin/echo "Hola" > /home/fulano/prueba.txt
sudo echo "Hola" > /home/fulano/prueba.txt

Sin embargo, sudo impedirá a los usuarios regulares redirigir la salida estándar hacia archivos fuera de sus propios directorios de inicio, como por ejemplo al ejecutar algo como lo siguiente:

sudo echo "Hola" > /etc/prueba.txt

Para poder realizar la operación anterior, se tendría que ejecutar:

sudo bash -c "echo 'Hola' > /etc/prueba.txt"

Para impedir lo anterior, habría que prohibir en el archivo /etc/sudoers el uso de /bin/bash, como se muestra en el siguiente ejemplo:

fulano ALL = (ALL) ALL, !/bin/su, !/bin/bash \
    !/usr/bin/sudo, !/usr/bin/visudo, \
    NOEXEC: /bin/vi, /usr/bin/vim, /bin/more, /usr/bin/less

Sudo permitirá realizar una tarea con privilegios sobre cualquier archivo dentro de cualquier directorio, aún si el usuario regular carece de permisos de acceso para ingresar a dicho directorio, siempre y cuando especifique la ruta exacta de dicho archivo. Ejemplo:

sudo chown named /var/named/dominio.zone

Sudo siempre impedirá ejecutar algo como lo siguiente cuando el usuario regular carece de permisos de acceso a un directorio o sub-directorio en particular:

sudo chown named /var/named/*.zone

Lo más recomendado.

Si se va a permitir la ejecución de todos los programas del sistema utilizando sudo, como mínimo prohíba el uso de /bin/bash, /bin/su, /usr/bin/sudo (para prevenir se pueda ejecutar «sudo sudo programa»), /usr/bin/passwd root y /usr/sbin/visudo y restrinja el uso de programas que permitan escape al intérprete de mandatos, como serían /usr/bin/less, /bin/more, /bin/vi y /usr/bin/vim. Ejemplo:

fulano ALL = (ALL) ALL, \
    !/bin/bash, !/bin/su, !/usr/sbin/visudo, !/usr/bin/passwd root, \
    !/usr/bin/sudo, \
    NOEXEC: /bin/more, /bin/vi, /usr/bin/less, /usr/bin/vim

De ser posible, evite definir ALL —todos los programas y aplicaciones del sistema— y sólo permita la ejecución de programas específicos. Puede definir todos los que quiera. Ejemplo:

fulano ALL = (ALL) /bin/cat, /bin/chgrp, /sbin/chkconfig, /bin/chmod, \
    /bin/chown, /sbin/depmod, /usr/sbin/edquota, /usr/sbin/groupadd, \
    /usr/bin/htpasswd, /sbin/ip, /usr/bin/openssl, /sbin/service, \
    /usr/bin/tail, /usr/sbin/useradd, /usr/bin/passwd [A-z]*, \
    !/usr/bin/passwd root, \
    NOEXEC: /bin/more, /bin/vi, /usr/bin/less, /usr/bin/vim

Evite utilizar nombres de usuario y, sobre todo, contraseñas predecibles o fáciles de adivinar.

Lo menos recomendado.

Si se quiere permitir a un usuario ejecutar con sudo prácticamente lo que sea, desde cualquier anfitrión, utilizando cualquier identidad de usuario del sistema y requiriendo ingresar la contraseña correspondiente al menos cada 5 minutos, se puede definir:

fulano ALL = (ALL) ALL

La configuración predeterminada en distribuciones basadas sobre Ubuntu™ Linux utiliza lo siguiente:

%wheel ALL = (ALL) ALL

Con lo anterior sólo los usuarios miembros del grupo wheel podrán hacer uso de sudo. Se recomienda cambiar esta configuración para hacerla un poco más restrictiva, como se muestra en los ejemplos citados algunos párrafos arriba.

Si se quiere permitir a un usuario ejecutar sudo lo lo que sea, desde cualquier anfitrión, utilizando cualquier identidad de usuario del sistema y sin necesidad de autenticar, se puede definir algo como lo siguiente:

fulano ALL = (ALL) NOPASSWD: ALL

Evite utilizar esta última configuración salvo que sea estrictamente necesario.

Uso de sudo.

Ejecute sudo con la opción -l (minúscula) como usuario regular para mostrar las opciones de variables de entorno permitidas y la lista de programas permitidos y prohibidos:

sudo -l

La salida puede ser algo similar a lo siguiente:

Matching Defaults entries for jbarrios on this host:
    requiretty, env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE 
    INPUTRC KDEDIR LS_COLORS", env_keep+="MAIL PS1 PS2 QTDIR USERNAME 
    LANG LC_ADDRESS LC_CTYPE", env_keep+="LC_COLLATE LC_IDENTIFICATION
    LC_MEASUREMENT LC_MESSAGES", env_keep+="LC_MONETARY LC_NAME
    LC_NUMERIC LC_PAPER LC_TELEPHONE", env_keep+="LC_TIME LC_ALL LANGUAGE
    LINGUAS _XKB_CHARSET XAUTHORITY",
    secure_path=/sbin:/bin:/usr/sbin:/usr/bin

User fulano may run the following commands on this host:
        (ALL) NOPASSWD: ALL, (ALL) !/sbin/fdisk, (ALL) NOEXEC: /usr/bin/vim,
    (ALL) /bin/more

Como root ejecute sudo con la opción -l (minúscula), la opción -U (mayúscula) y el nombre del usuario a consultar para listar los privilegios de un usuario en particular. Ejemplo:

sudo -l -U fulano

Ejecute sudo con la opción -L (mayúscula) para mostrar todas las opciones soportadas en el archivo /etc/sudores.

sudo -L

La salida —que será muy extensa— puede incluir algo similar a lo siguiente:

Available options in a sudoers ``Defaults'' line:

syslog: Syslog facility if syslog is being used for logging
syslog_goodpri: Syslog priority to use when user authenticates
successfully
syslog_badpri: Syslog priority to use when user authenticates
unsuccessfully
long_otp_prompt: Put OTP prompt on its own line
ignore_dot: Ignore '.' in $PATH
mail_always: Always send mail when sudo is run
...
pwfeedback: Provide visual feedback at the password prompt when there
is user input
fast_glob: Use faster globbing that is less accurate but does not
access the filesystem
umask_override: The umask specified in sudoers will override the
user's, even if it is more permissive
log_input: Log user's input for the command being run
log_output: Log the output of the command being run
compress_io: Compress I/O logs using zlib
use_pty: Always run commands in a pseudo-tty

Para ejecutar cualquier programa con sudo, se utiliza la siguiente sintaxis.

sudo -[opciones] programa

Ejemplo:

sudo service cups restart

Se asumirá que el usuario y grupo utilizados para la identidad serán root si se omite especificar opciones u otros argumentos.

Para especificar que una operación se ejecute como un usuario en particular, ejecute sudo con la opción -u (minúscula) seguida del nombre del usuario a utilizar y el nombre del programa correspondiente como argumento. Ejemplo:

sudo -u zutano vim /home/zutano/datos.txt

Ejecute sudo con la opción -g seguida del nombre del grupo a utilizar y el programa correspondiente como argumento para especificar que una operación se ejecute como un miembro de un grupo en particular. Ejemplo:

sudo -g lp lpadmin -x EPL-5900

Ejecute sudo con la opción -b y el programa correspondiente como argumento para especificar que una operación se realice en segundo plano. Ejemplo:

sudo -b tar cpf /var/respaldos/respaldo-etc.tar /etc

Una vez que el usuario se ha autenticado, el usuario podrá utilizar nuevamente sudo sin necesidad de volver a autenticarse durante 5 minutos —salvo que se especifique lo contrario en el archivo /etc/sudoers. Si un usuario regular ejecuta sudo con la opción -v, éste podrá refrescar el periodo de tiempo sin necesidad de tener que ejecutar de nuevo algo con sudo —en cuyo caso contrario expirará dicha autenticación y será necesario volver a realizar ésta.

sudo -v

Se forzará que expire el periodo de tiempo si se ejecuta sudo con la opción -k (minúscula), obligando a ingresar nuevamente la contraseña la siguiente vez que ejecute sudo.

sudo -k

Lo anterior también permite ejecutar un programa y expirar el periodo de tiempo —estableciendo la fecha de último uso a la fecha y hora actual— de manera simultánea. La ejecución de lo anterior puede requerir ingresar la contraseña del usuario regular si el tiempo ya ha expirado. Por lo general se utiliza de este modo en operaciones donde se desea condicionar a que sean realizadas siempre por un ser humano y jamás por un programa automatizado. Ejemplo:

sudo -k service cups restart

Si el usuario ejecuta sudo con la opción -K (mayúscula), se forzará que expire el periodo de tiempo por completo (elimina toda referencia de tiempo), obligando a ingresar nuevamente la contraseña la siguiente vez que se ejecute sudo. A diferencia de la opción -k (minúscula), ésta sólo permite ser utilizada sin otros argumentos.

sudo -K

Uso de aliases.

BASH (Bourne-Again Shell) permite utilizar variables de entorno y aliases al iniciar la sesión. Un administrador responsable por lo general preferirá evitar utilizar la cuenta de root y en su lugar hará uso de una cuenta de usuario regular para ejecutar diversos programas a través de sudo, los cuales se pueden simplificar a través de aliases. Por ejemplo, si se quiere definir que se ejecute sudo cada vez que se invoque a chkconfig, se puede crear un alias que ejecute sudo con /sbin/chkconfig, como en el siguiente ejemplo:

alias chkconfig="sudo /sbin/chkconfig"

Lo anterior permitirá ejecutar chkconfig utilizando sudo, sin necesidad de teclear «sudo» en el intérprete de mandatos.

CentOS, Fedora y Red Hat Enterprise Linux.

Puede crear diversos aliases que pueden ser de utilidad en el archivo ~/.bashrc del usuario regular utilizado, los cuales permitirán ejecutar automáticamente diversos programas con sudo. Ejemplos:

# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
	. /etc/bashrc
fi

# User specific aliases and functions

alias chgrp="sudo /bin/chgrp"
alias chkconfig="sudo /sbin/chkconfig"
alias chmod="sudo /bin/chmod"
alias chown="sudo /bin/chown"
alias depmod="sudo /sbin/depmod"
alias edquota="sudo /usr/sbin/edquota"
alias groupadd="sudo /usr/sbin/groupadd"
alias groupdel="sudo /usr/sbin/groupdel"
alias htpasswd="sudo /usr/bin/htpasswd"
alias ip="sudo /sbin/ip"
alias less="sudo /usr/bin/less"
alias openssl="sudo /usr/bin/openssl"
alias service="sudo /sbin/service"
alias system-config-firewall="sudo /usr/bin/system-config-firewall"
alias system-config-network-tui="sudo /usr/sbin/system-config-network-tui"
alias system-config-printer="sudo /usr/sbin/system-config-printer"
alias tail="sudo /usr/bin/tail"
alias useradd="sudo /usr/sbin/useradd"
alias userdel="sudo /usr/sbin/userdel"
alias vi="sudo /usr/bin/vim"
alias yum="sudo /usr/bin/yum"

Para que surtan efectos los cambios, hay que salir de la sesión y volver a ingresar con la misma cuenta de usuario en cuyo archivo ~/.bashrc se añadieron estos aliases.

En openSUSE™ y SUSE™ Linux Enterprise.

Puede crear diversos aliases que pueden ser de utilidad en el archivo ~/.aliases del usuario regular utilizado, los cuales permitirán utilizar automáticamente diversos programas con sudo. Ejemplos:

alias chgrp="sudo /bin/chgrp"
alias chkconfig="sudo /sbin/chkconfig"
alias chmod="sudo /bin/chmod"
alias chown="sudo /bin/chown"
alias depmod="sudo /sbin/depmod"
alias edquota="sudo /usr/sbin/edquota"
alias groupadd="sudo /usr/sbin/groupadd"
alias groupdel="sudo /usr/sbin/groupdel"
alias htpasswd="sudo /usr/bin/htpasswd"
alias insserv="sudo /sbin/insserv"
alias ip="sudo /sbin/ip"
alias less="sudo /usr/bin/less"
alias openssl="sudo /usr/bin/openssl"
alias service="sudo /sbin/service"
alias tail="sudo /usr/bin/tail"
alias useradd="sudo /usr/sbin/useradd"
alias userdel="sudo /usr/sbin/userdel"
alias vi="sudo /usr/bin/vim"
alias yast="sudo /usr/sbin/yast2"
alias zypper="sudo /usr/bin/zypper"

Para que surtan efectos los cambios, hay que salir de la sesión y volver a ingresar con la misma cuenta de usuario en cuyo archivo ~/.aliases se añadieron estos aliases.

Manejando MySQL desde la linea de comandos

Conectándose a la base de datos

Esta guía asume que ya tienes creada una base de datos, así como un usuario con los privilegios necesarios para hacer las operaciones que se requieren en la base de datos.

Los cuatro parámetros que necesitamos para establecer una conexión a la base de datos es el host donde reside la base de datos, el nombre de usuario, la contraseña y el nombre de la base de datos que vamos a manipular.

mysql -h [host] -D [base de datos] -u [usuario] -p

Esto te pedirá la contraseña, para que no sea guardada en el historial, por ejemplo:

mysql -h servidor.jveweb.net -D nombre_base_de_datos -u juan -p

Puedes especificar la contraseña en el comando agregando la contraseña junto a -p, no dejes un espacio entre -p y la contraseña para conectarte de esta manera, aunque no usar la contraseña en el comando es recomendable, por ejemplo:

mysql -h servidor.jveweb.net -D nombre_base_de_datos -u juan -punacontraseña

El parámetro -D para especificar la base de datos a usar desde que nos conectamos también es opcional, si no lo usas puedes ver una lista de las bases de datos disponibles usando show databases; y seleccionar la base de datos a usar con use [nombre base de datos]; en la linea de comandos de mysql, por ejemplo: use usuarios;

Si funcionó, obtendremos un resultado similar a este:

Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 6324623
Server version: 5.1.39-log MySQL Server

Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This software comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to modify and redistribute it under the GPL v2 license

Type 'help;' or '\h' for help. Type '\c' to clear the current input 
statement.

mysql>

Para terminar la sesión escribe quit. Si te estás conectando a una base de datos ubicada en un host externo, es recomendable el uso de SSL al conectarse a la base de datos, para hacer esto usa el parámetro --ssl

Enviando peticiones al shell de MySQL

Una vez que estamos en el shell de MySQL, podemos enviar peticiones de MySQL. Para ejecutarlas tenemos que terminarlas con un punto y coma (;), o con \g, por ejemplo:

show tables;

La petición no es ejecutada hasta que el punto y coma es encontrado, esto nos permite escribir peticiones de MySQL en lineas múltiples, por ejemplo:

show
tables
;

Si queremos presentar los resultados verticalmente, necesitamos terminar las peticiones con \G en vez de un punto y coma o \g

Usando el editor

En sistemas basados en Unix como Linux, el comando edit desde dentro del shell de mysql lanza el editor que está definido en la variable de entorno EDITOR. Cuando usamos el comando edit, si habíamos hecho una petición previamente, el editor será abierto con esta petición, esto es muy útil para hacer correcciones a la última petición, de otra manera solo obtendremos un editor vacío para escribir lo que necesitemos. Una vez que terminemos de editar la petición, guardamos, salimos del editor, y entonces usamos un punto y coma o \g para ejecutar la petición(es) que acabamos de escribir.

Para configurar la variable de entorno EDITOR, usamos export, en este ejemplo yo configuro vim ya que es mi editor preferido, pero puedes utilizar uno más fácil como nano. El editor por default es vi:

export EDITOR=vim

Para revisar el valor de la variable de entorno EDITOR, podemos utilizar:

echo $EDITOR

Procesando un archivo por lotes

Podemos ejecutar un archivo por lotes de peticiones MySQL utilizando:

mysql -u usuario -pcontraseña -h host -D nombre_base_de_datos < archivo_lotes.sql

O, si estamos dentro de el shell de mysql, podemos usar:

source archivo_lotes.sql

Peticiones MySQL para manipular tablas

Quien tenga el trabajo de crear scripts y programas que interactúan con MySQL seguramente está familiarizado con estas peticiones, pero ya que utilizo mi propio sitio web como referencia pondré aquí algunas peticiones comunes.

Listar tablas existentes en la base de datos

show tables;

Mostrar información de las tablas en la base de datos

show tables solo nos mostrará los nombres de las tablas en la base de datos, para ver toda la información sobre las tablas, usa:

show table status;

La información presentada sobre la tabla es:

  • Name – El nombre de la tabla
  • Engine – Mecanismo de la tabla (MyISAM, InnoDB, Memory, CVS, etc.)
  • Version – Número de versión del archivo .frm de la tabla
  • Row_format – El formato de almacenamiento de las filas (Dinámico, Redundante, etc.)
  • Rows – Número de filas en la tabla
  • Avg_row_length – Longitud promedio de las filas
  • Data_length – Longitud del archivo de datos
  • Max_data_length – La máxima longitud del archivo de datos
  • Index_length – La longitud del archivo índice
  • Data_free – Número de bytes asignados pero no usados
  • Auto_increment – El próximo valor de auto-incremento
  • Create_time – Cuando fue creada la tabla
  • Update_time – Cuando fue actualizado el archivo de datos por última vez
  • Check_time – Cuando fue revisada la tabla por última vez
  • Collation – El set de caracteres y la colación de la tabla
  • Checksum – El checksum vivo
  • Create_options – Opciones extras utilizadas cuando fue creada la tabla
  • Comment – El comentario de la tabla

Podemos especificar de que tabla queremos ver la información utilizando:

show table status like 'nombre_de_la_tabla';

Y podemos buscar en otro campo por cierto valor, por ejemplo, para mostrar todas las tablas que usan el mecanismo de almacenamiento MyISAM, podemos utilizar:

show table status where `Engine` like 'MyISAM';

Crear una nueva tabla

Este es un ejemplo del comando para crear una tabla, agregué muchos campos diferentes para la referencia de como declararlos.

create table `nombre_base_de_datos`.`tabla_de_prueba` (
`campo_id` int( 11 ) unsigned not null auto_increment comment 'clave primaria',
`campo_indice1` int( 11 ) unsigned not null comment 'un índice',
`campo_indice2` int( 11 ) unsigned not null comment 'un índice',
`campo_indice3` int( 11 ) unsigned not null comment 'un índice',
`campo_unico1` int( 11 ) unsigned not null comment 'un campo único',
`campo_unico2` int( 11 ) unsigned not null comment 'un campo único',
`campo_unico3` int( 11 ) unsigned not null comment 'un campo único',
`campo_varchar` varchar( 100 ) not null comment 'un campo varchar',
`campo_date` date not null comment 'un campo date',
`campo_datetime` datetime not null comment 'un campo datetime',
`campo_float` float not null comment 'un campo float',
`campo_longtext` longtext not null comment 'un campo longtext',
`campo_bool` bool not null comment 'un campo bool',
`campo_char` char( 1 ) not null comment 'un campo char',
`campo_tinyint` tinyint not null comment 'un campo tinyint',
primary key ( `campo_id` ) ,
index ( `campo_indice1` , `campo_indice2`, `campo_indice3` ) ,
unique ( `campo_unico1` , `campo_unico2`, `campo_unico3`)
) engine = myisam character set utf8 collate utf8_general_ci comment =
'comentarios de tabla';

Listar los campos en una tabla

show columns from `tabla_de_prueba`;

Cambiar el nombre de un campo en una tabla

alter table `tabla_de_prueba` change `campo_indice_1` `nuevo_nombre_campo` int(11) unsigned not null;

Agregar un campo a una tabla y hacerlo un índice

alter table `tabla_de_prueba` add `nuevo_campo_indice` int(11) unsigned not null, add index(`nuevo_campo_indice`);

Quitar un índice de una tabla

alter table `tabla_de_prueba` drop index `nuevo_campo_indice`;

Quitar un campo de una tabla

alter table `tabla_de_prueba` drop `nuevo_campo_indice`;

Agregar campos después de un campo especificado

alter table `tabla_de_prueba` add `a_borrar` varchar(12) not null after `campo_date`;

Agregar campos al comienzo de la tabla

alter table `tabla_de_prueba` add `a_borrar_2` varchar(12) not null first;

Agregar múltiples campos a la tabla

alter table `tabla_de_prueba` add `a_borrar_3` varchar(12) not null after `a_borrar`, add `a_borrar_4` varchar(12) not null after `a_borrar_3`;

Borrar campos en una tabla

alter table `tabla_de_prueba` drop `a_borrar`, drop `a_borrar_2`, drop `a_borrar_3`, drop `a_borrar_4`;

Renombrar una tabla

rename table `nombre_base_de_datos`.`nombre_original` to `nombre_base_de_datos`.`nuevo_nombre`;

Cambiar el comentario de una tabla

alter table `tabla_de_prueba` comment='Los comentarios';

Cambiar el valor de auto incremento de una tabla

alter table `tabla_de_prueba` auto_increment=3;

Reparar una tabla

repair table `tabla_de_prueba`;

Optimizar una tabla

optimize table `tabla_de_prueba`;

Borrar todos los registros en una tabla

truncate table `tabla_de_prueba`;

Borrar una tabla

drop table `tabla_de_prueba`;

Peticiones MySQL para manipular registros en una tabla

Voy a utilizar las siguientes dos tablas ficticias para los ejemplos que voy a estar utilizando referentes a la manipulación de registros.

Tabla de estados (estados)
estado_id estado_nombre
1 Jalisco
2 Guanajuato
3 Hidalgo
Tabla de ciudades (ciudades)
ciudad_id ciudad_nombre ciudad_poblacion estado_id
1 Guadalajara 1494134 1
2 Tequila 33155 1
3 Zapopan 1243538 1
4 Tonalá 408729 1
5 Tlaquepaque 563006 1
6 Guanajuato 171709 2
7 Celaya 468064 2
8 León 1436733 2
9 Pachuca 275578 3
10 Tizayuca 100562 3

Mostrar los registros de una tabla

select [campos] from `tabla_nombre` [where condiciones] [order by orden1 asc/desc,orden2 asc/desc] [limit inicio,limite];

select [x.campo,y.campo] from `tabla1` x, `tabla2` y where y.`id`=x.`indice` [condiciones extras] [order by x.campo,y.campo] [limit inicio,limite];

El número de combinaciones que podemos hacer con el comando select es enorme, así que trataré de cubrir algunos usos comunes en los siguientes ejemplos. Los campos que usamos siguiendo el select son los campos que serán mostrados, y el orden en que los especificamos es el orden en el que serán mostrados. Después de esto especificamos la tabla o tablas donde estamos buscando.

Definiendo el where podemos especificar múltiples condiciones separadas por espacios. Si estamos utilizando más de una tabla en la búsqueda, necesitamos hacer una comparación de igual entre los campos que ligan ambas tablas. Los últimos ejemplos son sobre hacer estas peticiones en más de una tabla.

Las condiciones pueden ser dadas con operadores de comparación, como =, <, >, <=, >=, <> or !=. La expresión LIKE nos permite hacer comparaciones simple de patrones, podemos utilizar % como carácter comodín. between ... and ... nos permite especificar un rango de valores. Y podemos especificar más de una condición utilizando los operadores lógicos AND o &&, OR o ||, NOT o !, o XOR.

Podemos ordenar el resultado utilizando order by y especificando el campo que queremos utilizar para ordenar, y si queremos que el orden sea ascendente (asc) o descendente (desc), podemos usar más de un campo para hacer el ordenamiento, en cuyo caso el primer campo será usado primariamente para el orden, y el segundo campo será usado cuando el primer campo tenga más de una instancia.

Y finalmente, el valor limit define desde que registro comenzaremos a mostrar, y cuantos registros serán mostrados.

Espero que en los próximos ejemplos esto se volverá mucho más claro, toma las dos tablas como referencia para ver los resultados de cada comando.

select * from `estados`;

+-----------+---------------+
| estado_id | estado_nombre |
+-----------+---------------+
|         1 | Jalisco       |
|         2 | Guanajuato    |
|         3 | Hidalgo       |
+-----------+---------------+
3 rows in set (5.14 sec)

select * from `ciudades` where `ciudad_id` = '3';

+-----------+---------------+------------------+-----------+
| ciudad_id | ciudad_nombre | ciudad_poblacion | estado_id |
+-----------+---------------+------------------+-----------+
|         3 | Zapopan       |          1243538 |         1 |
+-----------+---------------+------------------+-----------+
1 row in set (0.90 sec)

select `ciudad_nombre`,`ciudad_poblacion` from `ciudades` order by `ciudad_poblacion` asc;

+---------------+------------------+
| ciudad_nombre | ciudad_poblacion |
+---------------+------------------+
| Tequila       |            33155 |
| Tizayuca      |           100562 |
| Guanajuato    |           171709 |
| Pachuca       |           275578 |
| Tonalá        |           408729 |
| Celaya        |           468064 |
| Tlaquepaque   |           563006 |
| Zapopan       |          1243538 |
| León          |          1436733 |
| Guadalajara   |          1494134 |
+---------------+------------------+
10 rows in set (0.04 sec)

select `ciudad_nombre` from `ciudades` where `estado_id` = '2' order by `ciudad_nombre` desc;

+---------------+
| ciudad_nombre |
+---------------+
| León          |
| Guanajuato    |
| Celaya        |
+---------------+
3 rows in set (0.85 sec)

select * from `ciudades` limit 2,3;

+-----------+---------------+------------------+-----------+
| ciudad_id | ciudad_nombre | ciudad_poblacion | estado_id |
+-----------+---------------+------------------+-----------+
|         3 | Zapopan       |          1243538 |         1 |
|         4 | Tonalá        |           408729 |         1 |
|         5 | Tlaquepaque   |           563006 |         1 |
+-----------+---------------+------------------+-----------+
3 rows in set (0.06 sec)

select `ciudad_nombre` from `ciudades` where `ciudad_nombre` like 'G%';

+---------------+
| ciudad_nombre |
+---------------+
| Guadalajara   |
| Guanajuato    |
+---------------+
2 rows in set (0.04 sec)

select * from `ciudades` where `ciudad_poblacion` between '500000' and '1000000';

select * from `ciudades` where `ciudad_poblacion`>='500000' and `ciudad_poblacion`<='1000000';

+-----------+---------------+------------------+-----------+
| ciudad_id | ciudad_nombre | ciudad_poblacion | estado_id |
+-----------+---------------+------------------+-----------+
|         5 | Tlaquepaque   |           563006 |         1 |
+-----------+-------------+--------------------+-----------+
1 row in set (0.04 sec)

Nota: Mientras que ambas peticiones regresarían los mismos registros, utilizar between es más rápido que utilizar dos comparaciones, así que si estás lidiando con un rango de valores, siempre utiliza between.

select c.`ciudad_nombre`,s.`estado_nombre` from `estados` s, `ciudades` c where c.`estado_id`=s.`estado_id` order by c.`ciudad_nombre`;

+---------------+---------------+
| ciudad_nombre | estado_nombre |
+---------------+---------------+
| Celaya        | Guanajuato    |
| Guadalajara   | Jalisco       |
| Guanajuato    | Guanajuato    |
| León          | Guanajuato    |
| Pachuca       | Hidalgo       |
| Tequila       | Jalisco       |
| Tizayuca      | Hidalgo       |
| Tlaquepaque   | Jalisco       |
| Tonalá        | Jalisco       |
| Zapopan       | Jalisco       |
+---------------+---------------+
10 rows in set (0.06 sec)

select c.`ciudad_nombre`,s.`estado_nombre` from `estados` s, `ciudades` c where c.`estado_id`=s.`estado_id` and c.`ciudad_nombre` like 'G%';

+---------------+---------------+
| ciudad_nombre | estado_nombre |
+---------------+---------------+
| Guadalajara   | Jalisco       |
| Guanajuato    | Guanajuato    |
+---------------+---------------+
2 rows in set (0.05 sec)

select c.`ciudad_nombre`,s.`estado_nombre`,c.`ciudad_poblacion` from `estados` s,`ciudades` c where s.`estado_id`=c.`estado_id`;

+---------------+---------------+------------------+
| ciudad_nombre | estado_nombre | ciudad_poblacion |
+---------------+---------------+------------------+
| Guadalajara   | Jalisco       |          1494134 |
| Tequila       | Jalisco       |            33155 |
| Zapopan       | Jalisco       |          1243538 |
| Tonalá        | Jalisco       |           408729 |
| Tlaquepaque   | Jalisco       |           563006 |
| Guanajuato    | Guanajuato    |           171709 |
| Celaya        | Guanajuato    |           468064 |
| León          | Guanajuato    |          1436733 |
| Pachuca       | Hidalgo       |           275578 |
| Tizayuca      | Hidalgo       |           100562 |
+---------------+---------------+------------------+
10 rows in set (0.05 sec)

select c.`ciudad_nombre`,s.`estado_nombre`,c.`ciudad_poblacion` from `estados` s, `ciudades` c where s.`estado_id`=c.`estado_id` order by s.`estado_nombre` desc,c.`ciudad_poblacion` asc;

+---------------+---------------+------------------+
| ciudad_nombre | estado_nombre | ciudad_poblacion |
+---------------+---------------+------------------+
| Tequila       | Jalisco       |            33155 |
| Tonalá        | Jalisco       |           408729 |
| Tlaquepaque   | Jalisco       |           563006 |
| Zapopan       | Jalisco       |          1243538 |
| Guadalajara   | Jalisco       |          1494134 |
| Tizayuca      | Hidalgo       |           100562 |
| Pachuca       | Hidalgo       |           275578 |
| Guanajuato    | Guanajuato    |           171709 |
| Celaya        | Guanajuato    |           468064 |
| León          | Guanajuato    |          1436733 |
+---------------+---------------+------------------+
10 rows in set (0.15 sec)

Contar los registros de una tabla

select count(*) from `tabla_nombre` [where condiciones];

Las condiciones son opcionales, y pueden tener el mismo formato de las condiciones que utilizamos en peticiones select, esto simplemente nos devuelve el número de registros, por ejemplo:

select count(*) from `ciudades`;

+----------+
| count(*) |
+----------+
|       10 |
+----------+
1 row in set (0.06 sec)

Sumar los registros de una tabla

select sum(`ciudad_poblacion`) from `ciudades`;

+-------------------------+
| sum(`ciudad_poblacion`) |
+-------------------------+
|                 6453216 |
+-------------------------+
1 row in set (0.05 sec)

Insertar un registro

insert into `estados` (`estado_nombre`) values ( "Oaxaca");

insert into `ciudades` (`ciudad_nombre`,`ciudad_poblacion`,`estado_id`) values ('Oaxaca','258008',LAST_INSERT_ID());

En este caso agrego un nuevo estado, y una nueva ciudad, nota que en el campo estado_id estoy utilizando como valor la función LAST_INSERT_ID(), que me da el valor de la última ID que fue insertada. Si quisiera insertar más de un registro con esta ID, podemos usar la misma petición de insertar para la inserción de más de un campo. Voy a tomar la petición pasada e insertar en vez de eso tres registros:

insert into `estados` (`estado_nombre`) values( "Oaxaca");

insert into `ciudades` (`ciudad_nombre`,`ciudad_poblacion`,`estado_id`) values
('Oaxaca','258008',LAST_INSERT_ID()),
(`Salina Cruz`,`76219`,LAST_INSERT_ID()),
(`Zaragoza`,`85869`,LAST_INSERT_ID());

Otra función útil que utilizo para llenar un valor es la función NOW() en campos de tipo datetime, utilizo esto mucho para manejar el tiempo de creación o modificación de registros. Por ejemplo, asumiendo que tuviéramos un campo llamado tiempo_de_creacion, podríamos usar:

insert into `estados` (`estado_nombre`,`tiempo_de_creacion`) values ('Sonora', NOW());

Actualizar un registro

update `ciudades` set `ciudad_nombre`='Algún nombre',`ciudad_poblacion`='1000000' where `ciudad_id`='5';

Cuando estamos actualizando un registro, necesitamos especificar que registro es el que queremos actualizar, usualmente la llave primaria es utilizada para este propósito debido a que es un valor único. Por supuesto, podemos modificar muchos registros en la misma petición si más de un registro cumple con la condición. Por ejemplo digamos que todos los registros creados el 12 de Febrero de 2010 se volverán “activos” cambiando el valor de un campo llamado activo de ‘0’ a ‘1’, aquí está lo que haríamos:

update `cuentas` set `activo`='1' where `fecha_de_creacion` between '2010-02-12 00:00:00' and '2010-02-12 23:59:59';

Borrar un registro

delete from `estados` where `estado_id`='8';

La petición delete es más sencilla que una petición update pero algo similar, todos y cada uno de los registros que cumplan la condición(es) serán borrados. Se muy cuidadoso con esta petición, si estás apuntando a registros específicos, siempre usa la llave primaria para no golpear otro registro por accidente.

Peticiones MySQL preparadas

La razón por la que aprendí sobre peticiones preparadas fue debido a la seguridad que ofrecen cuando estoy utilizando PHP para realizar las peticiones a la base de datos en un sitio web. Sin embargo, el uso de peticiones preparadas desde la linea de comandos nos ofrece la habilidad de definir una petición una vez y entonces llamarla cuantas veces queramos, cambiando solamente el parámetro que usamos. Por ejemplo, para mostrar un registro de la tabla de ciudades, mostrando el nombre del estado en vez de estado_id, siempre tendría el mismo formato:

select c.`ciudad_nombre`,s.`estado_nombre` from `estados` s, `ciudades` c where c.`estado_id`=s.`estado_id` and c.`ciudad_id` = ?;

En el ejemplo, estamos utilizando el ? como un apartado para la ID de el registro que queremos mostrar de esta manera. Esto es útil también cuando estamos utilizando una petición como esta desde PHP y necesitamos usar un valor que recibimos de alguien más. Antes de la existencia de peticiones preparadas, necesitábamos filtrar muy cuidadosamente la entrada de un usuario para poder prevenir un ataque de inyección de sql que tiene el potencial de borrar nuestra base de datos o darle acceso a una persona no autorizada. Al separar la lógica de MySQL de los datos evitamos este problema, ya que MySQL no interpreta el parámetro, simplemente lo maneja como datos. Otra ventaja es que es más rápido utilizar peticiones preparadas de MySQL.

Hasta donde se, las peticiones preparadas solo funcionan con SELECT, INSERT, UPDATE, REPLACE, DELETE y CREATE TABLE. Veamos un ejemplo utilizando la petición previa. Primero que nada, creamos la petición preparada y la nombramos mostrar_ciudad:

prepare mostrar_ciudad from "select c.`ciudad_nombre`,s.`estado_nombre` from `estados` s, `ciudades` c where c.`estado_id`=s.`estado_id` and c.`ciudad_id` = ?";

Después preparamos el parámetro, llamado una_ciudad, en este caso:

set @una_ciudad = "2";

Y ejecutamos la petición preparada mostrar_ciudad usando el parámetro una_ciudad:

execute mostrar_ciudad using @una_ciudad;

+---------------+---------------+
| ciudad_nombre | estado_nombre |
+---------------+---------------+
| Tequila       | Jalisco       |
+---------------+---------------+
1 row in set (0.04 sec)

Notas al pie

Recuerda marcar como índice los campos que planeas usar frecuentemente para las búsquedas, esto hará más rápidas las peticiones a la base de datos.

Todos los ejemplos de uso, especialmente las peticiones preparadas al final, son en preparación para una serie de publicaciones sobre como utilizar MySQL desde PHP y python, ya que esos lenguajes son los que he estado utilizando más recientemente, y ash, pero esa es otra historia.

Antiguas entradas Recientes entradas

© 2018 Agcapa

Tema por Anders NorenArriba ↑

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.

ACEPTAR
Aviso de cookies