
Hoy en día, al instalar un sistema operativo en una nueva máquina, siempre hay un paso de la instalación en que nos pide la zona horaria en la que nos encontramos. Incluso la mayoría de sistemas operativos, si tienen una conexión a internet es posible que ya nos la sugieran de forma automática.

Sin embargo, el otro día me encontré con un servidor Linux que administro que no tenía la hora real. Estaba desincronizado!

Para volver a sincronizarlo hay que seguir unos sencillos pasos. Primero hay que instalar la utilidad NTP si aún no la tenemos instalada. En un Debian o Ubuntu podemos ejecutar desde la linea de comandos la instrucción:

```bash
sudo apt-get install ntp
```

Ahora procederemos a configurar esta herramienta. Con algun editor de texto (por ejemplo nano) abrimos el archivo de configuración:

```bash
sudo nano /etc/ntp.conf
```

En este documento hay muchas opciones de configuración, pero las que nos interesan son las del tipo:

```
server 0.ubuntu.pool.ntp.org
server 1.ubuntu.pool.ntp.org
server 2.ubuntu.pool.ntp.org
server 3.ubuntu.pool.ntp.org
```

Estas lineas corresponden a las urls de los servidores con los que queremos sincronizar la fecha y la hora. Puedes cambiarlas por servidores más cercanos al alojamiento de tu servidor. Por ejemplo si tienes hospedado la máquina en España, puedes ir a esta página [http://www.pool.ntp.org/zone/es](http://www.pool.ntp.org/zone/es), y reemplazar los servidores por defecto por estos:

```
server 1.es.pool.ntp.org
server 3.europe.pool.ntp.org
server 0.europe.pool.ntp.org
```

Para cualquier otra zona puedes buscar por continentes: [http://www.pool.ntp.org/es/](http://www.pool.ntp.org/es/).

Guardamos el archivo y salimos a la linea de comandos. Ahora reiniciamos el servicio para aplicar los cambios. En la linea de comandos escribimos:

```bash
/etc/init.d/ntp restart
```

Para comprobar que la fecha es la correcta ejecutamos el comando:

```bash
date
```


Cómo configurar la hora y fecha de nuestra máquina con la hora real de manera automática.

Cómo sincronizar la hora de Linux

como-sincronizar-la-hora-de-linux


## Instalar MongoDB

Primero descargar la base de datos desde la página oficial [www.mongodb.org/downloads](http://www.mongodb.org/downloads) manualmente. O bien usar el comando:

```bash
cd /tmp
wget http://downloads.mongodb.org/linux/mongodb-linux-x86_64-2.6.7.tgz
```

Luego extraer los archivos comprimidos

```bash
tar -zxvf mongodb-linux-x86_64-2.6.7.tgz
```

Creamos un directorio, por ejemplo en la carpeta /opt y copiamos los archivos descomprimidos:

```bash
sudo mkdir -p /opt/mongodb
sudo mv mongodb-linux-x86_64-2.6.7/\* /opt/mongodb/
```

Finalmente, exportaremos la ruta de los binarios en la variable PATH del sistema para que la base de datos sea accesible en la linea de comandos desde cualquier sitio. Esto lo haremos en el archivo .bashrc, situado en la carpeta del usuario. Lo abriremos con algun editor de texto, por ejemplo:

```bash
sudo nano ~/.bashrc
```

Y al final del archivo escribiremos:

```bash
export PATH=/opt/mongodb/bin:$PATH
```

Para que los cambios surtan efecto escribiremos:

```bash
source ~/.bashrc
```

Ahora hay que crear la carpeta física donde se guardaran los documentos de mongo. Por defecto los creamos en /data y le damos permisos de escritura:

```bash
sudo mkdir /data
sudo mkdir /data/db
sudo chmod uo+w /data/db
```

Finalmente, para usar la base de datos MongoDB, usaremos el comando

```bash
mongod --smallfiles
```

para iniciar la base de datos, y el comando

```bash
mongo
```

para iniciar una instancia de cliente desde donde poder hacer consultas NoSQL.


Instalación paso a paso de la base de datos MongoDB en entornos linux

Instalar MongoDB en Linux

instalar-mongodb-en-linux


Oracle instant client es un cliente que nos permite conectar nuestra aplicación web a la base de datos Oracle.

La instalación de este cliente es algo complicada ya que hay poca documentación y el sitio oficial de Oracle no lo pone muy fácil para instalarlo. En este artículo instalaremos Oracle instant client en Ubuntu.

En la página oficial de Oracle descargaremos el [cliente](http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html). Es necesario registrarse para poder descargarlo.

Seleccionamos el cliente que nos interesa, generalmente:

Instant Client for Linux x86

Aceptamos el acuerdo de licencia y seleccionamos **oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.rpm** y **oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.rpm**.

Podemos descargar también el SQL Developer, que es un programa de escritorio que se utiliza para hacer consultas y programar en PL/SQL en la base de datos Oracle, pero no lo necesitamos para conectar nuestra aplicación web a Oracle.

En Ubuntu/Debian los instalables suelen empaquetarse en archivos acabados en extensión .deb y los archivos descargados son .rpm, por lo que necesitaremos reconvertirlos. Para ello usaremos la aplicación alien, que si no la tenemos instalada podemos hacerlo con:

```bash
sudo apt-get install alien
```

Luego reconvertimos los archivos .rpm a .deb con:

```bash
alien oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.rpm
alien oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.rpm
```

y luego usaremos el comando dpkg para instalarlos:

```bash
dpkg -i oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.deb oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.deb
```

# Instalar extensión oci8 en PHP

Si deseamos instalar el driver en PHP para poder conectar con una base de datos Oracle, podemos usar PECL para que nos lo instale. Usaremos:

```bash
sudo apt-get install libaio1
sudo apt-get install pecl
sudo pecl install oci8
```

Finalmente añadimos la extensión a php.ini, normalmente el archivo está en /etc/php5/apache/php.ini, y podemos añadir la linea en cualquier parte del archivo:

```bash
extension=oci8.so
```

Si se ha instalado correctamente, con la instrucción phpinfo() de PHP deberíamos ver el módulo OCI8.


Instalar el cliente de Oracle para conectarse usando PHP en Ubuntu

Oracle Instant Client en Ubuntu

oracle-instant-client-en-ubuntu


En linux existe una herramienta para rotar los logs del sistema, de modo que no se generen archivos de tamaño desorbitado y nos llene todo el espacio del disco.

La herramienta se llama **logrotate** y es muy sencilla de utilizar. La configuración general de logrotate se puede encontrar en /etc/logrotate.conf

Para configurar logrotate para unos logs en concreto, podemos crear un archivo en /etc/logrotate.d/

Podemos crear un archivo en esa carpeta para definir los logs que rotarán. Pueden haber varios definiciones en un mismo archivo. Un ejemplo de rotación podría ser:

```
/var/www/vhosts/miweb.com/log/production.log {
daily
missingok
rotate 30
compress
delaycompress
sharedscripts
postrotate
touch /var/www/vhosts/miweb.com/tmp/restart.txt
endscript
}
```

En nuestro ejemplo tras hacer la rotación se ejecuta el reinicio de una aplicación en Ruby on Rails en la etiqueta "postrotate", pero en otros casos puede cambiar según lo que se quiera, por ejemplo en un servidor apache se podría recargar la configuración del servidor con

```
postrotate
/etc/init.d/apache2 reload
endscript
```

O simplemente no hacer nada.

## Testear la configuración de logrotate

logrotate permite debuguear los scripts de configuración para ver si funcionan como esperamos, podemos ejecutar el comando con el parámetro -d

```bash
logrotate -d /etc/logrotate.d/nombredelarchivodeconfiguracion
```


Rotación automática de logs en linux con la aplicación logrotate

Rotar logs

rotar-logs


Buscar archivos desde la consola de Linux es una tarea complicada si eres nuevo en sistemas Linux.

Para buscar archivos el comando más común es el comando **find**. Este comando es muy potente y permite una infinidad de opciones para buscar tipos de archivos en todo el sistema. Veamos algunos ejemplos de cómo funciona.

## Buscar archivos y mostrar sus nombres

Para buscar todos los archivos dentro de un directorio con extensión .txt

```bash
find /home/miusuario -name "\*.txt"
```

Para encontar un archivo en todo el sistema, podemos buscarlo desde la carpeta raiz /

```bash
find / -name nombre_de_archivo
```

## Buscar archivos por nombre de usuario

Si deseamos buscar un archivo por nombre de usuario podemos escribir:

```bash
find / -user nombreusuario
```

Esto mostrará todos los archivos de ese usuario a partir de la carpeta raiz / y todas sus subcarpetas.

## Buscar archivos por tamaño de fichero

Para buscar archivos vacíos (el . indica el directorio en el que nos encontramos):

```bash
find . -size 0c
```

Para buscar archivos de un tamaño en kilobytes:

```bash
find . -size 54k
```

## Buscar por expresiones regulares

El comando find permite buscar utilizando expresiones regulares. Esto nos ofrece una potencia considerable. Por ejemplo si deseamos buscar archivos del tipo archivo01_01.txt, archivo02_03.txt, etc, podemos utilizar:

```bash
find . -regex './archivo0[1-2]_0[1-3].\*'
```

Además podemos anidar todas las opciones para hacer consultas más complejas.

## Buscando archivos con el comando Locate

También existe otra forma de buscar archivos en el índice del sistema, el comando locate.

Este comando funciona de la siguiente forma:

```bash
locate nombredelarchivo
```

Y devolverá todas las rutas en donde aparece el nombre entrado, podemos consultar dentro de los resultados devueltos por ejemplo:

```bash
locate miarchivo | grep bin
```

Devolverá todos las rutas del sistema que contengan el nombre miarchivo y que además también aparezca el texto bin.

Para actualizar el índice del sistema podemos utilizar el comando updatedb

```bash
sudo updatedb
```

Es recomendable ejecutarlo antes de hacer un locate para añadir las rutas recientes, por ejemplo si acabamos de instalar un programa.


Buscar archivos desde la linea de comandos en Linux

Buscar archivos en Linux

buscar-archivos-en-linux


Rsync es una aplicación muy potente para linux que nos permite sincronizar archivos y directorios. Normalmente se utiliza para realizar backups de un sitio remoto a otro.

Lo que hace realmente útil esta herramienta es que permite transferir sólo los bytes que han cambiado de los archivos, de modo que si se quiere hacer una copia de seguridad de un gran volumen de datos, a largo plazo minimizaremos el tamaño de información a copiar y transferir.

## Sincronizar archivos de un sitio remoto a nuestro PC

Rsync permite varias opciones que podemos ver usando el comando man de linux "man rsync", pero la más importante es la siguiente instrucción, que copia los contenidos del sitio remoto example.com a nuestro directorio local tmp.

```bash
rsync -avz --delete miusuario@example.com:/var/www/sitio/ /root/tmp
```

**\* Atención**: La opción delete elimina los archivos del directorio tmp que ya no existen en el sitio remoto.


Sincronizar archivos y directorios con Rsync

Rsync

rsync


Para comprimir archivos en linux desde la línea de comandos hay distintas herramientas de código libre como **gzip** o **zip**. Comprimir archivos es muy útil para que estos ocupen menos espacio y se puedan transferir a mayor velocidad.

En este tutorial veremos cómo comprimir y descomprimir con el comando gzip

## Comprimir con gzip, descomprimir con gunzip

Los archivos gzip suelen llevar por extensión las letras .gz, esto es sólo una convención. Ejemplo de compresión:

```bash
gzip archivo
```

Este comando generará un archivo llamado archivo.gz que incluirá el contenido del fichero comprimido

Para descomprimir usaremos el comando gunzip:

```bash
gunzip archivo.gz
```

Para comprimir varios archivos al mismo tiempo:

```bash
gzip archivo.gz fichero1 fichero2 fichero3 /directorio
```

Este ejemplo comprimirá todos los ficheros y el directorio.

## Contenedor de ficheros con tar

**tar** es otro comando que permite juntar varios directorios y archivos en uno solo. Por ejemplo:

```bash
tar -cvf archivo.tar /directorio
```

La instrucción anterior empaquetará todo el contenido de directorio y lo archivará en el fichero archivo.tar

Para extraer los contenidos de un archivo tar:

```bash
tar -xvf archivo.tar
```

Este comando no comprime el archivador por defecto, pero podemos usar el parámetro c (compress) para que sí lo haga (se creará el archivo archivo.tgz):

```bash
tar -czvf archivo.tar
```

Finalmente, podemos descomprimir el archivador usando el parámetro x (extract):

```bash
tar -xzvf archivo.tgz
```


Cómo empaquetar archivos con tar y comprimirlos con gzip usando comandos de linux

Comprimir con tar y gzip

comprimir-con-tar-y-gzip


Hay varios métodos para añadir variables de entorno en linux. Normalmente existen diferentes scripts que se ejecutan en diferentes eventos, por ejemplo, cuando un usuario se loguea en el sistema se ejecuta un archivo llamado **.bashrc**. Este es un archivo de sistema que se encuentra en la carpeta del usuario /home/usuario/.bashrc

Este script es un buen lugar para añadir la variable de entorno. Aunque también existen otros siios.

En este ejemplo veremos cómo añadir una ruta a la variable de entorno PATH, que es una variable común para asignar rutas de aplicaciones y comandos que se instalan en el sistema.

Podemos usar cualquier editor para modificar los datos, por ejemplo

```bash
vim /home/nombreusuario/.bashrc
```

Para evitar sobreescribir esta variable (es posible que se haya definido en otro sitio), podemos hacerlo de añadiendo esta línea al final del archivo

```
export PATH=$PATH:/directorio1:/directorio2:...:/directorioN
```

Para que los cambios surtan efecto podemos reiniciar sesión con ese usuario al que le hemos editado el archivo o bien podemos usar el comando de linux **source**

```bash
source /home/nombreusuario/.bashrc
```

Para probar que se ha guardado correctamente podemos escribir:

```bash
$PATH
```

En la línea de comandos


Cómo y dónde configurar las variables de entorno en Linux

Configurar variables de entorno en Linux

configurar-variables-de-entorno-en-linux


Django es un framework para crear aplicaciones web en el lenguaje de programación Python.

En este tutorial instalaremos Django en linux y crearemos una aplicación.

## Instalar Django

Para instalar Django para un entorno de desarrollo no necesitaremos un servidor como Apache ya que el mismo framework trae un servidor web de poco peso para probar las aplicaciones y hacer experimentos. Es una práctica común en este tipo de frameworks.

Para descargar la última versión del framework podemos ir a la página oficial de Django ([http://www.djangoproject.com/download/](http://www.djangoproject.com/download/))

Podemos usar este código para descargar y descomprimir el archivo:

```bash
wget http://www.djangoproject.com/download/1.2.1/tarball/
cd Django-1.2.1
sudo python setup.py install
```

Una vez instalado Django ya podemos crear aplicaciones.

## Crear una aplicación

Para crear una aplicación Django, podemos ejecutar este comando en la ruta dónde queramos guardar el código:

```bash
django-admin.py startproject NOMBREAPLICACION
```

Se creará una carpeta con una estructura de directorios y scripts que ya son parte de nuestra aplicación web.

Para iniciar el servidor entramos dentro del proyecto creado ejecutando este código:

```bash
cd NOMBREAPLICACION
python manage.py runserver
```

Si todo ha ido bien veremos que el servidor se ha iniciado, ahora podemos ir al navegador y digirnos a la url **http://localhost:8000** para ver la página de bienvenida a nuestro proyecto.


Instalación del Framework Django para crear aplicaciones web en Python

Instalar Django en Linux

instalar-django-en-linux


En este tutorial mostraremos como con unos pocos pasos podemos reemplazar una versión antigua de Java en CentOs por la que nos interese.

En realidad esto puede servir para reemplazar cualquier aplicación o comando porque lo que se trata es de modificar, usando el comando **alternatives** de linux, la aplicación que se ejecuta al llamar a ese comando. Veamos detalladamente este ejemplo donde reemplazaremos la aplicación que se ejecuta al usar el comando java:

Primero podemos usar el comando

```bash
java -version
```

que sirve para conocer cúal es la última versión de java instalada de nuestro servidor antes de hacer ningun cambio.

Ahora descargaremos la última versión de Java de la [página oficial](http://java.sun.com/javase/downloads/index.jsp). Tenéis que cambiar la url de este ejemplo por la verdadera.

```bash
curl -L -O http://....jdk-6u18-linux-i586.bin
```

Se descargará el archivo empaquetado bin. Podemos cambiarle los permisos de ejecución y ejecutarlo:

```bash
chmod +x jdk-6u18-linux-i586.bin
./jdk-6u18-linux-i586.bin
```

Tras ejecutar el comando anterior, el programa se desempaqueta en la misma carpeta. Podemos moverlo donde nos plazca, un buen sitio puede ser

```bash
mv jdkxxx /usr/local
```

Ahora viene lo interesante:

```bash
alternatives --install /usr/bin/java java /usr/jdkxxx/java 2
```

Lo que hace este comando es agregar una alternativa para este comando. Finalmente llamamos otra vez a este comando para asignar el comando java a la ruta de la nueva instalación.

```bash
alternatives --config java
```

y podemos seleccionar el comando que queremos ejecutar.

Efectivamente, este método sólo modifica el comando java, de forma que el resto de comandos (javac, etc) deberíamos reemplazarlos manualmente de la misma forma.

En general es un buen recurso para reemplazar comandos si creemos que alguna vez deberemos necesitar el antiguo, puesto que en otros casos quizá nos interese desinstalar la aplicación anterior e instalar la nueva versión.


Cómo usar una versión actualizada de Java sin desinstalar la antigua en CentOS server

Upgrade de Java en CentOS

upgrade-de-java-en-centos


Memcached es una libreria que sirve para guardar en memoria objetos de la base de datos agilizando y reduciendo el número de peticiones que se realizan.

## Instalar Dependencias

Memcached necesita de esta librería que podemos descargar en monkey.org, es posible que haya versiones más actuales. Pero con la 1.3 ya vamos bien.

```bash
wget http://monkey.org/~provos/libevent-1.3e.tar.gz
tar zxpfv libevent-1.3e.tar.gz
cd libevent-1.3e
./configure
make install
```

## Instalar Memcached

```bash
wget http://memcached.googlecode.com/files/memcached-1.2.8.tar.gz
tar zxpfv memcached-1.2.8.tar.gz
cd memcached-1.2.8
./configure
make install
```

Crear el usuario con el que se ejecutará el daemon memcached llamado con el mismo nombre.

```bash
adduser memcached
```

Para acceder a memcached desde cualquier sitio y poder ejecutar luego el daemon.

```bash
ln -s /usr/local/lib/libevent-1.3e.so.1 /lib/
```

Por ejemplo para arrancar una instancia del daemon: En este ejemplo asignamos 50 MB de memoria ram, desde el ip localhost y con el puerto recomendado 11211.

```bash
memcached -u memcached -d -m 50 -l 127.0.0.1 -p 11211
```

Para ver que funciona podemos abrir otra consola y ejecutar un telnet en el puerto 11211.

```bash
telnet 127.0.0.1 11211
```

Por supuesto también podemos ver que se está ejecutando en el sistema.

```bash
ps aux | grep memcached
```

Ahora memcached ya funciona correctamente por si solo. A continuación veremos cómo configurarlo para que funcione en PHP y luego como hacer que se ejecute siempre al arrancar el servidor.

## Instalar la extensión memcache en PHP

No confundir con la extensión memcached que también está en [http://pecl.php.net](http://pecl.php.net). Al momento de escribir esta guía la versión estable era la 2.2.5.

```bash
wget http://pecl.php.net/get/memcache
tar zxvf memcache-2.2.5.tgz

cd memcache-2.2.5

./configure
make
make install
```

En el archivo php.ini debemos habilitar la extension añadiendo la siguiente línea en el apartado de extensiones.

```
extension=memcache.so
```

Luego reiniciamos el servidor Apache

```bash
/etc/init.d/httpd restart
```

Ya podemos ver en el php.ini que aparece la extensión instalada.

## Arrancar memcached cuando inicie el sistema

Hay que crear un script de inicialización en la carpeta /etc/init.d llamado por ejemplo memcached. Este script lo configuraremos para poder configurarlo con el **chkconfig**. Dentro escribimos:

#!/bin/bash

#

# memcached Script de inicio para Memcached

#

# chkconfig: 235 95 16

# description: memcached

# processname: memcached

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr:bin
memcached -u memcached -d -m 50 -p 11211

Ahora cambiamos los permisos de este archivo para que sea ejecutable.

```bash
chmod 755 memcached
```

Finalmente lo agregamos a la lista de servicios de chkconfig:

```bash
chkconfig --add memcached
chkconfig --list memcached
```

Y ya podemos reiniciar el servidor. Cuando haya reiniciado veremos, utilizando el comando siguiente:

```bash
ps aux | grep memcached
```

que ya se ejecuta por si sola una instancia del demonio.


Instalar Memcached

instalar-memcached


## Descargar CentOS 5.3 Server

Se puede descargar el servidor [CentOS](http://isoredirect.centos.org/centos/5/isos/i386/) en esta url. Algunos mirrors ofrecen la versión completa en DVD "CentOS-5.3-i386-bin-DVD.iso", sino también se pueden descargar los 6 cds (de CentOS-5.3-i386-bin-1of6.iso hasta CentOS-5.3-i386-bin-6of6.iso)

## Configuración de la Instalación de CentOS 5.3 Server

Arrancamos el sistema con el CD 1, o con el DVD y nos aparece la pantalla principal de CentOS. Para instalar pulsamos enter.

A continuación nos pregunta si deseamos testear los CDS, pero podemos pulsar Skip.

Llegamos a la pantalla de instalación de CentOs. Pulsamos Next. Selecionamos el idioma, y después el idioma del teclado.

Ahora nos pide si deseamos borrar la información del disco que estamos instalando. Como es una instalación de 0 pulsamos que si (atención:se borrarán todos los datos si había).

Seguidamente hay que particionar el sistema. Seleccionamos "Suprimir particiones de Linux en dispositivos seleccionados y crear diseño predeterminado". Si nos interesa cambiar las particiones ahora es el momento, pero por las que nos dan por defecto ya van bien. Al pulsar Siguiente nos pide confirmación y seleccionamos si.

En las opciones de configuración de la red usaremos IP's estáticas. Para ello hay que pulsar el botón Modificar en Network Devices y seleccionar dentro de Enable IPv4 support, manual configuration. Dentro de este campo IP Adress ponemos por ejemplo **192.168.0.100** y como máscara de red **255.255.255.0**. Podemos desactivar la opción Enable IPv6 support.

Como nombre de host ponemos un nombre del tipo: **servidor.dominio.com**. Como Gateway 192.168.0.1, como Primary y Secondary DNS por el momento usaremos el mismo ip que el servidor 192.168.0.100

Tras pulsar siguiente, seleccionamos la zona horaria correspondiente y después nos pedirá la root password.

Ahora hay que decirle que aplicaciones queremos que instale. Como en un servidor necesitamos los máximos recursos de memoria y disco disponibles sólo instalaremos lo esencial. No instalaremos ni siquiera entorno de escritorio. Por lo tanto deseleccionamos Desktop - Gnome y pulsamos solamente en la opción de Server. También marcamos la casilla "personalizar ahora" y le damos a siguiente.

Dentro de **Aplicaciones** seleccionamos editores, Internet basada en texto. Dentro de **Desarrollo** Bibliotecas de Desarrollo, Herramientas de Desarrollo. Dentro de **Servidores** seleccionamos Servidor de Nombres DNS, servidor FTP, Servidor de Correo, Base de datos MySQL, Herramientas de Configuración del Servidor, Servidor Web. Dentro de **Sistema Base** seleccionamos Base, Herramientas de Administración y Herramientas del Sistema.

Tras unos segundos de espera en la que el instalador busque dependencias de los programas que instalaremos, pulsamos siguiente y empieza la instalación.

Para finalizar pulsamos reiniciar y quitamos el CD o DVD.


Guía paso a paso para instalar el servidor linux CentOS 5.3

Instalar CentOS 5.3 Server

instalar-centos-5-3-server


En linux existen un par de comandos para dar de alta un usuario: useradd y adduser. En este artículo mostraremos que es lo que hacen. Crearemos un usuario manualmente.

## Crear el usuario

Para crear un usuario se debe modificar el archivo /etc/passwd. Podemos hacerlo de forma segura utilizando el comando de linux vipw (sirve para bloquear el archivo mientras lo estés modificando de forma que nadie más pueda editarlo).

```bash
vipw /etc/passwd
```

En este archivo se guardan los usuarios del sistema. Para añadir otro, se crea una nueva línea con esta información:

nombreusuario:*:1000:1000:Nombre,,,:/home/nombreusuario:/bin/bash

nombreusuario - Es el nombre con el que el usuario podrá loguearse  
\* - Sirve para que la cuenta esté deshabilitada, normalmente este campo contendrá una x que significa que tiene una contraseña asignada en el archivo /etc/shadow  
1000 - es el id del usuario (User Id). Es un identificador único que no puede estar repetido.  
1000 - es el id del grupo de ese usuario. En linux cada usuario tiene un grupo con el mismo nombre que crearemos luego.  
Nombre,,, - Son campos de información del usuario como el Nombre, Apellidos, etc separados por coma.  
/home/nombreusuario - es la carpeta que le corresponde al usuario.  
/bin/bash - es la shell o aplicación que se ejecutará cuando el usuario se loguee. Por ejemplo, otra forma para que un usuario no pudiera acceder al sistema sería poniendo aquí un programa que no se lo permitiera.

## Crear el grupo

En linux cada usuario tiene un grupo con el mismo nombre, ahora crearemos este grupo utilizando el comando vigrp de linux, para bloquear el archivo /etc/groups mientras lo editamos:

```bash
vipw /etc/passwd
```

Hay que añadir el nuevo grupo asegurando que es el mismo nombre que el usuario, y el GID (Id de Grupo) que hemos puesto al crear el usuario

```
nombreusuario:x:1000:
```

A los grupos también se les puede asignar passwords, pero en este caso no será necesario y ponemos una x.

## Crear directorio home

Ahora hay que crear el directorio de inicio y carpeta personal del usuario

```bash
mkdir /home/nombreusuario
```

## Copiar esqueleto

A continuación copiaremos los archivos por defecto que tendrá el usuario en su directorio home. Estos archivos suelen estar en /etc/skel. Hay que copiar también los subdirectorios, por eso utilizamos el atributo -r (recursivo)

```bash
cp -r /etc/skel/* /home/nombreusuario
```

## Cambiar de propietario

Como hemos creado las carpetas con un usuario con privilegios de administrador, ahora hace falta cambiar los propietarios de estos directorios ara que el usuario los pueda usar. Recordamos que nombreusuario=nombregrupo.

```bash
cd /home/nombreusuario
chown -R nombreusuario.nombregrupo .
chmod -R go=u,go-w .
chmod go= .
```

## Asignarle una password

```bash
passwd nombreusuario
```

Finalmente, ejecutando este comando nos pedirá una password para este usuario que se guardará debidamente encriptada en /etc/shadow.


Pasos para crear un usuario manualmente en Linux

Crear usuario

crear-usuario


Guía paso a paso para instalar MySQL en un servidor Linux.

## Descargar MySQL

Antes que nada debemos descargar MySQL de la página oficial. Recomendamos ver cuál es la última versión en la página oficial de descargas de MySQL. En este artículo hemos usado la versión de MySQL 5.0.67 (Linux non RPM packages).

Instalaremos la base de datos dentro del directorio /usr/local. Para ello descargaremos MySQL con el comando wget, luego descomprimiremos el archivo y renombraremos la carpeta a mysql (la estructura quedará así: /usr/local/mysql)

cd /usr/local
wget http://dev.mysql.com/get/Downloads/MySQL-5.0/mysql-5.0.67-linux-i686.tar.gz/from/http://mysql.mirror.kangaroot.net/
gunzip < mysql-5.0.67-linux-i686.tar.gz | tar xvf -
mv mysql-5.0.67-linux-i686 mysql
cd mysql

## Instalar MySQL

Antes de proceder a instalar MySQL, es necesario crear un usuario con el nombre mysql. Estando dentro del diretorio /usr/local/mysql, ejecutamos las siguientes instrucciones para crear este usuario y darle permisos en este directorio.

groupadd mysql
useradd -g mysql mysql
chown -R mysql .
chgrp -R mysql .

Ahora ejecutamos un script que se encuentra dentro del directorio scripts para instalar MySQL

scripts/mysql_install_db --user=mysql

Ahora podemos restablecer los permisos habituales en este directorio, a excepción de la carpeta data, que contendrá los ficheros de nuestras bases de datos

chown -R root .
chown -R mysql data

## Iniciar MySQL

Finalmente, para arrancar MySQL ejecutamos el archivo mysql_safe que se encuentra dentro de la carpeta bin. Añadimos un ampersand (&) al final para que el proceso se ejecute en segundo plano.

/usr/local/mysql/bin/mysqld_safe --user=mysql &

Tal y como nos pide el script mysql_install_db, lo que debemos hacer es asignar el password para el usuario root de la base de datos con el siguiente comando

/usr/local/mysql/bin/mysqladmin -uroot password 'miclave'

Para probar que hemos instalado correctamente MySQL podemos entrar en la consola desde:

/usr/local/mysql/bin/mysql -hlocalhost -uroot -p

Nos pide la password que hemos entrado **miclave** y ya está instalada!

## Arrancar MySQL como un Servicio

Ahora para que se arrranque MySQL al cargar el sistema operativo como un servicio haremos lo siguiente:

cd /usr/local/mysql/support-files
cp mysql.server /etc/init.d/mysql
chmod +x /etc/init.d/mysql

Y finalmente si usamos Centos o similares podemos usar la siguiente instrucción:

chkconfig --add mysql

Con debian deberemos usar el comando update-rc.d para que se inicie el servicio en los runlevels por defecto

## Llamar la Consola Mysql desde Cualquier Sitio

Ahora, si no lo hemos hecho antes (en la instalación de otros componentes), debemos poner el directorio donde hemos instalado MySQL (/usr/local/bin) en la variable de entorno $PATH. Para ello usamos algun editor de textos por ejemplo nano

nano /root/.bashrc

Y añadimos la siguiente linea

PATH=$PATH:/usr/local/mysql/bin

Guardamos y salimos. Finalmente, para que los cambios surgan efecto ejecutamos el comando source

source /root/.bashrc

Fin!


Manual para instalar MySQL paso a paso en Linux

Instalar MySQL

instalar-mysql


Para seguir este tutorial, es necesario haber instalado Apache Web Server. Tenemos otro manual de cómo [instalar Apache]({domain_root}/tutoriales/linux/instalar-apache.64.html). En este artículo hemos creado una guía paso a paso para instalar PHP en Linux.

## Descargar y Descomprimir Código Fuente PHP

Nos situamos en el directorio /usr/local/src y descargamos el código fuente de PHP. Hemos descargado la versión 5.2.6, pero recomendamos visitar la [página oficial](http://www.php.net/downloads.php) de PHP para descargar el código fuente de la última versión.

cd /usr/local/src
wget http://es2.php.net/get/php-5.2.6.tar.gz/from/this/mirror
tar zxvf php-5.2.6.tar.gz

Tras desempaquetar y descomprimir el código de PHP (el archivo .tar.gz), entramos en la carpeta que se haya creado y dentro configuraremos PHP para que se compile e instale correctamente. Si deseamos usar MySQL, esta debe estar instalada con anterioridad a PHP y debemos añadir la ruta hacia MySQL (por ejemplo --with-mysql=/usr/local/mysql) , para que cargue la extensión Mysql.so en los módulos de Apache.

./configure --with-apxs2=/usr/local/apache2/bin/apxs --with-libxml-dir --with-mysql=/usr/local/mysql --enable-mbstring

El paso de configure es muy importante para determinar que paquetes instalaremos. Si nos dejamos alguno deberemos volver a recompilar PHP en el futuro. No es ningún problema, pero si una pérdida de tiempo.

Una vez terminada la configuración, compilaremos e instalaremos PHP

make
make install

En la misma carpeta que estamos (dónde descomprimimos el código fuente de php), copiamos el archivo php.ini-dist a /usr/local/lib cambiándole el nombre a php.ini

cp php.ini-dist /usr/local/lib/php.ini

Con un editor de texto como vi, nano o otro, nos aseguramos que hay la extensión que carga mysql.so en el archivo php.ini. En caso de que no esté lo añadimos manualmente:

extension=mysql.so

## Configurar Apache para que interprete archivos .php

Finalmente, modificamos el archivo de configuración de Apache Web Server para que lea correctamente archivos .php. Abrimos el archivo httpd.conf

nano /usr/local/apache2/conf/httpd.conf

Y añadimos el siguiente código

<FilesMatch \\.php$>

SetHandler application/x-httpd-php

</FilesMatch>

Finalmente, reiniciamos el servicio de Apache y ya podremos ejecutar archivos .php

/usr/local/apache2/bin/apachectl start


Manual para instalar PHP paso a paso en Linux

Instalar PHP

instalar-php


Guía paso a paso para instalar Apache Tomcat en Linux. Descargar los binarios de Apache e instalarlo.

## Descargar y Descomprimir Binarios

Descargamos los binarios del servidor Tomcat de la página oficial de Apache utilizando por ejemplo el comando wget desde la línea de comandos de Linux. Recomendamos visitar la [página oficial del servidor](http://tomcat.apache.org/download-60.cgi) para obtener la última versión. En este artículo se ha usado la 6.0.18

cd /usr/local

wget http://apache.rediris.es/tomcat/tomcat-6/v6.0.18/bin/apache-tomcat-6.0.18.tar.gz

Se desempaqueta y descomprime el archivo. Al descomprimir se creará un directorio dentro de llamado apache-tomcat-6.0.18

tar zxvf apache-tomcat-6.0.18.tar.gz

## Creación Variables de Entorno

Ahora hay que crear las variables de entorno que colocaremos en el archivo /etc/profile. Podemos usar cualquier editor de textos por ejemplo:

nano /etc/profile

Y añadimos las siguientes líneas al final del archivo:

CATALINA_HOME="/usr/local/apache-tomcat-6.0.18"
EXPORT CATALINA_HOME

Guardamos y salimos del editor de textos. Ahora utilizamos el comando source, para que la variable de entorno tenga efecto de inmediato.

source /etc/profile

## Iniciar Apache Tomcat

Finalmente, podemos iniciar el servidor manualmente accediendo a la carpeta bin, dentro de apache-tomcat-6.0.18.

cd /usr/local/apache-tomcat-6.0.18/bin

./catalina.sh

Finalmente, para comprobar que funciona, podemos acceder a la url http://localhost:8080 y nos aparecerá la página de bienvenida de Apache Tomcat.


Manual para instalar Apache Tomcat paso a paso en un servidor Linux

Instalar Tomcat

instalar-tomcat


En esta guía veremos como instalar Apache Web Server paso a paso en un servidor Linux. En sistemas operativos Linux, existe la posibilidad de instalar aplicaciones utilizando apt-get o herramientas similares, que descargan e instalan aplicaciones precompiladas. Sin embargo, en este manual obtendremos el código fuente de Apache, lo configuraremos, luego lo compilaremos y finalmente lo instalaremos.

## Comprobar si Apache está instalado

Antes de empezar con la instalación, podemos ver si ya lo tenemos instalado. Y si lo está qué versión de Apache es. Hay varias formas de hacerlo, por ejemplo ejecutando los siguientes comandos:

updatedb
locate apachectl

**Updatedb** actualiza la base de datos para localizar los ficheros del sistema y **locate** encuentra el archivo apachectl. La ejecución de estas instrucciones en la línea de comandos nos devolverá la ruta donde residen archivos de Apache.

Para ver si se está ejecutando alguna instancia del servidor Apache podemos usar el comando **ps** para ver si hay algún proceso referente al servidor

ps aux | grep httpd

También podemos usar el comando **nmap** en nuestro sistema (localhost) para ver si hay algun puerto http abierto

nmap 127.0.0.1

Se puede obtener la versión instalada con el siguiente comando. La rutadeinstalación puede ser la ruta que hemos encontrado en el paso anterior utilizando locate

/rutadeinstalacion/apache2/bin/httpd -v

## Desinstalar Apache

En caso de querer desinstalar Apache antes de instalar la nueva versión, es necesario parar el servicio de Apache y luego eliminar procesos activos del sistema.

/etc/init.d/apache2 stop
killall -9 httpd

Finalmente, podemos desinstalar el servidor utilizando (por ejemplo):

apt-get remove apache2

## Descargar Apache Web Server

En la [web oficial del servidor](http://httpd.apache.org/download.cgi) se puede descargar el código fuente de la última versión. Descargaremos un archivo del tipo **httpd-X.X.X.tar.gz**. El siguiente código sirve para descargar el código fuente y guardarlo en una ruta local de nuestro sistema. La url de descarga puede variar con el tiempo pero un ejemplo sería el siguiente:

wget http://apache.rediris.es/httpd/httpd-2.2.9.tar.gz

Este comando descarga el archivo comprimido y lo pone en el directorio desde el que se ha llamado. A continuación se desempaqueta y descomprime el archivo tar:

tar zxvf httpd-2.2.9.tar.gz

Al ejecutar este comando se crea una carpeta llamada httpd-2.2.9. Entramos dentro de ella y escribimos el comando. (Atención: Debemos tener privilegios para poder instalar Apache, por lo que se recomienda instalarlo siendo administrador.)

./configure --prefix=/usr/local/apache2 --with-mpm=worker

Podemos pasarle el parámetro --with-mpm=worker para que [instale Apache en modo multiproceso](http://httpd.apache.org/docs/2.0/mod/worker.html).

Ahora hay que instalarlo, se ejecutan estas instrucciones una después de otra en el mismo directorio:

make
make install

Puede tardar bastante rato en compilar e instalar el servidor. Pero una vez instalado ya podemos inicializar el servicio manualmente.

/usr/local/apache2/bin/apachectl start

Ahora ya podemos acceder al servidor con el navegador entrando la url **http://localhost/** o **http://localhost:80**


Manual paso a paso para instalar Apache Web Server en servidores Linux

Instalar Apache

instalar-apache


Podríamos categorizar tres tipos de formas de instalación de aplicaciones en linux: las que traen un asistente de instalación, las que están precompiladas (se pueden instalar usando otras aplicaciones como apt-get, aptitude, rpm, yum, etc) y las que, a partir del código fuente, debes configurarlas y compilarlas. En este artículo nos centraremos en la última forma y veremos los pasos a seguir para descargar, desempaquetar (unpack), descomprimir, configurar, compilar e instalar código fuente de una aplicación en Linux desde la línea de comandos.

## Descargar el Código Fuente

Normalmente descargaremos el código fuente de la red. Ya sea por ftp, http, etc. Los archivos descargados se suelen guardar en directorios temporales (por ejemplo /tmp o en /usr/local/src)

## Desempaquetar y Descomprimir

Los archivos suelen venir empaquetados en un archivo .tar y, además, comprimidos. Existen muchos tipos de compresión: zip, gzip, bzip2, b2z, etc. Para desempaquetar un archivo podemos usar por ejemplo:

tar zxvf archivo.tar.gz

Parámetros de tar  
c: crear un archivo  
x: extraer de un archivo  
t: listar los contenidos de un archivo  
v: ver un reporte de las acciones a medida que se van realizando  
f: empaquetar contenidos de archivos  
z: comprimir al momento de empaquetar

## Establecer configuraciones antes de instalar

En muchos casos podremos utilizar un script de configuración por defecto. Este script estará en la carpeta del código fuente descargado y se ejecutará del siguiente modo:

```bash
./configure
```

Normalmente le podremos pasar diversor parámetros, como por ejemplo en que directorio deseamos que se instale pasándole el argumento ./configure --prefix=/usr/local . Para obtener todas las opciones usaremos el argumento --help y nos aparecerá un listado de opciones.

## Compilar el Código Fuente e Instalarlo

Una vez configurada, ya está preparada para compilarse. Usaremos el comando make para compilar, y luego el make install para instalar la aplicación.

```bash
make
make install
```

Si no hay ningún problema, la aplicación ya está instalada


Descargar, compilar, configurar e instalar código fuente en Linux

Compilar Código Fuente en Linux

compilar-codigo-fuente-en-linux


## ¿Qué significa SSH?

SSH es el acrónimo de un protocolo (**S**ecure **Sh**ell) que sirve para acceder a máquinas remotas que están conectadas a una red.

## Servidores SSH para Windows y Linux

A continuación proporcionamos un listado de servidores SSH. La gran mayoría son gratuitos y de código abierto (Open Source). Además, recomendamos utilizar el cliente [PuTTY](http://putty.softonic.com/)

[KpyM SSH Server](http://www.kpym.com/en/Overview.htm) es un servidor ssh gratis y opensource para Windows NT/2000/2003/XP. Proporciona acceso a un servidor remoto a través del protocolo ssh. Soporta aplicaciones de línea de comandos (dir, ftp, etc.) y aplicaciones gráficas de color (edit.com, tetrix.exe, etc.) KTS acepta conexiones de clientes SSH que funcionen bajo cualquier sistema operativo. Además, KTS proporciona la posibilidad de transmitir archivos y manipularlos utilizando el protocolo SFTP (Secure File Transfer Protocol). Este servidor se ejecuta como servicio y utiliza el sistema de identificación de Windows, de modo que no es necesario guardar usuarios y contraseñas adicionales.

[DropBear SSH Server And Client](http://matt.ucc.asn.au/dropbear/dropbear.html) es un servidor y cliente SSH 2 relativamente pequeño. Funciona en una variedad de plataformas basadas en POSIX. Es un software Open Source distribuído bajo licencia MIT-Style. Este servidor es particularmente útil para sistemas Linux o Unix, como routers inalámbricos.

[OpenSSH](http://www.openssh.com/) es una versión gratuita de las herramientas de conectividad SSH que utilizan los usuarios técnicos. Los usuarios que utilizan telnet, rlogin y ftp no se percatan de que su clave se transmite por la red sin estar encriptada. OpenSSH encripta todo el trafico (incluyendo contraseñas) para eliminar secuestros de conexión entre otros muchos ataques. OpenSSH proporciona varios métodos de autenticación además de soportar todos las versiones de protocolos SSH.

[OpenSSH para Windows](http://sshwindows.sourceforge.net/) es un paquete gratuito que instala herramientas de servidor y cliente en el paquete Cygwin sin la necesidad de instalar el programa CygWin completo. Es similar al paquete de NetworkSimplicity. El paquete de OpenSSH para Windows proporciona soporte para SSH/SCP y SFTP.

[WinSSHD](http://www.bitvise.com/winsshd.html) es un servidor seguro SSH para Windows NT4/2000/XP/2003 y Vista que soporta los siguientes servicios SSH: Acceso remoto seguro vía consola (soporta vt100, xterm y bvterm), acceso remoto seguro via GUI (Se requiere escritorio remoto o WinVNC), transferencia de archivos segura utilizando SFTP y SCP (compatible con los clientes más populares), conexión TCP/IP segura (reenvío de puerto). Puedes utilizar WinSSHD por un período de 30 días.

[copSSH - OpenSSH para Windows](http://www.itefix.no/phpws/index.php?module=pagemaster&PAGE_user_op=view_page&PAGE_id=12&MMN_position=22:22) es una implementación de un cliente y servidor SSH para sistemas Windows. Es otro paquete de openssh, cygwin, algunas herramientas populares y además con algunas de las mejores prácticas relativas a seguridad. Puedes usar COPSSH para la administración remota de tus sistemas o para obtener información remota de forma segura.


Varios servidores SSH gratuitos. La gran mayoría Open Source que te permitirán crear un servidor Secure Shell.

Servidores SSH

servidores-ssh


## Cómo se recupera la password del root en Linux

Un problema habitual para administradores de linux es no saber que hacer al perder la clave del usuario root. Afortunadamente hay varias soluciones para recuperar el acceso a tu sistema. Todas estas maneras de recuperar contraseñas en linux son, obviamente, teniendo acceso físico a la máquina.

## Primer método

La mejor manera de recuperar una clave es reiniciar en modo usuario único. Si estás utilizando Linux Loader (LILO), en la línea de boot prompt, escribimos:

```bash
linux single
```

De esta forma te convertirás en usuario root sin pedir ninguna password. Una vez el sistema se haya reiniciado, puedes cambiar la clave usando el comando:

```bash
passwd
```

## Modificar la password de un usuario

Si se ha olvidado la password de un usuario común es mucho más simple. Supongamos que el usuario **user1** ha olvidado su password:

```bash
passwd user1
```

Y el sistema te pide que entres la nueva clave.

## Segundo Método

Puedes reiniciar utilizando un LiveCD. Después (a través de una terminal root) puedes utilizar el comando chroot en tu sistema después de montarlo:

```bash
sudo su
mkdir /mnt/hd
mount /dev/hda2 -t ext3 /mnt/hd
chroot /mnt/hd
passwd
```

El sistema te pide que escribas una clave y la password root queda modificada.


Diferentes maneras de recuperar la password del usuario root en Linux si la hemos perdido.

Recuperar root password

recuperar-root-password


## Comandos para administrar un servidor Linux

En este artículo veremos una selección de comandos linux, cada uno con algún ejemplo. Estos comandos son útiles para moverse por el sistema operativo y poder realizar tareas de forma rápida y eficaz.

_* Con esta lista no se pretende mostrar (ni mucho menos) todos los comandos linux, sinó un recopilatorio de algunos de ellos y las formas más útiles o comunes de usarlos._

Para obtener ayuda detallada de estos y otros comandos ver el comando **man** de más abajo. Los comandos están ordenados alfabéticamente:

## Comando Chmod

Este comando sirve para modificar permisos de archivos. Hay dos formas de usarlo:

```bash
chmod 777 miarchivo
```

O esta otra:

```bash
chmod g+x miarchivo
```

En el primer caso añadimos permisos de forma octal, mientras que en el segundo utilizamos la notación con letras. En el ejemplo añadimos el permiso ejecutar al grupo propietario del archivo. Podemos usar o+,o- para los otros usuarios, g+, g- para añadir o quitar permisos sobre el grupo, y u+, u- para los permisos del usuario propietario, seguidos de la letra r(read), w(write) o x(execute).

## Comando Chown

Este comando sirve para cambiar el propietario de un archivo y se puede usar de la siguiente forma

```bash
chown -R nuevopropietario /rutadelarchivo
```

## Comando Chgrp

El comando chgrp modifica el grupo propietario del archivo o directorio.

```bash
chgrp nuevogrupo /rutadelarchivo
```

## Comando Du

Muestra el uso de disco de cada ARCHIVO y directorio (incluído sus subdirectorios).

```bash
du
```

Si se quiere ver sólo el tamaño total de todos los archivos y directorios de una carpeta se puede usar este comando:

```bash
du -ch | grep total
```

## Comando Grep

Este es un comando indispensable. Sirve para buscar cadenas de texto dentro de un archivo o dentro de otra cadena. Por ejemplo estas tres instrucciones devolverán el número de directorios que hay en el directorio actual. (**ls** es para listar todos los archivos y directorios y **wc -l** para contar el número de líneas

```bash
ls -l | grep ^d | wc -l
```

En este otro ejemplo podemos ver el número de veces que está conectado el usuario root. Por ejemplo si tiene abiertas diferentes _shells_ del sistema operativo a la vez. (**who** devuelve una cadena con todos los usuarios conectados)

```bash
who | grep root | wc -l
```

El comando grep soporta expresiones regulares y es lo que lo hace realmente potente, aunque siempre que se añaden expresiones regulares la cosa se complica. Supongamos que tenemos un fichero llamado **archivo_prueba** con los siguientes datos:

```
dir 15kb 27/07/2007
archivo 27kb 26/07/2007
dualco 1kb 26/07/2007
```

Y sólo queremos que nos muestre las líneas que empiezan por la letra d. Esta sería la solución con el comando grep usando expresiones regulares.

```bash
grep \\'^[d]\\' archivo_prueba
```

## Comando Head

Devuelve las primeras líneas de un texto dado. Este ejemplo devolvería las primeras 10 líneas del archivo.

```bash
head -n 10 archivo.c
```

## Comando Kill

Este comando es muy útil para detener un proceso. Normalmente se utiliza el comando **ps** para buscar el PID (Process id o número identificador de proceso) y luego kill para 'matarlo'

```bash
kill 174541
```

Donde este número es el PID del proceso.

En algunas ocasiones usando este comando el proceso no se detendrá. En este caso podemos usar el parámetro -9 para darle más prioridad

```bash
kill -9 174541
```

## Comando Locate

Este comando sirve para localizar la ruta de un archivo en linux para saber dónde está guardado. Puede ser más rápido que **find** ya que almacena las rutas en una base de datos. Es especialmente útil cuando se conoce el nombre del programa pero no se recuerda la ruta.

Es necesario actualizar el índice con el comando updatedb para que reindexe los archivos nuevos.

```bash
updatedb
locate archivo
```

Si sólo se quieren mostrar 5 resultados se puede utilizar esta instrucción:

```bash
locate "\*.h" -n 5
```

## Comando ls

Comando indispensable. Sirve para listar los archivos y directorios de una carpeta.

```bash
ls /home/root/
```

Los parámetros más usados para esta función son posiblemente "-la". Ya que muestra información detallada sobre cada archivo y directorio (incluso los archivos ocultos):

```bash
ls -la /home/root/
```

## Comando man

Este comando se utiliza para llamar al Manual de Linux y preguntarle sobre un comando en concreto.

```bash
man NOMBRECOMANDO
```

Si el NOMBRECOMANDO existe, se nos abrirá la aplicación MAN con toda la información referente a ese comando, todas sus opciones y explicaciones. Este es un comando imprescindible para profundizar en el uso de Linux.

Una vez se entra dentro de la aplicación man, se puede salir pulsando la tecla ESC y luego escribiendo :q

Algunos comandos aceptan el parámetro --help para mostrarnos información de sus opciones. Podemos usar este método para no tener que llamar a man.

```bash
NOMBRECOMANDO --help
```

## Comando Tail

Este comando sirve para visualizar la parte final de un documento (en inglés tail signifia cola). Se puede usar en muchos casos, por ejemplo, supongamos que tenemos un log de errores del servidor web Apache que ocupa varios GB. Mostrarlo usando el comando **cat error_log** no sería una buena idea, y menos si lo único que queremos es ver un error reciente que está en las últimas líneas del fichero. En este caso esta instrucción nos vendría muy bien para que nos mostrara por pantalla las últimas 50 líneas del archivo _error_log_.

```bash
tail error_log -n 50
```

## Comando ps

El comando ps nos da una instantánea de todos los procesos que se están ejecutando en un momento determinado. Ver comando Top para mostrar los procesos en tiempo real.

Aunque hay muchas opciones para filtrar y ordenar los procesos que muestra este comando, posiblemente la que más se usa suele ser

```bash
ps aux
```

Con estos parámetros se formatean los procesos mostrándo los atributos más importantes. Muchas veces se suele usar este comando junto con **grep** para encontrar un proceso en concreto

```bash
ps aux | grep "nombredelproceso"
```

Para detener un proceso se usa el comando Kill, también explicado en esta página.

## Comando Top

Muestra toda la actividad de los procesos que se están ejecutando en tiempo real. Así como información varia del sistema, uptime, memoria, etc

```bash
top
```

Para detener el comando pulsar control+c.

Tiene multitud de opciones para ordenarlo según nuestras preferencias. Si mientras se está ejecutando se pulsa la tecla shift+m se ordena por los procesos que ocupan más memoria.

## Comando Uptime

Muestra el tiempo que ha transcurrido desde que el sistema se abrió.

```bash
uptime
```

Además también muestra los usuarios que estan connectados al equipo en ese instante y las medias de carga en los últimos 1, 5 y 15 minutos.


Ejemplos prácticos de algunos de los comandos linux esenciales. chmod, chown, chgrp, du, grep, locate, tail, ls ...

Comandos Linux

comandos-linux


## Atributos de Archivos

En el sistema operativo linux, los archivos tienen muchos atributos. Para verlos podemos ejecutar este comando:

```bash
ls -l
```

Esta instrucción listará todos los archivos del directorio actual. Un ejemplo de una línia podría ser:

```bash
-rwxrwxrwx 1 root root 762 jan 30 08:15 miarchivo
```

**-** es el tipo de archivo. (Ver Tipos de Archivos).  
**rwxrwxrwx** es el permiso que tiene ese archivo. Veremos qué significan y como funcionan a lo largo de este artículo.  
**1** es el número de hard links (enlaces fuertes).  
**root root** el primer root es el usuario propietario del archivo, mientras que el segundo se refiere al grupo propietario.  
**762** es el tamaño del archivo.  
**jan 30 08:15** es la fecha de la última modificación del archivo.  
**miarchivo** es el nombre del archivo

## Tipos de Archivos

El primer atributo puede tener los siguientes valores dependiendo del tipo de archivo que sea:

**-** Archivo normal  
**l** Enlace Débil (Soft Link)  
**b** Block-oriented device file (Archivos especiales de dispositivo)  
**c** Character-oriented device file  
**p** Fifo o Pipe (Tubería)

## Permisos de Archivo

Los permisos sirven en linux para limitar el acceso y privilegios de determinados usuarios a ciertos archivos o directorios. Los permisos se organizan en tres grupos. El primero se refiere al propietario del archivo, el segundo se refiere al grupo propietario del archivo y el tercero al resto de usuarios.

Los permisos se pueden asignar de forma octal (numérica) o con combinaciones de letras rwx. **R** Read (Lectura), **W** Write (Escritura), **X** Execute (Ejecución).

Veamos un ejemplo de como pasar una cadena de permisos a modo octal. Si tenemos estos permisos: **rwx r-- --x**, lo primero que se debe hacer es separarlos por grupos de tres. Entonces sabiendo que la letra de más peso es la de más a la izquierda y que en modo octal con tres dígitos, el primer dígito valdrá 4, el segundo 2 y el tercero 1.  

**rwx** = 421  
**r--** = 400  
**--x** = 001  

Entonces sumando los tres dígitos de cada grupo obtendremos que:  
El primer dígito (propietario) 4+2+1 = 7  
El segundo dígito (grupo) 4+0+0 = 4  
El tercer dígito (otros) 0+0+1 = 1  
Por lo tanto, el permiso **rwx r-- --x** en octal es **741**.


Explicación con ejemplos de los permisos de acceso y privilegio para los usuarios y grupos de usuarios en Linux. Permisos Linux

Permisos Linux

permisos-linux


## ¿Que es Cron?

Cron es un programa que te permite ejecutar scripts o comandos automáticamente en una fecha específica. También es posible realizar tareas repetidas dados unos intervalos. Estos scripts o secuencias de comandos se guardan en un archivo llamado crontab. Y cada usuario de Linux puede disponer de su archivo crontab propio.

Si queremos crear un archivo cron que tenga efecto para el usuario con el que estamos identificados podemos escribir en la línea de comandos la instrucción **crontab -e**, se abrirá el editor de texto (vi) y ya podremos empezar a programar el cron. Para listar el contenido del crontab usaremos **crontab -l**, y **crontab -r** para eliminarlo.

Para ver todos los ficheros crontabs que se han creado podemos mirar el directorio /var/spool/cron/tabs. El programa cron está en el directorio /usr/sbin/cron y el script que lo carga al iniciar el sistema operativo en /etc/init.d

Si tienes permisos de administrador también es posible denegar que un usuario del sistema pueda usar el cron. Para ello crea o edita el archivo /etc/cron.deny y añade o quita el nombre del usuario.

## Cómo Funciona

```bash
* * * * * echo hola > /dev/console
```

Este comando imprimiría por pantalla "hola" cada minuto.

Cada asterísco indica un atributo distinto. Por orden:  
**Minuto** = El minuto de 00 a 59. Un * indica cada minuto  
**Hora** = Hora del día en formato de 24 horas: de 00 a 23. Un * indica cada hora  
**Día** = Día del mes de 1 a 31. Un * indica cada día  
**Mes** = Mes del año de 1 a 12. Un * indica cada mes  
**Día de la semana** = 3 caracteres en inglés (sun, mon,..) o númerico empezando el domingo por 0 (0=domingo, 1=lunes,...). Un * indica cada día de la semana.  
**Comando** = El comando que queremos que se ejecute.

## Ejemplo de crontab

```bash
*/2 * * * * echo hola > /dev/console
```

Escribirá cada dos minutos "hola" por pantalla


Cron es una aplicación de linux para programar tareas que se ejecuten de forma automática.