Download linux administrator - Skanda Tecnology Advisors

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

Document related concepts

Filesystem Hierarchy Standard wikipedia , lookup

Fstab wikipedia , lookup

Proceso de arranque en Linux wikipedia , lookup

XFS wikipedia , lookup

Inodo wikipedia , lookup

Transcript

[FECHA]
LINUX ADMINISTRATOR
[TÍTULO DEL DOCUMENTO]
[SUBTÍTULO DEL DOCUMENTO]
USUARIO DE MICROSOFT OFFICE
[NOMBRE DE LA EMPRESA]
[Dirección de la compañía]
Tabla de contenido
Presentación del instructor: ............................................................................................................................... 3
Alineación de expectativas: ................................................................................................................................ 3
Presentación del objetivo del curso: .................................................................................................................. 3
Reglas de oro: ..................................................................................................................................................... 3
Cumplimiento de expectativas: .......................................................................................................................... 4
Introducción ........................................................................................................................... 5
Unidad 1.- Instalación del SistemaOperativo y Ajustes posteriores ....................................... 6
Introducción ....................................................................................................................................................... 6
Sistema Operativo UNIX ..................................................................................................................................... 8
Sistema Operativo Linux..................................................................................................................................... 9
Requerimientos de Hardware de Linux ............................................................................................................11
Organización de Linux ......................................................................................................................................13
Sistema de Archivos en Linux ...........................................................................................................................15
Procesamiento de Texto ...................................................................................................................................17
Características del Sistema Linux .....................................................................................................................20
Software disponible en Linux ...........................................................................................................................20
Distribuciones Linux. .........................................................................................................................................20
Estándar de Jerarquía de Sistema de Archivos. ...............................................................................................25
Estructura de los directorios general ...............................................................................................................25
Estructura de Archivos .....................................................................................................................................26
Instalacion Centos ............................................................................................................................................30
Editor de texto VI y VIM ...................................................................................................................................46
Uso de disco de rescate en CentOS 6.5 ............................................................................................................61
Gestion de memoria Swap ...............................................................................................................................74
Unidad 2.- Administración del Sistema de Archivos.............................................................. 77
Límites de tamaño ............................................................................................................................................77
Sistema de archivos de gran tamaño ...............................................................................................................78
Extents ..............................................................................................................................................................78
Swapinees.........................................................................................................................................................82
Commit .............................................................................................................................................................83
fsck (file system check o bien file system consistency check)..........................................................................83
Uso de dd..........................................................................................................................................................86
Unidad 3. -Administración de Sofware y servicios. ............................................................... 95
Gestión de paquetes RPM ................................................................................................................................96
Instalación de paquetes. ..................................................................................................................................98
Gestor de Servicios .........................................................................................................................................105
Secuencia de arranque ...................................................................................................................................107
Arranque y parada de lo servicios ..................................................................................................................111
pág. 1
Envío de señales a los procesos .....................................................................................................................112
Unidad 4.-Gestión de usuarios, grupos y privilegios. ........................................................ 117
Gestión de cuentas de usuario. ......................................................................................................................117
Tipos de usuarios ............................................................................................................................................117
Archivos de configuración ..............................................................................................................................126
Gestion de cuentas de grupos: .......................................................................................................................129
SUDO ..............................................................................................................................................................130
Unidad 5. Permisos y Atributos del Sistema de Archivos. ................................................... 141
Permisos de ficheros ......................................................................................................................................144
Umask .............................................................................................................................................................145
Comando chmod ............................................................................................................................................147
Comando chown ............................................................................................................................................150
Unidad 6.- Herramientas básicas del Sistema Operativo. ................................................... 156
Compresión y descompresión de archivos.....................................................................................................167
Gestión de procesos y trabajos. .....................................................................................................................176
Configuración y uso de crond. ........................................................................................................................180
Usando cron ...................................................................................................................................................181
Implementar y Administrar Cuotas De Disco (Disk Quotas) en Linux ............................................................202
UNIDAD 7.- Redes ............................................................................................................... 212
Configuración de red. .....................................................................................................................................212
Configuración del fichero resolv.conf ............................................................................................................216
Iptables ...........................................................................................................................................................218
Protocolo TCP .................................................................................................................................................224
Protocolo UDP ................................................................................................................................................225
Protocolo ICMP...............................................................................................................................................226
Protocolo SSH .................................................................................................................................................232
Historia del SSH ..............................................................................................................................................233
Versiones de SSH ............................................................................................................................................233
Características de SSH ....................................................................................................................................233
Instalacion y Configuracion: ...........................................................................................................................234
Secuencia de eventos de una conexión SSH ..................................................................................................238
Autenticación en SSH .....................................................................................................................................240
Canales en SSH ...............................................................................................................................................241
Servidores FTP ................................................................................................................................................241
Intalacion y Configuracion de FTP. .................................................................................................................245
Modo activo ...................................................................................................................................................256
Modo pasivo ...................................................................................................................................................257
CONCLUSIONES ..............................................................................................................................................258
CIBERGRAFIA ..................................................................................................................................................259
pág. 2
Formación de la comunidad de aprendizaje:
La formación de la comunidad de aprendizaje es un proceso que debe llevarse a cabo para iniciar
cada uno de nuestros cursos. Su finalidad es crear un clima propicio para la celebración de la
actividad instruccional, es decir, generar un entendimiento previo entre el instructor y los
participantes sobre los temas que se desarrollarán durante ésta, así como las estrategias
educativas que se llevarán a cabo para lograr un mejor aprendizaje.
Un adecuado manejo de la comunidad de aprendizaje es un elemento fundamental para
garantizar la satisfacción de uno de los clientes involucrados en la impartición de los cursos: los
participantes.
Presentación del instructor:
Nombre, profesión, años de experiencia como instructor, experiencia en la impartición del curso,
o cursos similares o relacionados.
Alineación de expectativas:
•
El instructor recabará las expectativas de los participantes respecto al curso, con el fin de
dejarles claro el objetivo del mismo.
•
En caso de que alguna expectativa no coincida con los temas que el curso contiene, el
instructor dejará claro cuáles de las expectativas expresadas no serán cubiertas con el curso y
porqué.
•
Las expectativas alineadas serán anotadas en hojas de rotafolio para su revisión al término
del curso.
•
Durante el desarrollo del curso el instructor deberá cubrir las expectativas alineadas.
Presentación del objetivo del curso:
•
El instructor presentará a los participantes el objetivo del curso, aclarando dudas al
respecto si las hubiese.
Reglas de oro:
•
El instructor promoverá el establecimiento de reglas por parte de los participantes que se
observarán a través del curso; por lo que puede proponer: tiempo de tolerancia para iniciar las
sesiones, respeto hacia los compañeros, participación de todos en técnicas y ejercicios grupales,
etc.; se incluirán todos los puntos que los participantes consideren pertinentes.
pág. 3
•
Se anotarán los acuerdos en hojas de rotafolio y se colocarán en un espacio en el que sean
visibles a lo largo de todo el curso.
Cumplimiento de expectativas:
•
Al finalizar el curso el instructor deberá llevar a cabo una revisión de las expectativas
alineadas que se anotaron en hojas de rotafolio al inicio del curso.
Se revisará cada una de las expectativas alineadas palomeando las que hayan sido
cumplidas, y el instructor explicará de qué manera se llevó a cabo tal cumplimiento.
pág. 4
Introducción
Linux es un sistema operativo de la familia Unix, gratuito, creado mediante la política de “código
abierto”. Estas características implican un gran ahorro en los costes de instalación de los
equipos, pero también una mayor especialización por parte del personal informático.
En todo sistema Unix existe un usuario administrador (root), que controla el funcionamiento
completo del sistema, tiene acceso universal y puede realizar cualquier operación con los datos
y los dispositivos de la máquina.
Por lo tanto, este curso tiene como finalidad la formación de profesionales en el área de
Administración de Redes que le permite al participante obtener conocimientos profundos en el
área de infraestructura. Combina una sólida formación teórico -práctica con una metodología que
logra un importante nivel de entrenamiento técnico.
pág. 5
Unidad 1.- Instalación del SistemaOperativo y Ajustes posteriores
Introducción
Un sistema de computadora es un dispositivo electrónico programable que puede almacenar,
recuperar y procesar datos. Ejecuta un conjunto de instrucciones llamado programa. La
ejecución del programa da al usuario final el resultado deseado. Un ejemplo de ejecución de
un programa es cuando se trabaja con una calculadora en un sistema operativo Windows.
Una computadora es capaz de realizar múltiples tareas, tales como:
•
•
•
•
Ejecutar programas de usuario
Conectar computadoras en una Red de Área Local (Local Área Network – LAN)
Compartir los recursos
Controlar su hardware
Para que una computadora sea capaz de hacer todo esto, requiere de un programa especial
llamado sistema operativo. El sistema operativo reside en el disco duro de la computadora
y actúa como un puente entre los programas de usuario y los programas que controlan le
hardware de la computadora.
El sistema operativo trabaja principalmente en segundo plano. Se encarga de los componentes
hardware de una computadora, además de asegurar el inicio y ejecución de diversos programas.
También se encarga de los datos almacenados en los dispositivos de almacenamiento de la
computadora.
El sistema operativo es el responsable de las siguientes funciones del sistema de computadora:
•
•
•
•
Arrancar o iniciar la computadora
Actuar como interfaz entre el CPU y el mundo externo
Coordinar los dispositivos del sistema
Coordinar las aplicaciones o programas en ejecución
El sistema operativo controla todo el trabajo de la computadora. Sin el, la computadora solo
es un montón de circuitos electrónicos.
pág. 6
Programa de
Usuario
Sistema
Operativo
Programas que
controlan
Ilustración 1 Rol de un Sistema Operativo
Los siguientes son algunos de los usos del sistema operativo:
Proporciona diferentes recursos a los usuarios, tales como: calculo, almacenamiento,
dispositivos de Entrada/Salida (Input/Output – I/O) manejo de red, etc
Permite que varios usuarios trabajen juntos compartiendo e intercambiando programas,
aplicaciones y datos en la misma instalación.
Ayuda a resolver conflictos cuando los usuarios solicitan el mismo recurso simultáneamente.
Proporciona seguridad cuando los usuarios comparten datos y programas.
Asiste en la administración y evaluacion del uso y eficacia de un sistema, recolectando datos
sobre la utilización de los recursos.
En los sistemas de computadoras, existen varios componentes que solo trabajan en forma
secuencial y que solo se pueden compartir directamente en forma marginal. Los sistemas
operativos permiten que se haga un uso eficiente de estos componentes.
Inicio de un Sistema Operativo
El proceso de iniciar el sistema operativo es llamado arranque (bootstrapping o booting). Aquí
se mencionan algunos puntos acerca de cómo se inicia un sistema operativo.
Las instrucciones para el arranque están incluidas en uno de los chips de la computadora,
llamado el chip BIOS (Basic Input/Output System)
El chip BIOS informa a la computadora que busque un programa especial llamado el gestor de
arranque (boot loader)
El gestor de arranque esta disponible en un lugar fijo en el disco de arranque. El disco de
arranque en cualquier computadora es el disco duro primario.
El gestor de arranque inicia la parte principal del sistema operativo.
pág. 7
Los sistemas operativos son clasificados en dos tipos:
Sistema Operativo de Usuario Único: permite que solo un usuario use todos los recursos del
sistema de computadora en cualquier momento dado. Mientras el procesador maneja un
usuario o programa, otros programas o usuarios no pueden usar estos recursos. Un ejemplo
de Este tipo el sistema operativo DOS.
Sistema Operativo Multiusuario: permite que más de un usuario o programa se ejecuten o
usen recursos del sistema en forma simultánea. Algunos ejemplos de estos sistemas
operativos multiusuario son UNIX, XENIX, Linux, Solaris, etc.
En los tiempos en que los sistemas operativos como DOS únicamente permitían solo un
usuario para realizar tareas simples, la introducción de UNIX creo una nueva forma de
computación. A pesar que Windows también es un sistema operativo principalmente de
usuario único, permite que varias tareas se realicen en forma simultanea. A continuación se
aprenderá acerca del sistema operativo UNIX, dado que Linux es una variación del sistema
operativo UNIX.
Sistema Operativo UNIX
El sistema operativo UNIX tiene una historia muy interesante. Algunos aspectos de su
evolución son:
• Bell Telephone Laboratorios (BTL), GE y MIT se unieron intentando crear un sistema
operativo que permitiera trabajar simultáneamente hasta mil usuarios. Ken
Thompson y Dennis Ritchie de BTL trabajaron en esto y crearon un sistema
operativo llamado MULTICS, un acrónimo de MULTiplexed Information and
Computer Services (Servicio de Información Multiplexada y Calculo).
• BTL se retiro del proyecto durante el desarrollo del trabajo.
• En 1969-70, Thompson y Ritchie reescribieron el sistema operativo para jugar un
juego de guerra espacial con otra maquina mas pequeña.
• Este sistema operativo fue llamado Uniplexed Information and Computing Services
(UNICS), un juego de palabras del MULTICS original.
• El nombre de UNICS luego fue transformado a UNIX.
• En 1972-73, el sistema UNIX fue reescrito usando el lenguaje de programación C
• El sistema operativo UNIX es uno de los mas poderosos versátiles y flexibles en el
mundo hoy en día.
pág. 8
El sistema operativo UNIX corre en un rango de computadores desde microcomputadoras hasta
mainframes. Algunas de sus características son:
Es conocido como un sistema operativo “ abierto” dado que puede ser llevado e instalado
en cualquier clase de sistema de computadora y plataforma de hardware.
Normalmente, los sistemas operativos son escritos en lenguaje ensamblador. Sin embargo,
UNIX esta escrito en un lenguaje de alto nivel y su código fuente esta disponible fácilmente.
Esto supone una ventaja para los programadores cuando incorporan cambios para ajustarse
a sus necesidades.
Es un sistema multiusuario y multitarea. Multitarea significa que el sistema operativo coordina
múltiples tareas o trabajos en forma simultanea. Mientras un usuario esta compilando un
programa en C, otro puede crear documentos usando un editor, cada ignorando la presencia
del otro.
UNIX es uno de los sistemas operativos más poderosos existentes, por el hecho de poder
compartir recursos en tiempo real.
A pesar de que UNIX esta desarrollado para programadores, proporciona un entorno tan flexible
que también es usado en negocios, ciencias, educación e industria.
Los interruptores de telecomunicación y sistemas de transmisión son algunos ejemplos del
uso del sistema operativo UNIX
A continuación se aprenderá acerca del sistema operativo Linux:
Sistema Operativo Linux
Linux es un sistema operativo distribuido gratuitamente basado en el sistema operativo
UNIX. Fue desarrollado originalmente por Linus Torvalds, quien empezó a trabajar sobre Linux
en 1991 siendo estudiante de la Universidad de Helsinki en Finlandia. Luego, miles de
programadores contribuyeron a su desarrollo y fue distribuido gratuitamente por Internet.
Por los años 80, los sistemas operativos eran básicamente propietarios, lo que significaba que
se tenía que usar solo el sistema operativo proporcionado para una plataforma especifica. El
proyecto GNU fue fundado por Richard Stallman, quien fue el también fundador de Free
Software Foundation (FSF), autor de GNU GPL (General Public License) y el desarrollador
original de algunos programas de software GNU (por ejemplo, el compilador gcc y el editor de
texto Emacs)
pág. 9
Las principales metas del proyecto GNU incluyeron las siguientes:
•
•
•
Desarrollar un sistema operativo compatible con UNIX
Soportar diferentes arquitecturas de hardware
Hacer que el sistema operativo estuviese disponible libre de costo para asegurar
que los usuarios pudiesen redistribuir todo el sistema y cambiar ó contribuir a
alguna parte de él.
En 1990, la mayoría de las piezas de software del sistema operativo basado en GNU se habían
escrito, excepto la más importante, el kernel. El kernel es el núcleo del sistema operativo.
Mas tarde, el kernel gratuito basado en UNIX, desarrollado por Linus Torvalds fue
combinado con el sistema GNU. Así nació un sistema operativo, el sistema GNU basado en
Linux.
Las etapas significativas en la evolución de Linux son:
•
En 1991, Linus Torvalds desarrollo Linux con el soporte de desarrolladores a lo
largo del mundo y lo llamo Linux
•
•
•
El lanzo la versión 0.02 de Linux en 1991
En 1994, fue lanzada la versión 1.0 de Linux
La versión 2.6 completa fue lanzada en Diciembre de 2003. Sin embargo, su
desarrollo continúa.
Los siguientes son algunos de los hechos básicos acerca del sistema operativo Linux:
Es desarrollado, escrito, distribuido y respaldado bajo GPL de GNU (GNU no es UNIX).
Como resultado, su código fuente puede ser distribuido gratuitamente y disponible
para el publico en general.
Los sistemas Linux se usan para redes, desarrollo de software, soluciones de
alojamiento basados en Web y como plataforma de usuario final.
La mascota oficial, que Linus eligió para su sistema operativo, es el pingüino Linux llamado
Tux (Torvalds Unix), que se presente en la figura 1.2
pág. 10
Ilustración 2 “TUX”, la mascota de Linux
Linux no es un derivado del código fuente de UNIX. Sin embargo, la interfaz de Linux es
intencionalmente como la de UNIX. Así las lecciones aprendidas acerca de UNIX, incluyendo
información sobre seguridad son aplicables tanto a UNIX como a Linux
Linux es un sistema operativo estable y versátil, especialmente como un servidor de red.
Proporciona un sólido entorno grafico, paquetes fáciles de instalar y aplicaciones de alto
nivel.
Requerimientos de Hardware de Linux
Linux soporta plataformas de hardware tales como Intel x86, PowerPC, S/390, SPARC y Alpha.
Los diferentes requerimientos de hardware para Linux se listan en la siguiente tabla
CPU
Hardware
Tarjeta Madre (MotherBoard)
Memoria
Monitor y Adaptador de Video
Dispositivos de Puntero
Controlador de Disco Duro
Requerimientos
La serie x86 de Intel y sus compatibles,
DEC, Alpha, Motorola, PowerPC, etc.
Sistemas de bus PCI, EISA, VESA y MCA.
64 MB(mínimo), 256 MB recomendados
para mayor eficiencia y ejecución
CGA, EGA, VGA, IBM monochrome, Súper
VGA y otras tarjetas aceleradoras de video
Ratón serial estándar como Logitech, serie
MM, Microsoft 2 botones, Sistemas Mouse de 3
botones, etc.
IDE, EIDE, MFM \, RLL y la mayoría de los controladores
ESDI
pág. 11
Espacio de Disco Duro
Requiere un mínimo de 100 MB de espacio
para una instalación mínima de Linux. Para una
instalación completa con todos los servicios, los
requerimientos pueden ser tanto como 2 GB
Unidades de CD-ROM
Sistema estándar de archivo ISO 9660 para CD-ROMS
Unidades de Cinta
Impresoras
Modems
SCSI
Impresoras paralelas
Modems seriales internos y externos
Tarjetas Ethernet
Soporta tarjetas
populares
3 Tabla: Requerimientos de Hardware de Linux
pág. 12
Ethernet
y
adaptadores LAN
Organización de Linux
El sistema operativo Linux esta organizado funcionalmente en los siguientes tres niveles:
•
•
•
Kernel (Núcleo)
Shell (Interprete de Comandos)
Herramientas y aplicaciones.
La representación esquemática de las tres partes principales del sistema operativo Linux se
presenta en la Figura 4
Herramientas y aplicaciones
Shell
Nucelo
Ilustración 4 Partes Principales del Sistema Operativo Linux
El kernel
El kernel es el núcleo de un sistema operativo, así como la CPU es el núcleo de un sistema
de computadora. El kernel es una colección de programas, la mayoría escritos en C y solo existe
un kernel para cualquier sistema operativo. Este se comunica directamente con el hardware y
sin un kernel un sistema operativo no puede interactuar con el hardware. Algunas de las tareas
importantes del kernel son:
•
•
Verificar si el usuario es un usuario autorizado
•
•
Asignar espacio de almacenamiento para los archivos en el sistema
Hacer seguimiento de los diferentes programas que están ejecutándose y asignar
un tiempo especifico a cada programa
Ejecutar el programa shell
pág. 13
•
Manejar la transferencia de información entre la computadora y las terminales
En un sistema multiusuario, a cada terminal se le asigna un numero y los usuarios trabajan en
terminales conectadas a la computadora principal. El sistema operativo se comunica con la
Terminal a través de los números de Terminal
El Shell
El sistema operativo Linux usa un shell para transferir los comandos desde el teclado a la
computadora. El shell (interprete de comandos) es solo otro programa escrito en C.
Actúa como un intérprete entre los programas de los usuarios y el kernel. Traduce los
comandos del usuario en la acción apropiada. El shell interactúa con el usuario, mientras que
el kernel interactúa con el hardware de la maquina.
El shell es el programa que toma comandos y, ejecuta el programa apropiado o lo traduce en
instrucciones que el kernel entiende. Por ejemplo, un comando tal como chdir será traducido
por el shell a un formato entendible por el kernel, mientras que un comando tal como ls será
ejecutado por el shell como un programa en el directorio /usr/bin/ls.
El shell es una interfaz basada en texto para el sistema Linux. En Linux, las interfaces graficas
tales como el Sistema X Window (similar al presentado por Windows NT y 2000, que permiten
al usuario ejecutar comandos usando el ratón y el teclado) también pueden ser usadas. El shell
por defecto en Linux es bash (Bourne Again Shell). Otros tipos de shell disponibles en Linux
son:
csh (C Shell)
ksh (Korn Shell)
sh (Shell)
esch (enhanced C Shell)
Bourne Shell y el C Shell son los que se usan comúnmente. Ambos son controlados por
comandos. El Korn Shell es el menos usado. Todos los shells sirven para el mismo propósito, pero
tiene diferentes características y sintaxis.
pág. 14
Herramientas y Aplicaciones
En el sistema Linux existe un cierto número de herramientas disponibles. Las herramientas
son programas de usuario que pueden ser escritos por terceros para determinados tipos de
aplicaciones. Típicamente, las herramientas se agrupan para realizar ciertas funciones, tales
como programación, aplicaciones de negocio y procesamiento de texto.
A continuación se aprenderá acerca de la organización del sistema de archivos en el sistema
operativo Linux
Sistema de Archivos en Linux
Todos los programas de usuario, documentos, herramientas, aplicaciones, etc son
almacenados como archivos en sistema de computadora. Todos los archivos son almacenados
en un dispositivo de almacenamiento secundario (usualmente un disco). Una porción del
disco es separada para almacenar la información relacionada a los archivos almacenados. Esta
unidad funcional se denomina sistema de archivos.
Algunos de los puntos importantes aquí son:
El área de la superficie donde se almacenan los archivos se dividen en pistas circulares.
Las pistas circulares están divididas en sectores o bloques de disco (en forma de torta)
Todos los bloques del disco son del mismo tamaño y tienen un numero único llamado
el numero de bloque de disco
El tamaño del bloque de disco varía dependiendo de la distribución Linux.
La mayoría de los sistemas modernos tienen un tamaño de bloque de disco de un 1 KB
(kilobytes). Los bloques de disco están organizados en los siguientes cuatro grupos:
Bloque de Arranque (Boot)
Superbloque
Bloque Inodo (128 bytes)
Bloque de Datos
Cada sistema de archivos tiene un bloque de arranque, un superbloque, una lista de
bloques inodos y una lista de bloques de datos.
pág. 15
Ahora se va a entender la necesidad y uso de cada bloque en el sistema de archivos.
Bloque de Arranque
Consiste de un bloque de disco que contiene el código para iniciar la computadora,
Ocupa el primer bloque de un sistema de archivos
Un sistema solo requiere de un bloque de arranque para iniciar el sistema. En el resto de los
sistemas de archivos, este bloque permanece vacío.
Superbloque
Esta a continuación del bloque de arranque en el sistema de archivos
Consiste de un bloque de disco que contiene información acerca del sistema de archivos
Contiene información acerca del número de bloques en el sistema de archivos, el número de
bloques asignados para inodos (se aprenderá acerca de los inodos más adelante) y el número
de bloques que están actualmente libres.
Bloque Inodo
Es el tercer grupo de bloques en un sistema de archivos.
Contiene más de un bloque de disco para mantener información acerca de los archivos en
el sistema de archivos.
Bloque de Datos
Almacena el contenido del archivo
Sigue a los bloques asignados para inodos.
Un sistema de archivos contiene cierto número de bloques de datos.
Antes de proceder a aprender acerca de la partición del disco, se entenderá un poco mas acerca
de la información que mantiene inodos. Los inodos mantienen información acerca del
propietario del archivo, los bloques de disco usados en el archivo, etc. Los archivos, por otro
lado, contienen los datos del archivo.
Asuma que se crea un archivo llamado midocumento.txt. Este debe ser almacenado en el disco.
Dependiendo del sistema de archivos al que este asociado, los datos del archivo se
almacenaran en los bloques de datos y otra información administrativa acerca de este, será
almacenada en los bloques inodos.
pág. 16
Partición de Disco
Aquí, el sistema divide el disco en particiones de disco.
Cada partición consiste en bloques, situados en forma contigua, pero separados de las otras
particiones
La partición puede ser un sistema de archivos o un espacio de intercambio
(space swap).
Un espacio de intercambio (space swap) se usa para implementar la memoria virtual, donde
una porción de la memoria principal se almacena temporalmente
La partición primaria es donde se almacenan los archivos relacionados al arranque.
Las particiones del espacio de intercambio (space swap) son una secuencia lineal de
bloques.
El tamaño de los archivos cambia a través del tiempo (crece o disminuye)
Un bloque de datos de un archivo puede no estar en una secuencia lineal de bloques. En
vez de ello, puede estar disperso a lo largo de toda la partición.
Procesamiento de Texto
El sistema Linux proporciona métodos poderosos de procesamiento de un texto.
Un ejemplo simple de procesamiento es encontrar el número de ocurrencias de un patrón
dado en un texto.
A continuación se considerara un ejemplo:
“La pronunciación de la palabra pronunciación es pronunciación”
En esta oración el patrón ‘pronunciación’ ocurre tres veces en el texto. Cierto número de
herramientas, tales como grep, egrep y fgrep, están disponibles para realizar el procesamiento
de texto.
También existen otras herramientas de procesamiento de texto, que son conocidas como
editores. Estos proporcionan las funcionalidades para crear, editar (modificar) y guardar
texto.
pág. 17
Algunos ejemplos de editores son:
Vi: es conocido como editor visual y es el editor más popular. Vi es un programa que
permite a los usuarios editar tanto archivos de texto como binarios. Los archivos de texto
son aquellos que tienen caracteres alfanuméricos, mientras que los binarios contienen
caracteres entendibles por la maquina. A pesar que también puede leer archivos binarios,
vi es conocido normalmente como un editor de texto.
Un editor de texto es como un procesador de palabras. Los editores de texto se usan
principalmente para escribir programas, que luego son convertidos en un código
entendible por la maquina a través de otro programa.
Ed: mientras que vi es un editor que permite visualizar el contenido de un archivo, una
pantalla a la vez, ed es un editor en linea. En cualquier momento, solo puede mostrarse
una linea del archivo.
Sed: es un editor de flujos basado en ed. Puede editar archivos sin intervención del
usuario. Los comandos de edición pueden ser pasados como argumentos de linea de
comandos. Los argumentos de linea de comandos son aquellos que se proporcionan
junto con un comando, antes de que el comando sea ejecutado. Estos argumentos van
como entradas sobre las cuales el programa puede trabajar para producir cierta salida.
Sed se utiliza extensivamente en los sistemas Linux. Proporciona mecanismos poderosos
para editar flujos de datos pasados a el como entrada.
Emacs: es un poderoso editor de texto. Siendo C el lenguaje de programación usado
comúnmente en los sistemas Linux, emacs tiene características incorporadas que
permite dar formato automático a los programas C, a su vez también permite la
búsqueda de patrones y lectura de correo electrónico desde el editor.
A continuación se presenta una breve discusión sobre las capacidades de programación y
documentación disponibles en Linux.
Programación
Se puede programar a través del shell y esto se conoce como programación de shell Linux
proporciona más de un shell. El Bourne Again Shell (popularmente conocido como bash) es
el shell mas usado. Se aprenderá acerca de los diferentes shells que proporciona Linux
en la unidad 2: El Sistema Linux. Cada shell en Linux proporciona la capacidad de programación.
Un programa shell puede invocar las herramientas proporcionadas en Linux a través de una
sintaxis simple. La programación de shell es similar a un lenguaje de programación como C.
pero con una sintaxis diferente.
pág. 18
Combinado con el poder del procesamiento de texto, la programación en Linux es
extremadamente poderosa. La administración de sistemas complejos en sistemas operativos
estilo UNIX se hace típicamente a través de la programación del shell. El administrador del
sistema usa la programación del shell en forma extensiva para administrar y monitorear el
sistema operativo.
Documentación.
Linux proporciona una documentación bastante elaborada para todas sus herramientas. Las
herramientas son referidas comúnmente como comandos.
El sistema Linux proporciona cierto número de comandos. Algunos de ellos son:
clear – limpia la pantalla
date – muestra la fecha y hora
cal – muestra el calendario del mes actual
who – muestra los usuarios que están actualmente conectados al sistema
Sin embargo, dado que los comandos son tan extensos, no es posible para ningún usuario
recordar todos los comandos y la sintaxis asociada con estos.
La documentación puede ser leída fácilmente con la ayuda de una herramienta controlada por
comandos llamada man.
A continuación se dan ejemplos algunos comandos de uso en conjunto con man
man clear
man date
man man
Los primeros dos usos del comando man muestran la documentación para los comandos clear
y date, respectivamente. El tercer uso, muestra la documentación del mismo comando
man
pág. 19
Características del Sistema Linux
El sistema Linux ofrece las siguientes características:
Estabilidad: tiene protección de la memoria entre procesos, de manera que uno de ellos
no pueda colgar el sistema.
Multitarea: varios programas (realmente procesos) ejecutándose al mismo tiempo
Multiplataforma: se ejecuta en muchos tipos de CPU, no solo Intel
Multiusuario: varios usuarios en la misma maquina al mismo tiempo (y sin licencias para
todos)
Manejo de la Memoria: la memoria gestiona como un recurso unificado para los
programas de usuario y para cache de disco, de tal forma que toda la memoria libre puede
ser usada para cache y este puede a su vez ser reducido cuando se ejecutan grandes
programas
Interfaz Grafica de Usuario: KDE, GNOME.
Desarrollo de Software: KDevelop (Lenguaje C, C++, Java, PHP, Perl, Phyton, entre
otros)
Trabajo de redes: TCP/IP, incluyendo ftp, telnet, NFS, Gíreles, etc.
Disponibilidad del código Fuente: todo el código fuente esta disponible, incluyendo el
núcleo completo, todos los drivers, las herramientas de desarrollo y todos los programas
de usuario; además están disponibles libremente.
Software disponible en Linux
En Linux se encuentran disponibles varios tipos de software. Algunas de las categorías son:
Aplicaciones
Software de Desarrollo
Software Científico
Software de Sistema
Utilitarios
Juegos.
Distribuciones Linux.
Como el código fuente para Linux fue desarrollado esta siendo distribuido gratuitamente,
diferentes compañías han desarrollado sus propias versiones o distribuciones de Linux Cada
una de estas variedades tiene su propio conjunto de características, tales como
procedimientos de instalación y administración, paquetes de software y configuraciones.
pág. 20
Muchas de ellas están configuradas para un tipo específico de computadora.
Las 10 distribuciones principales se listan a continuación:
Mandrake Linux, desarrollado por MandrakeSoft.
Red Hat Linux, desarrollado por Red Hat
Debian GNU/Linux, desarrollado por Debian.
SuSE Linux, desarrollado por SuSe, Inc.
Gentoo Linux, desarrollado por Gentoo Technologies, Inc.
El Proyecto Slackware Linux, desarrollado por Slackware Linux, Inc.
Lycoris Desktop, desarrollado por Lycoris
Beehive Linux, desarrollado por el Equipo Beehive
Caldera OpenLinux, desarrollada por Caldera Internacional, Inc.
Turbolinux, desarrollado por Turbolinux, Inc.
Existen muchas más, aunque la distribución mas usada es Red Hat Linux
Linux es un sistema de libre distribución por lo que puedes encontrar todos los ficheros y
programas necesarios para su funcionamiento en multitud de servidores conectados a Internet.
La tarea de reunir todos los ficheros y programas necesarios, asi como instalarlos en tu sistema y
configurarlo, puede ser una tarea bastante complicada y no apta para muchos. Por esto mismo,
nacieron las llamadas distribuciones de Linux, empresas y organizaciones que se dedican a hacer
el trabajo "sucio" para nuestro beneficio y comodidad.
Ilustración 5 Distribuciones de Linux
Una distribución no es otra cosa, que una recopilación de programas y ficheros, organizados y
preparados para su instalación. Estas distribuciones se pueden obtener a traves de Internet, los
cuales contendrán todo lo necesario para instalar un sistema Linux bastante completo y en la
mayoría de los casos un programa de instalación que nos ayudara en la tarea de una primera
instalación. Casi todos los principales distribuidores de Linux, ofrecen la posibilidad de bajarse sus
distribuciones, via FTP (sin cargo alguno).
pág. 21
Existen muchas y variadas distribuciones creadas por diferentes empresas y organizaciones a unos
precios bastantes asequibles (si se compran los CDs, en vez de bajársela via FTP), las cuales
deberías poder encontrar en tiendas de informática ó librerías. En el peor de los casos siempre
puedes encargarlas directamente por Internet a las empresas y organizaciones que las crean. A
veces, las revistas de informática sacan una edición bastante aceptable de alguna distribución.
A continuacion una gráfica con todas las distribuciones a lo largo de los últimos años. Este gráfico
es grande asi que pulsar en el mismo para ver la versión en tamaño original.
Ilustración 6 Distribuciones en los ultimos años
Si vas a instalar el sistema por primera vez, te recomiendo que pruebes una distribucion LiveCD.
Con una de ellas podras probar Linux sin necesidad de instalarlo. A continuación puedes encontrar
informacion sobre las distribuciones más importantes de Linux (aunque no las únicas).
UBUNTU.-Distribución basada en Debian, con lo que esto conlleva y
centrada en el usuario final y facilidad de uso. Muy popular y con
mucho soporte en la comunidad. El entorno de escritorio por defecto
es GNOME.
http://www.ubuntu.com/
pág. 22
REDHAT ENTERPRISE.-Esta es una distribución que tiene muy buena
calidad, contenidos y soporte a los usuarios por parte de la empresa
que la distribuye. Es necesario el pago de una licencia de soporte.
Enfocada a empresas.
http://www.redhat.com/
FEDORA.-Esta es una distribución patrocinada por RedHat y soportada
por la comunidad. Facil de instalar y buena calidad.
http://fedora.redhat.com/
DEBIAN.- Otra distribución con muy buena calidad. El proceso de
instalacion es quizas un poco mas complicado, pero sin mayores
problemas. Gran estabilidad antes que últimos avances.
http://www.debian.org/
OpenSuSE.-Otra de las grandes. Facil de instalar. Version libre de la
distribucion comercial SuSE.
http://www.opensuse.org/es/
SuSE LINUX ENTERPRISE.-Otra de las grandes. Muy buena calidad,
contenidos y soporte a los usuarios por parte de la empresa que la
distribuye, Novell. Es necesario el pago de una licencia de soporte.
Enfocada a empresas.
https://www.suse.com/
SLACKWARE.- Esta distribución es de las primeras que existio. Tuvo un
periodo en el cual no se actualizo muy a menudo, pero eso es historia.
Es raro encontrar usuarios de los que empezaron en el mundo linux
hace tiempo, que no hayan tenido esta distribucion instalada en su
ordenador en algun momento.
http://www.slackware.com/
pág. 23
GENTOO.-Esta distribución es una de las unicas que incorporaron un
concepto totalmente nuevo en Linux. Es una sistema inspirado en BSDports. Podeis compilar/optimizar vuestro sistema completamente
desde cero. No es recomendable adentrarse en esta distribucion sin
una buena conexion a internet, un ordenador medianamente potente
(si quereis terminar de compilar en un tiempo prudencial) y cierta
experiencia en sistemas Unix.
http://www.gentoo.org/
KUBUNTU.-Distribución basada en Ubuntu, con lo que esto conlleva y
centrada en el usuario final y facilidad de uso. La gran diferencia con
Ubuntu es que el entorno de escritorio por defecto es KDE.
http://www.kubuntu.org/
MANDRIVA.-Esta distribución fue creada en 1998 con el objetivo de
acercar el uso de Linux a todos los usuarios, en un principio se llamo
Mandrake Linux. Facilidad de uso para todos los usuarios.
http://www.mandrivalinux.org/
pág. 24
Estándar de Jerarquía de Sistema de Archivos.
Introducción.
El estándar de jerarquía de archivos (FHS o Filesystem Hierarchy Standard) define los principales
directorios y sus contenidos en GNU/Linux y otros sistemas operativos similares a Unix.
En agosto de 1993 inició un proceso para desarrollar un estándar de sistema de archivos
jerárquico, como un esfuerzo para reorganizar las estructuras de archivos y directorios de
GNU/Linux. El 14 de Febrero de 1994 se publicó el FSSTND (Filesystem Standard), un estándar de
jerarquía de archivos específico para GNU/Linux. Revisiones de éste se publicaron el 9 de Octubre
de 1994 y el 28 de Marzo de 1995.
A principios de 1996, con la ayuda de miembros de la comunidad de desarrolladores de BSD, se
fijó como objetivo el desarrollar una versión de FSSTND más detallada y dirigida no solo hacia
Linux sino también hacia otros sistemas operativos similares a Unix. Como uno de los resultados
el estándar cambió de nombre a FHS o Filesystem Hierarchy Standard.
El FHS es mantenido por Free Standards Group, una organización sin fines de lucro constituida
por compañías que manufacturan sustento físico (Hardware) y equipamiento lógico (Software)
como Hewlett Packard, Dell, IBM y Red Hat. La mayoría de las distribuciones de Linux, inclusive
las que forman parte de Free Software Standards, utilizan este estándar sin aplicarlo de manera
estricta.
La versión 2.3 del FHS, que es la utilizada por CentOS, Fedora™, Red Hat™ Enterprise Linux,
openSUSE™ y SUSE™ Linux Enterprise, fue anunciada el 29 de enero de 2004.
Estructura de los directorios general
En el sistema de ficheros de UNIX (y similares), existen varias “sub-jerarquías” de directorios que
poseen múltiples y diferentes funciones de almacenamiento y organización en todo el sistema.[1]
Estos directorios pueden clasificarse en:
Estáticos: Contiene archivos que no cambian sin la intervención del administrador (root), sin
embargo, pueden ser leídos por cualquier otro usuario. (/bin, /sbin, /opt, /boot, /usr/bin...)
Dinámicos: Contiene archivos que son cambiantes, y pueden leerse y escribirse (algunos
sólo por su respectivo usuario y el root). Contienen configuraciones, documentos, etc. Para
pág. 25
estos directorios, es recomendable una copia de seguridad con frecuencia, o mejor aún,
deberían ser montados en una partición aparte en el mismo disco, como por ejemplo,
montar el directorio /home en otra partición del mismo disco, independiente de la partición
principal del sistema; de esta forma, puede repararse el sistema sin afectar o borrar los
documentos de los usuarios. (/var/mail, /var/spool, /var/run, /var/lock, /home...)
Compartidos: Contiene archivos que se pueden encontrar en un ordenador y utilizarse en
otro, o incluso compartirse entre usuarios.
Restringidos: Contiene ficheros que no se pueden compartir, solo son modificables por el
administrador. (/etc, /boot, /var/run, /var/lock...)
Estructura de Archivos
Existe una estructura de archivos estándar FHS (Filesystem Hierarchy Standard) El estándar de
jerarquía de archivos que es un conjunto de recomendaciones orientadas a la compatibilidad de
aplicaciones, herramientas de administración y desarrollo entre distintos sistemas. Esta es una de
las estructuras de archivos que deja la instalación por defecto de CentOS
Pero esa estructura tiene ventajas tales como:
•
Permitir al software conocer la ubicación de directorios y archivos instalados; Permitir al
software conocer donde se deben instalar los archivos de un programa
•
Permitir al usuario conocer dónde encontrar los archivos y directorios de los programas
instalados. En un sistema que cumpla con las especificaciones del FHS, los directorios del
sistema de archivos raíz o "/", deben ser suficientes para arrancar, reparar y/o recuperar
el sistema.
Los siguientes directorios son necesarios en el directorio raíz o "/":
En este directorio están los ficheros ejecutables básicos (bin = binarios) Directorio /boot
Aquí están los ficheros y directorios de arranque (boot) Directorio /dev
Contiene ficheros de dispositivos. Directorio /etc
Contiene ficheros y directorios de configuración específicos de tu sistema.
pág. 26
Ilustración 7 Contenido del directorio /etc
Directorio /bin: En este directorio están los ficheros ejecutables básicos (bin = binaries)
Directorio /boot: Aquí están los ficheros y directorios de arranque (boot)
Directorio /dev: Contiene ficheros de dispositivos.
Directorio /etc: Contiene ficheros y directorios de configuración específicos de tu sistema.
Directorio /home: Contiene los archivos utilizados por el usuario, documentos, escritorio,
descargas, etc.
Directorio /lib: Bibliotecas compartidas esenciales para los binarios de /bin/, /sbin/ y el
núcleo del sistema.
Directorio /lost+found: Directorio especifico para archivos perdidos. Cada partición tiene
el suyo propio independientemente.
Directorio /media: Puntos de montaje para dispositivos de medios como unidades lectoras
de discos compactos.
Directorio /misc: Abreviación de miscelánea.
Directorio /mnt: Sistemas de ficheros montados temporalmente.
Directorio/opt: En este directorio se suelen almacenar todos los archivos de una
instalación fuera de los repositorios como puede ser cuando instalamos un .deb
Directorio/proc: Directorio que contiene información sobre diferentes partes del sistema,
cpu, discos, tiempo uptime, irqs, memoria, etc
Directorio/root: Directorio particular del superusuario del sistema ( root )
Directorio/sbin: Contiene archivos ejecutables que por lo general son comandos usados
para la administración del sistema.
Directorio /srv: Es un directorio que contiene datos específicos que son servidos por el
sistema servidor (SeRVer).
Directorio /sys: Contiene parámetros de configuración del sistema que se está ejecutando.
pág. 27
Datos referidos al kernel, bus, dispositivos, firmware, fs (filesystem) y otros.
Directorio /tmp: Directorio donde se almacenan los ficheros temporales. Son ficheros que
se eliminan con el apagado del sistema.
Directorio /usr: Este es el espacio compartido de todos los usuarios del sistema. Aquí se
guardan los datos compartidos de usuarios: aplicaciones, librerías, manuales, etc.
Directorio /var: Contiene los datos que están cambiando continuamente en el sistema
como ficheros de log del sistema, correo, colas de impresión, etc.
El diseño predeterminado del instalador de CentOS, Fedora™ y Red Hat™ Enterprise Linux utiliza
4 particiones:
Partición
Descripción
/boot
Requiere de 200 MiB a 512 MiB.
/
Si se utiliza el diseño de tres particiones, asignar el resto
del espacio disponible en la unidad de almacenamiento.
Si se van asignar particiones para los directorios
mencionados adelante, se requieren de 3072 MiB a 5120
MiB.
/home
En estaciones de trabajo, a esta partición se asigna al
menos la mitad del espacio disponible para
almacenamiento.
Memoria
de Memoria diseñada para el intercambio de información
cuando la memoria ram es insuficiente.
intercambio (Swap)
Los siguientes directorios jamás deberán estar fuera de la partición que corresponda a /, es decir,
“jamás se deben asignar como particiones separadas”:
/etc
/bin
/dev
/lib y /lib64
/media
/mnt
/proc
/root
pág. 28
/sbin
/sys
Para futuras versiones de CentOS, el directorio /var también deberá estar dentro de la misma
partición que corresponda a /, pues el proceso de arranque, que será gestionado por Systemd, así
lo requerirá.
Otras particiones que se recomienda asignar, son:
Partición
Función
/usr
Requiere al menos 3072 MiB en instalaciones básicas. Debe
considerarse el equipamiento lógico se planee instalar a futuro. Para
uso general se recomiendan al menos de 5120 MiB, y, de ser posible,
considere un tamaño óptimo de hasta 20480 MiB.
/tmp
Requiere al menos 350 MiB y puede asignarse hasta 5 GiB o más,
dependiendo de la carga de trabajo y del tipo de aplicaciones. Si, por
ejemplo, el sistema cuenta con un grabador de DVD, será necesario
asignar a /tmp el espacio suficiente para almacenar una imagen de
disco DVD, es decir, al menos 4.2 GiB, asumiendo que es de una sola
cara y de densidad simple. Algunas distribuciones de vanguardia
utilizan un disco RAM —es decir un RAM disk— para este directorio
con la finalidad de mejorar el rendimiento del sistema.
/var
Requiere al menos 3072 MiB en estaciones de trabajo sin servicios.
En servidores regularmente se le asigna al menos la mitad del
espacio disponible para almacenamiento.
/usr/local
Requiere al menos 3072 MiB en instalaciones básicas. Debe
considerarse el equipamiento lógico que se planee compilar desde
código fuente, e instalar, a futuro. Al igual que /usr, para uso general
se recomiendan al menos de 5120 MiB, y, de ser posible, considere
un tamaño óptimo de hasta 20480 MiB.
/opt
Requiere al menos 3072 MiB en instalaciones básicas. Debe
considerarse el equipamiento lógico de terceros que se planee
instalar a futuro. Al igual que /usr, para uso general se recomiendan
al menos de 5120 MiB, y, de ser posible, considere un tamaño
óptimo de hasta 20480 MiB.
pág. 29
Partición
Función
/var/lib
Si se asigna como partición independiente de /var, lo cual permitiría
optimizar el registro por diario utilizando el modo journal para un
mejor desempeño, requiere al menos 3072 MiB en instalaciones
básicas. Deben considerarse las bases de datos o directorios de
LDAP, que se planeen hospedar a futuro. Recuerde que LDAP es
capaz de mandar mensajes a nivel de PING, de igual manera que es
usado para actualizar el cache de la librería del software.
/var/www o Dependiendo del sistema operativo utilizado, el directorio raíz del
servidor HTTP Apache puede encontrarse dentro de dos diferentes
/srv/www
rutas. CentOS, Fedora™ y Red Hat™ Enterprise Linux utilizan
/var/www, mientras que openSUSE™ y SUSE™ Linux Enterprise
utilizan /srv/www. Asignar como partición independiente cualquiera
de éstos directorios permite optimizar el registro por diario —
utilizando el modo writeback— para mejorar el desempeño.
Requiere al menos 3072 MiB en instalaciones básicas. Deben
considerarse los anfitriones virtuales, aplicaciones y contenido para
ser servido a través del protocolo HTTP, que se planeen hospedar a
futuro.
Instalacion Centos
CentOS es una distribución Linux de clase empresarial derivado de fuentes libremente ofrecidos
al público por un destacado proveedor de América del Norte Enterprise Linux. CentOS se ajuste
plenamente a la política de redistribución del proveedor de aguas arriba y aspira a ser 100%
compatible a nivel binario. (CentOS principalmente cambia los paquetes para eliminar marcas
comerciales del proveedor y obras de arte.) CentOS es gratuito. CentOS es desarrollado por un
equipo pequeño pero creciente número de desarrolladores del núcleo. A su vez, los
desarrolladores principales están respaldados por una activa comunidad de usuarios como los
administradores de sistemas, administradores de redes, los usuarios empresariales, gerentes,
colaboradores principales de Linux y los entusiastas de Linux de todo el mundo. CentOS tiene
numerosas ventajas sobre algunos de los proyectos de otros clones, incluyendo: una activa y la
creciente comunidad de usuarios, reconstruida rápidamente, probado y QA'ed paquetes de
erratas, una extensa red de servidores espejos , los desarrolladores que están tocados y de
respuesta, múltiples vías de apoyo gratuitos, como un Chat IRC , listas de correo , Foros , una
pág. 30
dinámica de preguntas frecuentes . Este sitio hace uso de Javascript. Si su navegador no funciona
con JavaScript, le recomendamos que use Firefox.
Introducción
Bienvenidos a la versión 6.5 de CentOS, una Distribución Linux de Rango Empresarial obtenida a
partir de los fuentes puestos a libre disposición del público por nuestro Proveedor de OS
(Upstream OS Provider , UOP).
CentOS se adapta completamente a la política de redistribución de nuestro proveedor y aspira a
ser 100% compatible con sus binarios (CentOS principalmente modifica los paquetes para eliminar
la marca y el diseño gráfico original).
Hemos decidido no imitar la utilización que hace el UOP de los Códigos de Instalación. Todos los
canales están a disposición del administrador del sistema en el momento de la instalación.
Siguiendo la práctica del proveedor original de los fuentes, no hay soporte para actualizar la
instalación desde una versión principal anterior de CentOS (en estos momentos CentOS 5 o
CentOS 4) a una versión posterior. Esto no es una limitación impuesta por CentOS, sino que refleja
la postura del proveedor en esta cuestión.
Quienes se sientan aventureros y quieran experimentar, que no olviden hacer y comprobar
previamente una copia de respaldo. Como aviso para aquellos que intenten la actualización a
pesar de esta advertencia, por ejemplo mediante la no soportada opción upgreadeany utilizando
la línea de comandos del medio de instalación, por favor, tengan en cuenta que necesitarán
recuperar manualmente el paquete centos-release actual, hacer manualmente un rpm -e nodeps
para eliminar el paquete centos-release anterior, y entonces instalar manualmente el paquete
centos-release de CentOS 6, pues de lo contrario yum no tendría ninguna posibilidad de funcionar
correctamente.
PROCEDIMIENTO
Al hacer boot se nos dan 2 opciones para instalar, la primera el sistema detectara la tarjeta de
vídeo y entrara en modo gráfico (lo cual a veces falla) por lo tanto recomiendo elegir la segunda
opción; la cual carga un driver básico de vídeo que diría que todos los equipos reconocen sin
problemas. Presionamos Enter
pág. 31
-Podemos verificar si nuestro DVD o instalación de USB están OK. Si ya lo hicimos o
estamos seguros, damos Enter en Skip
pág. 32
ENTORNO GRAFICO:
Vamos a iniciar la instalación del sistema operativo, damos clic en next
Seleccionamos el idioma
pág. 33
Seleccionamos la distribución del teclado
Damos en la opción Basic que aparece por defecto
pág. 34
Damos en la opción no conservar datos, puesto que tenemos un espacio ya designado en
el disco para la instalación
Le asignamos el nombre a nuestro servidor (Dominio)
pág. 35
Verificamos que el DHCP este marcada la casilla conectar automático
Seleccionamos el área o región para los usos horarios
pág. 36
Asignamos una contraseña para nuestro administrador root
«Usar todo el espacio» eliminará cualquier partición de cualquier otro sistema operativo
presente y creará de forma automática las particiones necesarias.
«Reemplazar sistema(s) Linux existente(s)» sólo eliminará todas las particiones Linux
existentes y creará de forma automática las particiones necesarias.
«Achicar el sistema actual» cambiará el tamaño de las particiones existentes de otros
sistemas operativos como Windows, haciendo el espacio necesario para poder instalar un
diseño predeterminado de particiones Linux.
«Usar espacio libre» creará de forma automática las particiones necesarias en el espacio
disponible, basándose sobre un diseño predeterminado.
«Crear un diseño personalizado» permitirá elegir las particiones estándar o volúmenes
lógicos, que uno requiera.
pág. 37
Seleccionamos crear un diseño personalizado, para asignarle los porcentajes a las carpetas
del sistema manualmente
En esta imagen muestra que tenemos 50 GB de espacio disponible, lo distribuiremos de la
siguiente forma: el 50% lo dividimos para las carpetas (/) y (home). Y el 50% restante lo dividimos
en 6 para las demás carpetas, EJEMPLO
pág. 38
Seleccionamos crear partición estándar y le asignamos el porcentaje
pág. 39
Le damos en formatear
pág. 40
Elegimos la opción que necesitemos, en este caso servidor básico y seleccionamos la opción
personalizar ahora para seleccionar los paquetes a instalar
pág. 41
pág. 42
Esperamos que carguen los archivos de la instalación
pág. 43
Reiniciamos
Conceptos importantes, hay que recordar que siempre hay que distinguir los distintos
dispositivos en las instalaciones:
/dev = dispositivo
/sda = disco duro
/st0 = dispositivo de cinta grabable
/nst0 = dispositivo de cinta en modo no regrabable
Y los tipos de particiones, anteriores, actuales y los mas importantes:
ext2 - Second Extended Filesystem es un consolidado y maduro sistema de archivos para
GNU/Linux muy estable. Uno de sus inconvenientes es que no tiene apoyo para el registro
(journaling) (véase más abajo) o las barreras. La falta de registro por diario («journaling») puede
traducirse en la pérdida de datos en caso de un corte de corriente o fallo del sistema. También
puede no ser conveniente para las particiones root (/) y /home, porque las comprobaciones del
sistema de archivos pueden tomar mucho tiempo.
Un sistema de archivos ext2 puede ser convertido a ext3.
ext3(soporta Jornaling) - Third Extended Filesystem es, esencialmente, el sistema de archivos
ext2 pero con el apoyo de journaling y la escritura de barreras. Es compatible con ext2, bien
probado, y extremadamente estable.
ReiserFS(soporta Jornaling) - Sistema de archivos con journaling y altas prestaciones de Hans
Reiser (V3) que utiliza un método muy interesante de transferencia de datos basado en un
algoritmo creativo e innovador. ReiserFS es anunciado como muy rápido, especialmente cuando
se trata de muchos archivos pequeños. ReiserFS es rápido en dar formato, sin embargo,
comparativamente lento en el montaje. Muy maduro y estable. ReiserFS (V3) no está siendo
activamente desarrollado en este momento. Generalmente considerado como una buena opción
para /var.
XFS (soporta Jornaling) - Primeros sistemas de archivos con journaling desarrollado
originalmente por Silicon Graphics para el sistema operativo IRIX y portado después a
GNU/Linux. Proporciona un rendimiento muy rápido en los archivos y sistemas de archivos
grandes y es muy rápido en el formato y montaje. Pruebas de benchmark comparativa han
demostrado que es más lento cuando trata con muchos archivos pequeños. XFS es muy maduro
pág. 44
y ofrece capacidad de desfragmentación en línea, además este permite soporte para ACLs sin
opciones de montado especial.
Felicidades Tu Servidor ha sido instalado de manera satisfactoria!!!!
Hay que tener en cuenta la importancia de recordar lo siguiente:
1. Para que vamos a utilizar nuestro servidor, es decir para administración de páginas
web, administración de puntos de venta, administración corporativa, etc.
2. El ciclo de vida que manejaremos dependiendo del tipo de instalación que tendremos y
el cual es vital para este punto.
3. El Hardware que se maneja y el volumen de usuarios a los cuales se les dara soporte
con este.
Una vez terminando de instalar el servidor por ahora solo hacermos una corrección al server para
poder tener salida a internet y este es realizando una corrección al archivo que esta ubicado en
la siguiente ruta
Vi /etc/sysconfig/network-scripts/ifcfg-eth0
Lo cual nos abrirá un archive con la siguiente estructura:
DEVICE="eth0"
NM_CONTROLLED="yes"
ONBOOT="yes"
HWADDR=08:00:27:89:15:BE
TYPE=Ethernet
BOOTPROTO=dhcp
La opción ONBOOT, debe estar en no, con la tecla i, podremos insertar la modificación, entrares
y lo modificaremos a “yes” y saldremos del archivo con “:wq” y reiniciaremos el sistema.
Tenga cuidado de no modificar nada mas en el archivo pues no tendrá acceso a internet.
pág. 45
Editor de texto VI y VIM
Vi (Visual) es un programa informático que entra en la categoría de los editores de texto. Pues a
diferencia de un procesador de texto no ofrece herramientas para determinar visualmente cómo
quedará el documento impreso. Por esto carece de opción como centrada o justificación de
párrafos, pero permite mover, copiar, eliminar o insertar caracteres con mucha versatilidad. Este
tipo de programas es frecuentemente utilizado por programadores para escribir código fuente de
software.
Vi fue originalmente escrito por Bill Joy en 1976, tomando recursos de ed y ex, dos editores de
texto para Unix, que trataban de crear y editar archivos, de ahí, la creación de vi.
Hay una versión mejorada que se llama Vim, pero Vi es un editor de texto que se encuentra en —
casi— todo sistema de tipo Unix, de forma que conocer rudimentos de Vi es una salvaguarda ante
operaciones de emergencia en diversos sistemas operativos.
Vim (del inglés Vi IMproved) es una versión mejorada del editor de texto vi, presente en todos los
sistemas UNIX.
Su autor, Bram Moolenaar, presentó la primera versión en 1991, fecha desde la que ha
experimentado muchas mejoras. La principal característica tanto de Vim como de Vi consiste en
que disponen de diferentes modos entre los que se alterna para realizar ciertas operaciones, lo
que los diferencia de la mayoría de editores comunes, que tienen un solo modo en el que se
introducen las órdenes mediante combinaciones de teclas o interfaces gráficas.
La mejor forma de entender estos conceptos es simplemente usando vi para editar un archivo de
prueba.
La sintaxis para vi es: vi
Nombrearchivo
donde nombrearchivo es el nombre del archivo que quieres editar.
Así se inicia el editor y, como el fichero no existe todavía, lo crea para ser editado. El editor está
ahora en modo de comandos esperando por un comando.
Partamos vi tipeando [xxx]%
vi prueba
Ejemplo
pág. 46
lo cual editará el archivo prueba. Deberías ver algo como esto:
~
~
~
~
~
~
"prueba" [New file]
para comenzar a insertar texto usa la tecla i
Mientras estés insertando texto, puedes tipear cuantas líneas quieras (presionando [Enter]
después de cada una, por supuesto), y puedes corregir los errores.
Para finalizar el modo de edición, y volver al modo de comandos, presiona [esc]. Mientras estés
en modo de comandos, puedes usar las teclas de flechas para moverte
por todo el archivo. Aquí, como tenemos solo una línea de texto, al tratar de usar las
flechas para subir y para bajar vi hará un pitido.
Las siguientes teclas controlar el movimiento del cursor.
k arriba
j abajo
h izquierda
l derecha
Modo de entrada de texto (añadir, insertar)
a añade texto a partir del carácter en que está situado el cursor i inserta texto a partir de la
posición del cursor
o inserta una línea debajo de la posición del cursor
O inserta una línea encima de la posición del cursor
pág. 47
Borrando y cambiando texto
Los cinco comandos más utilizados para alterar el texto son x borra el carácter en el cursor
r sustituye el carácter en el cursor
dd borra la línea en la que está el cursor
:s/palabrainicial/palabrafinal/c cambia de a una de las coincidencias
:s/palabrainicial/palabrafinal/g cambia todas las coincidencias
Estos cinco comandos son ejecutados en el modo de comandos, y vuelven al modo de comandos
después de ejecutarse.
Deshaciendo cambios
Hay veces que se realizan cambios y nos damos cuenta inmediatamente que hemos cometido un
error. El editor vi facilita mecanismos para deshacer acciones de comandos previos.
El comando u deshace el comando previo.
El comando U deshace todos los cambios realizados en la línea actual.
Guardando cambios y permaneciendo en vi
Es muy recomendable guardar los cambios que se van realizando de una forma regular. Para ello
se utiliza
:w
Si decides que no quieres sobrescribir el fichero que estás editando, sino que quieres guardar los
cambios como un fichero nuevo, añade al comando :w el nombre del nuevo fichero,
:w nuevo_fichero2
Abandonando vi
Para dejar vi se utiliza;
ZZ Guarda los cambios en el fichero original, y vuelve al intérprete de comandos
pág. 48
:wq Igual que ZZ
:q! Abandona el editor, no guarda los cambios, y vuelve al intérprete de comandos
Comandos adicionales para posicionamiento del cursor
Además de las teclas h, j, k, l existen cuatro más:
b mueve el cursor al comienzo de la palabra anterior e mueve el cursor al final de la palabra
siguiente
0 mueve el cursor al comienzo de la línea (cero)
$ mueve el cursor al final de la línea
Los comandos para avanzar una pantalla arriba y abajo (12 líneas) son control-d una pantalla
abajo control-u una pantalla arriba
Para ficheros muy largos, se puede ir a una línea del texto 3000G a a la línea número 3000
Para posicionar el curso en la última línea del fichero, teclea /G/
Para posicionar el cursor al comienzo del fichero, teclea 1G
El siguiente comando muestra el número de línea actual control-g
Búsqueda
Otro método de posicionarse dentro de un fichero es buscando una cadena de caracteres. En el
modo de comandos, cualquier cadena de caracteres precedida por / significa el comando de
búsqueda hacia adelante. El cursor se posiciona en la primera ocurrencia de dicha cadena.
El comando n busca hacia adelante la siguiente ocurrencia. Para buscar hacia atrás, se utiliza el
comando?
Borrar texto
Ya se vio anteriormente el comando dd para borrar la línea actual.
El comando dw borra la palabra actual. Nótese que el comando de borrado comienza por d,
pág. 49
seguido por el ámbito de aplicación (d para una línea, w para una palabra (word en inglés)).
Quitar y poner
Cuando se borra algo, es almacenado en un buffer temporal. El contenido de este buffer puede
ser accedido y 'puesto' o pegado en cualquier sitio del texto.
Para recuperar el último texto borrado, se usa el comando p
Resumen y algo mas
El presente editor consta de diferentes comandos, los cuales se dan a conocer en el siguiente
resumen:
vi [archivo].
Movimientos básicos:
=> Un espacio a la izquierda. j => Una línea hacia abajo.
k => Una línea hacia arriba.
l => Un espacio a la derecha.
$ => Mueve al final de la línea actual.
+ => Comienzo de la línea siguiente.
- => Comienzo de la línea anterior. 0 => Comienzo de la línea actual.
Control de despliegue:
CTRL-d => Deslizar hacia adelante.
CTRL-u => Deslizar hacia atrás.
CTRL-f => Pantalla siguiente.
CTRL-b => Pantalla anterior
CTRL-l => Redibuja la pantalla.
G => Moverse al final del archivo.
Comandos para agregar textos:
A => A final de la línea. i => Antes del cursor.
I => Al principio de la línea.
O => Abre una línea por encima. O
pág. 50
=> Abre una línea por debajo.
Comandos para eliminar y cambiar texto:
dd => Elimina línea.
cc => Cambiar línea.
D => Elimina hasta el final de línea.
C => Cambiar hasta final de línea
x => Elimina el carácter del cursor.
r => Cambia el carácter del cursor.
Comandos sobre palabras:
cw => Cambiar palabra.
dw => Elimina palabra.
:s/palabrainicial/palabrafinal/c cambia de a una de las incidencias
:s/palabrainicial/palabrafinal/g cambia todas las incidencias
e => Mueve cursor a final de palabra.
w => Mueve cursor a siguiente palabra.
Comandos de búsqueda:
/ => Búsqueda hacia adelante.
? => búsqueda hacia atrás.
n => Siguiente ocurrencia.
N => Posterior ocurrencia.
:set nu => mostrar números de línea
Comandos de edición avanzada:
u => Deshacer cambio más reciente.
U => Recupera todos los cambios de una línea.
p => Coloca el contenido del buffer a la derecha del cursor.
P => Coloca el contenido del buffer a la izquierda del cursor.
y => Copia los carácteres comenzando en el cursor en el buffer.
Y => Copia la línea actual completa en el buffer.
pág. 51
Comandos de control:
:w => Guarda sin salir.
:wq => Guarda y sale.
:q => Abandona si no hay modificaciones.
:q! => Abandona aún con los cambios.
:número => Ir a la línea número.
ZZ => Guarda y sale.
Otros
J
unir dos líneas en una
C
reemplaza caracteres
C o c$
reemplaza hasta el fin de línea
c0
reemplaza desde el comienzo de línea
BS
borrar caracter hacia la izquierda
:set
cambio de opciones
:set nonu no mostrar números de línea
:set showmode mostrar modo actual de vi
:set noshowmode no mostrar modo actual de vi
Nota: Los comandos en mayúsculas y minúsculas alteran el resultado (cuidado)
Para volver de nuevo al Modo de Comandos, lo cual es necesario, por ejemplo, para mover el
cursor, presiona la tecla de escape o <esc>. Si no recuerdas en qué modo estás presiona <esc>: si
estabas en Modo de Inserción, ahora pasas al Modo de Comandos; si estabas en Modo de
Comandos, vi emitirá un pitido y te dejará en Modo de Comandos.
Un editor de texto es simplemente un programa que se usa para editar ficheros que contengan
texto. Aunque hay muchos editores disponibles, el único que vas a encontrar seguro en todos los
sistemas UNIX es vi (el "editor visual").
Existe un editor vi ampliado llamado vim que contiene facilidades adicionales, así como diversas
versiones del vi original. En todos los casos, el conjunto de comandos básicos es el mismo.
pág. 52
Ejercicio:
Instala VI y VIM
Generamos un usuario nuevo y que no tenga privilegios:
# useradd –m pruebavi
Asignamos un password a nuestro usuario
# passwd pruebavi
Nos cambiamos al usuario
# su –l pruebavi
Creamos un documento nuevo con el comando vim
$ vim nuevo.txt
~
~
~
~
~
~
"nuevo.txt" [New file]
Una vez abierto el documento presionamos la tecla i para insertar texto nuevo
~
~
~
~
~
-INSERTUna vez que presiones i, aparecerá insertar en la interface, esto indica que podemos editar el
archivo creado, una vez hecho esto escribiremos la frase Linux el mejor sistema y pulsamos enter,
a continuación escribiremos “El megor sistema que conosco” este texto tiene errores
ortográficos, escríbalo de manera errónea pues el ejercicio es para realizar dichas correcciones
utilizando el editor VIM.
pág. 53
~Linux el mejor sistema
~El megor sistema que conosco
~
~
~
-INSERTAhora posicionese sobre la malabra “megor” sobre la letra g y presione shift + r y acontinuacion
aparecerá la opción remplazar, pulse la letra “j” y observe como se reemplaza por la letra g, repita
el procedimiento y corrija la letra z por la s en la palabra “conosco”
~ Linux el mejor sistema
~ El megor sistema que conosco
~
~
~
~
-REMPLAZARPrecione la tecla “Esc” seguido de : y la letra “w” para guardar los cambios.
~ Linux el mejor sistema
~ El mejor sistema que conozco
~
~
~
~
:w
Al pulsar enter notara un mensaje que dice que los cambios han sido realizados.
Vuelva a pulsar: (dos puntos) y luego escriba otro.txt pulse enter y ahora notara que se guardo el
archivo con el nombre otro.txt
~ Linux el mejor sistema
~ El mejor sistema que conozco
~
~
~
pág. 54
~
"otro.txt" [New file]
Vuelva a pulsar i, de nuevo aparecerá el mensaje de – INSERTAR –
~ Linux el mejor sistema
~ El mejor sistema que conozco
~
~
~
~
-INSERTEscriba lo siguiente:
~ Linux el mejor sistema
~ El mejor sistema que conozco
~Hoy es un dia aburrido
~conozco solo gente aburrida
~mi novia es muy aburrida
~
-INSERTAhora pulse esc, seguido pulse: (dos puntos) y por ultimo escriba lo siguiente:
%s/aburrid/divertid/g
~ Linux el mejor sistema
~ El mejor sistema que conozco
~Hoy es un dia aburrido
~conozco solo gente aburrida
~mi novia es muy aburrida
~
%s/aburrid/divertid/g
Pulse enter y observara lo siguiente:
~ Linux el mejor sistema
~ El mejor sistema que conozco
~Hoy es un dia divertido
pág. 55
~conozco solo gente divertida
~mi novia es muy divertida
~
3 sustituciones en 3 lineas
En este ejercicio, el símbolo % indicaba que se aplicaría un procedimiento a todo el archivo,
además de la línea misma, la letra «s» indicaba que se realizaría la búsqueda de la cadena de
caracteres «mal» definida después de la diagonal (/) por la cadena de caracteres «aburrid» en
toda la línea, indicado por la letra «g».
A continuación, posiciones el cursor de teclado utilizando las flechas del teclado hasta el primer
carácter de la primera línea:
~Linux el mejor sistema
~El mejor sistema que conozco
~Hoy es un dia divertido
~conozco solo gente divertida
~mi novia es muy divertida
~
Pulsamos la letra d en dos ocaciones para ver como se elimina la primera línea del archivo
~El mejor sistema que conozco
~Hoy es un dia divertido
~conozco solo gente divertida
~mi novia es muy divertida
~
Ahora pulsamos la tecla p para pegar la línea
~El mejor sistema que conozco
~Hoy es un dia divertido
~conozco solo gente divertida
~mi novia es muy divertida
~Linux el mejor sistema
~
En este caso usted podrá ver que se pega debajo del texto o donde tenga el cursor, lo cual quiere
decir que hay que posicionarse en la línea correcta para pegar lo copiado
Ahora posiciónese en la primera línea del texto y va a oprimir 3 y después dd y podra observar
pág. 56
como se copiaron ahora las 3 lineas consecutivas a partir de donde esta posicionado el texto y
podra pegar de la misma manera
~conozco solo gente divertida
~mi novia es muy divertida
~
Ahora vuelva a pulsar p y se restauran las tres líneas principales pero si pulsamos p de nueva se
volverán a pegar las líneas copiadas esto podría pasar n cantidad de veces según sea el caso
~conozco solo gente divertida
~mi novia es muy divertida
~Linux el mejor sistema
~El mejor sistema que conozco
~Hoy es un dia divertido
~Linux el mejor sistema
~El mejor sistema que conozco
~Hoy es un dia divertido
~Linux el mejor sistema
~El mejor sistema que conozco
~Hoy es un dia divertido
~
Ahora procedemos a salir del archivo guardando los datos, pulsaremos: wq seguido de enter
~conozco solo gente divertida
~ mi novia es muy divertida
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~
: wq
pág. 57
Vuelva a editar el archivo pulsando vi nuevo.txt y pulsaremos : /divertid y veremos como se raliza
una búsqueda sombreando las cadenas de coincidencias.
~conozco solo gente divertida
~ mi novia es muy divertida
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~Hoy es un dia divertido
~
/divertid
Para cancelar el resaltado de los resultados, pulse la combinación de teclas: nohl:
Si pulsamos shift + a, se realizara la inserción, pero al final de la línea.
Pulse Esc y seguido la tecla de la letra “o” y observara como se inicializa la función insertar pero
en una nueva línea.
~ conozco solo gente divertida
~ mi novia es muy divertida
~
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
pág. 58
~ Hoy es un dia divertido
~
-INSERTPulse nuevamente la tecla <Esc> y en seguida la combinación dG (d, luego SHIFT+G). Notará que
elimina todo el contenido del texto desde la posición del cursor hasta el final del archivo:
~conozco solo gente divertida
~mi novia es muy divertida
~
9 lineas menos
Precione: u y observara como se cancela la modificación hecha:
~ conozco solo gente divertida
~ mi novia es muy divertida
~
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~ Linux el mejor sistema
~ El mejor sistema que conozco
~ Hoy es un dia divertido
~
9 Lineas más
Una vez verificado esto guardamos el archivo y salimos de la edición.
Para mayor información revisar la documentación y la orientación de comandos incluida en este
manual sobre VI.
Ajustes y Optimizacion del Servidor.
A partir de este momento se pretende realizar un checklist con los puntos importantes a
pág. 59
configurar en el server para ponerlo a punto para cualquier entrega.
Localización
La internacionalización es el proceso de diseñar software de manera tal que pueda adaptarse a
diferentes idiomas y regiones sin la necesidad de realizar cambios de ingeniería ni en el código.
La localización es el proceso de adaptar el software para una región específica mediante la adición
de componentes específicos de un locale y la traducción de los textos, por lo que también se le
puede denominar regionalización. No obstante la traducción literal del inglés es la más
extendida.1
Es una práctica común en el idioma inglés (sobre todo en el ámbito de la computación),
abreviar internationalization con elnumerónimo "i18n". Ello se debe a que entre la primera i y la
última ene de dicha palabra hay 18 letras. Lo mismo sucede con localization, que se abrevia
"L10n". La L mayúscula se utiliza para distinguirla de la i minúscula de i18n.
Algunas empresas, como Microsoft e IBM, usan el término globalización para referirse a la
combinación de internacionalización y localización. Globalización puede también abreviarse con
el numerónimo "g11n".
Internacionalización y localización son dos de los conceptos más en boca en la moderna industria
del lenguaje.
La localización del sistema se logra mediante la edición de 2 archivos localizados en las rutas:
/etc/sysconfig/i18n:
/boot/grub/menu.lst
En ambos hay que buscar la configuración LANG="es_ES.UTF-8” y hay que modificarla por
LANG=es_MX.UTF-8
Esto nos dará la virtud de modificar la configuración de español de España por la configuración de
español de México.
pág. 60
Una vez realizada esta tarea se realizara un reincio de sistema para hacer los cambios de manera
permanente con el comando:
#reboot y enter.
Uso de disco de rescate en CentOS 6.5
Esta tarea es el equivalente a tener algun problema con el arranque del sistema o con el server
en comun, por lo cual recurriremos a meter el DVD en la disquetera y bootear desde esta para
realizar las tareas de reparacion o de mantenimiento segun sea el caso
Una vez que booteemos con el DVD nos aparecera la misma interfaz de inicio cuano realizamos la
instalacion la primera vez.
Aqui cambiaremos el IDE secundario maestro y pondermos la imagen
pág. 61
Una vez seleccionado se aceptan los cambios y se inicia la instalación
En esta hay que mover el cursor con las flechas para detener el contador automatico que corre
con un total de 60 segundos, antes de que se realize la seleccion de manera automatica.
pág. 62
Ahora seleccionaremos la opcion numero 3, que indica Rescue installed System, con lo cual
accesaremos a las opciones de rescate de sistema.
Una vez que se realice la deteccion de la media realizara una carga y nos pedira el idioma con el
cual trabajaremos, seleccionaremos español
pág. 63
A continuacion elegiremos el idioma del teclado, el cual es importante para manipulacion de la
consola con la que trabajaremos.
A continuación nos pide que elijamos si vamos a necesitar la configuracion de la tarjeta de red.
pág. 64
Automaticamente nos detectara la tarjeta o tarjetas de red conectadas al servidor.
De ser necesarias se realizan las configuracion con las direcciones necesarias para lograr las
conexiones y poder realizar los respaldos.
pág. 65
Una vez realizada la configuracion nos desplegara las siguientes opciones que nos indican lo
siguiente.
CONTINUAR >> El entorno de rescate intentará encontrar una instalación de GNU/Linux en el
disco duro e intentará montar todas las particiones en el árbol que corresponde, debajo del
directorio /mnt/sysimage. De este modo se podrá acceder en modo lectura y escritura al sistema
de archivos y así poder realizar los cambios o modificaciones que requiera.
MODO LECTURA >> Similar a la opción anterior, pero todo el sistema de archivos se montará en
modo de sólo lectura.
OMITIR >> Se omitirá el montado del sistema de archivos del disco duro. Esta opción es idónea
para realizar reparaciones del sistema de archivos de las particiones, utilizando fsck o bien para
realizar operaciones que requieren que las particiones estén sin montar.
AVANZADO >> Permitirá hacer uso de dispositivos especiales de almacenamiento, como Redes
de Área de Almacenamiento (SAN), es decir FCoE, iSCSI y zFCP.
De este modo seleccionaremos continuar lo cual realizara una deteccion de los dispositivos, y se
realizara el montaje de los directories en el fhs de /mnt/sysimage
pág. 66
Y seleccionaremos continuar:
Una vez realizada esta tarea nos enviara a una nueva interfaz con 3 opciones distintas:
pág. 67
SHELL START SHELL >> Iniciará el intérprete de mandatos, desde el cual podrá trabajar de
modo similar al nivel de ejecución 1 (mono usuario) y tendrá acceso a un conjunto básico de
herramientas de diagnóstico y reparación.
FAKD RUN DIAGNOSTIC >> Ejecutará FirstAidKit, una herramienta que realiza verificación y
reparación, automática de algunos problemas comúnes.
REBOOT REBOOT >>. Reiniciará el sistema.
pág. 68
Seleccionaremos la opcion de Start Shell
Esto nos dejara en la consola de administracion con permisos de Root
La opción de Fakd realizara una tarea de diagnostic y reparacion si es necesaria.
Con la opción reboot se realizara un reincio de sistema.
Una vez realizadas last areas realizaremos el apagado de la maquina y reconfiguraremos el disco
pág. 69
a su estado normal para reiniciar.
Nivel de Ejecución 1 o monousuario
Un sistema operativo monousuario (de mono: 'uno'; y usuario) es un sistema operativo que sólo
puede ser ocupado por un único usuario en un determinado tiempo. Ejemplo de sistemas
monousuario son las versiones domésticas de Windows. Administra recursos de memoria
procesos y dispositivos de las PC'S.
Es un sistema en el cual el tipo de usuario no está definido y, por lo tanto, los datos que tiene el
sistema son accesibles para cualquiera que pueda conectarse.
En algunos sistemas operativos se accede al sistema reproductor de un usuario único que tiene
permiso para realizar cualquier operación. Este es el caso de los sistemas operativos más antiguos
como MS-DOS y algunos más recientes como la serie Windows 95/98/Me de Microsoft o MacOS
(antes de Mac OS X) de Macintosh. En estos sistemas no existe una diferenciación clara entre las
tareas que realiza un administrador del sistema y las tareas que realizan los usuarios habituales,
no disponiendo del concepto de multiusuario, un usuario común tiene acceso a todas las
capacidades del sistema, pudiendo borrar, incluso, información vital para su funcionamiento. Un
usuario malicioso (remoto o no) que obtenga acceso al sistema podrá realizar todo lo que desee
por no existir dichas limitaciones.
pág. 70
Nivel de ejecucion 1 o s (single), es el nivel de ejecucion de monousuario, sin acceso a servicios
de red, este nivel es regularmente utilizado en tareas de mantenimiento del sistema y el usuario
que ejecuta es root, permite reparar problemas en el sistema.
La manera de acceder al sistema en modo monousuario es el siguiente:
Cuando se inicia el sistema lo primero que carga es el grub, donde se encuentran las tablas de
booteo, en caso de tener mas sistemas seria la parte donde se elegiria el sistema a iniciar, en
nuestro caso que solo tenemos un sistemas iniciara un contador de 3 segundo, para lo cual
detendremos este conteo presionando cualquier tecla menos enter, porque esto accesaria al
sistema de manera inmediata:
En este punto seleccionaremos la letra “p” para poder introducer el password del grub que se
pág. 71
ingreso en la instalacion inicial:
Se pone el password:
A continuacion presionaremos la tecla “e” para realizar la edicion del commando de booteo:
pág. 72
Seleccionamos la linea que del kernel de inicio:
Recuerde estas tres funciones del booteo o arranque
Lo primero es que el kernel o nucleo busca y monta el initrd
Linuxrc carga los modulos para montar el file system
El gestor de arranque carga el kernel e inintrd en la memoria.
Editamos esta de igual forma y al final de la linea ponemos un espacio y un numero “1”,
presionamos enter y nos regresara a la lista de configuraciones nuevamente, estando en esta
presionamos b como indica el menu para realizar el booteo:
pág. 73
Y esto nos dara acceso al sistema en nivel monousuario, para realizar las tareas que impliquen
tener este tipo de nivel.
Gestion de memoria Swap
La memoria es uno de los recursos más valiosos que gestiona el sistema operativo. Uno de
los elementos principales que caracterizan un proceso es la memoria que utiliza. Ésta está
lógicamente separada de la de cualquier otro proceso del sistema (excepto los threads de un
mismo proceso que comparten normalmente la mayor parte de la memoria que tienen
asignada). Un proceso no puede acceder, al espacio de memoria asignado a otro proceso, lo
cual es imprescindible para la seguridad y estabilidad del sistema. El direccionamiento es una
parte importante de la gestión de memoria, puesto que influye mucho en la visión del mismo por
parte de un proceso, como en el aprovechamiento del hardware y el rendimiento del sistema.
En Linux, además, un proceso tiene dos espacios de memoria: el espacio de memoria del
usuario, único para ese proceso, y el espacio de memoria del kernel, idéntico en todos los
procesos.
Objetivos del sistema de gestión de memoria:
Ofrecer a cada proceso un espacio lógico propio.
Proporcionar protección entre procesos.
Permitir que los procesos compartan memoria.
pág. 74
Dar soporte a las distintas regiones del proceso.
Maximizar el rendimiento del sistema.
Proporcionar a los procesos mapas de memoria muy grandes.
Espacio de direcciones de un proceso
Conjunto de direcciones a las que hace referencia.
Los espacios de direcciones involucrados en la gestión de la memoria son de tres tipos:
A. Espacio de direcciones físicas. Las direcciones físicas son aquellas que referencian
alguna posición de la memoria física. Se obtienen después de aplicar una
transformación por parte de la MMU (Unidad de Manejo de Memoria).
B. Espacio de direcciones lógicas o virtuales. Las direcciones lógicas son las direcciones
utilizadas por los procesos. Sufren una serie de transformaciones, realizadas por el
procesador (la MMU), antes de convertirse en direcciones físicas.
C. Espacio de direcciones lineales. Las direcciones lineales se obtienen a partir de las
direcciones lógicas tras haber aplicado una transformación dependiente de la
arquitectura. En Linux las direcciones lógicas y lineales son idénticas. En el i386, es
el nombre que reciben las direcciones tras haber aplicado la técnica de segmentación.
En la segmentación, tras haber realizado las correspondientes comprobaciones de
seguridad, se le suma a la dirección lógica una cierta dirección base, obteniendo así
la dirección lineal. A partir del kernel de Linux 2.2.x, las direcciones base de casi todos
los segmentos es 0, y por lo tanto, las direcciones lineales y las lógicas son las mismas.
La unidad de manejo de memoria (MMU) es parte del procesador. Sus funciones son:
a) Convertir las direcciones lógicas emitidas por los procesos en direcciones físicas.
b) Comprobar que la conversión se puede realizar. La dirección lógica podría no tener
una dirección física asociada. Por ejemplo, la página correspondiente a una dirección
se puede haber intercambiada a una zona de almacenamiento secundario
temporalmente.
c) Comprobar que el proceso que intenta acceder a una cierta dirección de memoria
tiene permisos para ello.
En caso de fallo se lanzará una excepción que deberá ser resuelta por el kernel del sistema
operativo. El kernel del sistema operativo está siempre en memoria principal, puesto que si se
intercambia a una zona de almacenamiento secundario, ¿quién sería el encargado de llevarlo a
memoria principal cuándo se produjera un fallo de acceso a memoria?
pág. 75
La MMU se inicializa para cada proceso del sistema. Esto permite que cada proceso pueda usar
el rango completo de direcciones lógicas (memoria virtual), ya que las conversiones de estas
direcciones serán distintas para cada proceso.
En todos los procesos se configura la MMU para que la zona del kernel (el cuarto gigabyte) sólo
se pueda acceder en modo kernel (modo privilegiado). La configuración correspondiente al espacio
de memoria del kernel es idéntica en todos los procesos. Todos los threads de un mismo proceso
también compartirán la configuración del espacio de memoria del usuario.
Para ejecutar un proceso debe estar, al menos en parte, en memoria principal. Subsistema de
Gestión de Memoria (parte del kernel del sistema operativo):
Decide qué procesos residen en memoria principal (al menos una parte).
Maneja parte del espacio de direcciones virtuales que ha quedado fuera.
Controla la cantidad de memoria principal.
Gestiona el intercambio de procesos entre memoria principal y memoria secundaria o
dispositivo de swap.
La memoria se asigna de la siguiente manera:
a. Si se tiene menos de 1Gb de memria ram, se asigna el doble de la cantidad de memoria.
b. Si se tienen mas de 1Gb de memoria ram, se asigna la cantidad de memoria ram mas 2.
pág. 76
Unidad 2.- Administración del Sistema de Archivos.
Ext3 (third extended filesystem o "tercer sistema de archivos extendido") es un sistema de
archivos con registro por diario(journaling). Fue el sistema de archivos más usado
en distribuciones Linux, aunque en la actualidad ha sido remplazado por su sucesor, ext4.
La principal diferencia con ext2 es el registro por diario. Un sistema de archivos ext3 puede
ser montado y usado como un sistema de archivos ext2. Otra diferencia importante es que ext3
utiliza un árbol binario balanceado (árbol AVL) e incorpora elasignador de bloques de disco Orlov.
Ventajas
Aunque su velocidad y escalabilidad es menor que sus competidores, como JFS, ReiserFS o XFS,
tiene la ventaja de permitir actualizar de ext2 a ext3 sin perder los datos almacenados ni tener
que formatear el disco. Tiene un menor consumo de CPU y está considerado más seguro que
otros sistemas de ficheros en Linux dada su relativa sencillez y su mayor tiempo de prueba.
El sistema de archivo ext3 agrega a ext2 lo siguiente:
Registro por diario.
Índices en árbol para directorios que ocupan múltiples bloques.
Límites de tamaño
Ext3 tiene dos límites de tamaño distintos. Uno para archivos y otro para el tamaño del sistema
de archivos entero. El límite del tamaño del sistema de archivos es de 232 bloques
Tamaño del
bloque
Tamaño máximo de los
archivos
Tamaño máximo del sistema de
ficheros
1 KiB
16 GiB
2 TiB
2 KiB
256 GiB
8 TiB
4 KiB
2 TiB
16 TiB
pág. 77
8 KiBlímites 1
2 TiB
32 TiB
Partición Ext4 (fourth extended filesystem ó cuarto sistema de archivos extendido)
Es un sistema de archivos transaccional (en inglésjournaling), anunciado el 10 de
octubre de 2006 por Andrew Morton, como una mejora compatible de ext3. El 25 de
diciembre de2008 se publicó el kernel Linux 2.6.28, que elimina ya la etiqueta de "experimental"
de código de ext4.
Las principales mejoras son:
Soporte de volúmenes de hasta 1024 PiB.
Soporte añadido de extent.
Menor uso del CPU.
Mejoras en la velocidad de lectura y escritura.
Sistema de archivos de gran tamaño
El sistema de archivos ext4 es capaz de trabajar con volúmenes de gran tamaño, hasta
1 exbibyte1 y ficheros de tamaño de hasta 16 TiB.
Extents
Los extents han sido introducidos para reemplazar al tradicional esquema de bloques usado por
los sistemas de archivos ext2/3. Un extent es un conjunto de bloques físicos contiguos, mejorando
el rendimiento al trabajar con ficheros de gran tamaño y reduciendo la fragmentación. Un extent
simple en ext4 es capaz de mapear hasta 128 MiB de espacio contiguo con un tamaño de bloque
igual a 4 KiB.2
Compatibilidad hacia adelante y hacia atrás
Cualquier sistema ext3 existente puede ser montado como ext4 sin necesidad de cambios en el
formato del disco. También es posible actualizar un sistema de archivos ext3 para conseguir las
ventajas del ext4 ejecutando un par de comandos. Esto significa que se puede mejorar el
rendimiento, los límites de almacenamiento y las características de sistemas de archivos ext3 sin
reformatear y/o reinstalar el sistema operativo. Si se requiere de las ventajas de ext4 en un
sistema de producción, se puede actualizar el sistema de archivos. El procedimiento es seguro y
no existe riesgo para los datos (aunque siempre es recomendado hacer un respaldo de la
información crítica). Ext4 usará la nueva estructura de datos sólo para la información nueva. La
estructura antigua será conservada sin modificación y será posible leerla y/o modificarla cuando
pág. 78
sea necesario. Esto significa que si se convierte un sistema de archivos a ext4 no se podrá regresar
a ext3 de nuevo.3
El uso de extents está fijado por defecto desde la versión del kernel 2.6.23. Anteriormente, esta
opción requería ser activada explícitamente (por ejemplo mount /dev/sda1 /mnt/point -t
ext4dev -o extents ).
Asignación persistente de espacio en el disco
El sistema de archivos ext4 permite la reserva de espacio en disco para un fichero. Hasta ahora la
metodología consistía en rellenar el fichero en el disco con ceros en el momento de su creación.
Esta técnica no es ya necesaria con ext4, ya que una nueva llamada del sistema "preallocate()" ha
sido añadida al kernel Linux para uso de los sistemas de archivos que permitan esta función. El
espacio reservado para estos ficheros quedará garantizado y con mucha probabilidad será
contiguo. Esta función tiene útiles aplicaciones en streaming y bases de datos.
Asignación retrasada de espacio en el disco
Ext4 hace uso de una técnica de mejora de rendimiento llamada Allocate-on-flush, también
conocida como reserva de memoria retrasada. Consiste en retrasar la reserva de bloques de
memoria hasta que la información esté a punto de ser escrita en el disco, a diferencia de otros
sistemas de archivos, los cuales reservan los bloques necesarios antes de ese paso. Esto mejora
el rendimiento y reduce la fragmentación al mejorar las decisiones de reserva de memoria basada
en el tamaño real del fichero.
Límite de 32000 subdirectorios superado
En ext3 el nivel de profundidad en subdirectorios permitido estaba limitado a 32000. Este límite
ha sido aumentado a 64000 en ext4, permitiendo incluso ir más allá de este límite (haciendo uso
de "dir_nlink"). Para permitir un rendimiento continuo, dada la posibilidad de directorios mucho
más grandes, htree está activado por defecto en ext4. Esta función está implementada desde la
versión 2.6.23. htree está también disponible en ext3 cuando la función dir_index está activada.
Chequeo del sistema de ficheros más rápido
En ext4, los grupos de bloques no asignados y secciones de la tabla de inodos están marcados
como tales. Esto permite a e2fsck saltárselos completamente en los chequeos y en gran medida
pág. 79
reduce el tiempo requerido para chequear un sistema de archivos del tamaño para el que ext4
está preparado. Esta función está implementada desde la versión 2.6.24 del kernel Linux.
Noatime (No tiempos de acceso)
Hoy vamos a ver una configuración muy simple de aplicar, y que hace que el sistema vaya
muuucho
más
flúido.
Y
estoy
hablando
del
parámetro
"noatime".
Qué es esto de "noatime"? Pues "noatime " es un parámetro especial en el montaje de los
dispositivos como discos duros o memórias extraibles. Se acostumbra a modificar en el fichero
/etc/fstab.
[Explicación]
Resulta que nuestro sistema de ficheros guarda, para cada uno de nuestros ficheros, un
parámetro que se llama "atime", o "access time". Total, que cada vez que accedemos
(leemos) un fichero, el valor "atime" se actualiza. Así podemos saber cuál fué la última vez que
accedimos/leimos un determinado fichero.
Pero claro, esto tiene un comportamiento no deseado: Resulta que por cada lectura que
hacemos a disco, necesitamos escribir algo a disco!! (Actualizar el valor "access time"). Esto
parece absurdo! Para leer tenemos que escribir.
Habrá alguien que pensará: exagerado! No es para tanto. Total, tiene que escribir a disco tan
solo unos pocos bytes, esto no es nhà.
Pues bueno, resulta que escribir estos pocos bytes si jode, y mucho. Me explico. Linux tiene un
sistema fantástico de caches, completamente transparente para el usuario. Te permite hacer lo
siguiente:
# cat ./bashrc
# cat ./bashrc
La primera vez que haces el "cat" de cualquier fichero ( en nuestro caso, .bashrc ), se va al disco
duro, y lo lee. Pero también lo pone en la memoria RAM. La segunda vez que ejecutas el
comando "cat", sabe que lo tiene cacheado y lo lee directamente de memória RAM. No hace
pág. 80
falta tocar disco duro. Esto hace que el sistema vaya muuuucho más rápido, ya que todo los
ficheros que hayas leido una vez ( y no se hayan modificado ) ya están cacheados, y no se
precisa leer a disco. Pero que pasa si no tenemos desactivado el "atime", pues que con
cada lectura, aunque la tuvieses cacheada, tienes que hacer una escritura a disco para
actualizar el tiempo de acceso. Nos ha jodido.
Esto, en portátiles tiene un impacto muy grande ya que al cabo de X segundos de no utilizar
el disco duro, éste se para. Un tema de ahorro de energía. Qué pasa si queremos hacer una
lectura o escritura? Pues que el disco se tiene que volver a poner a girar con el consiguiente
consumo energético/tiempo perdido. Pero si intentamos leer un fichero CACHEADO por el
sistema, el disco duro ni se entera. Sigue parado. Por lo que es genial.
Como hacerlo:
Cómo activar la opción "noatime"?
Con tu editor preferido (gedit, nano, emacs) el fichero, en mi caso "vim":
# sudo vim /etc/fstab
Busca tu disco duro principal. Lo mas seguro es que sea una entrada como esta:
UUID=3e9532f9-226c-4f17-ae64-dad42519a1fc / ext4 errors=remount-ro 0 1
y añade simplemente "noatime" en las opciones para que quede tal que así:
UUID=3e9532f9-226c-4f17-ae64-dad42519a1fc / ext4 noatime,errors=remount-ro 0 1
y punto. Reinicia y ya lo tienes.
[Cuándo aplicar esta configuración]
Bueno pues, recomendado, a todas las máquinas en general. Sin excepción.
Muy recomendado, en portátiles. Por el tema de ahorro de corriente, y del encendido/parado
del disco.
Y OBLIGATORIO en los equipos:
- Servidores ( web-ftp-sambda ) con muchas lecturas. Aquí si que utilizar el sistema de cachés es
pág. 81
algo básico, y no quitar el atime podría hacer que el rendimiento fuese pésimo.
- Equipos con discos duros SSD. Esto es debido a que los SSD tienen un número de escrituras
máximas por bloque, y al llegar este número se desactiva el bloque y no se utiliza nunca más. Por
lo que tener el "atime" activado significa que la vida del disco va a ser mucho mas corta.
Swapinees
De modo predeterminado, el núcleo de Linux utiliza un valor de 60 para vm.swapiness y tiene la
finalidad de permitir hacer pruebas a los desarrolladores del núcleo de Linux.
Este valor corresponde a la frecuencia con la que las aplicaciones utilizan memoria virtual. Pueden
establecerse valores entre 0 y 100, donde el valor más bajo establece que se utilice menos la
memoria de intercambio, lo cual significa que se reclamará en su lugar el caché de la memoria.
Para la mayoría de los casos, conviene cambiar este valor por uno más bajo a fin de que el sistema
utilice menos la memoria de intercambio y utilice más la memoria cache. Ésta es una clase de
memoria RAM estática de acceso aleatorio (SRAM o
Static Random Access Memory). Se sitúa entre la Unidad Central de Procesamiento (CPU) y la
memoria RAM y se presenta de forma temporal y automática para el usuario proporcionado
acceso rápido a los datos de uso más frecuente.
Lo más recomendable es cambiar el valor de vm.swappiness a 10, que resulta un valor más
apropiado para un sistema de escritorio o una portátil. Para tal fin, se edita el archivo
/etc/sysctl.conf y se añade al final de éste:
vm.swappiness = 10
Con lo anterior, la siguiente vez que se inicie el sistema aplicará el cambio y se utilizará con menos
frecuencia la memoria virtual. Para que el cambio surta efecto de inmediato, se ejecuta lo
siguiente:
sysctl -w vm.swappiness=10
Si se asigna 0 (cero) como valor para vm.swappiness, se estará desactivando el uso de memoria
virtual, lo cual es poco recomendado, salvo que se disponga de una buena cantidad de memoria
física. Por lo general, el valor 0 para esta opción se utiliza solo en portátiles con unidades SSD,
donde, de hecho, se busca realizar cuanto menos escritura como sea posible sobre las unidades
de almacenamiento.
pág. 82
Commit
Esta opción controla el tiempo que se utilizará entra cada operación sincronización (sync) de datos
y metadatos en una partición. El tiempo predeterminado es de 5 segundos y puede
incrementarse para mejorar el desempeño, tomando en consideración que si se específica
demasiado tiempo y ocurre una interrupción de energía antes de hacer una operación de
sincronización (sync), se perderán los datos más recientes con los que se haya trabajado. Sólo
usarla se recomienda si se dispone de un sistema de respaldo de energía confiable.
/mapper/lv_varwww /var/www ext4 defaults,commit=30 1 2
fsck (file system check o bien file system consistency check)
Es una utilidad de los sistemas Unix y similares, como Linux, AIX y MAC OS X que se utiliza ante
alguna inconsistencia del sistema de archivos para corregir los posibles errores en el sistema.
fsck se ejecuta automáticamente al inicio del sistema ante alguna anomalía, pero también puede
ser utilizada manualmente por el administrador del sistema para forzar una verificación.
Para verificar un sistema de archivos es muy aconsejable hacerlo mientras éste está desmontado.
Para detectar, verificar y corregir los errores del sistema de archivos. Es recomendable utilizarlo
solo con sistemas desmontados.
Su sintaxis es de la forma:
fsck [-sAVRTMNP] [-C[fd]] [-t fstype] [filesys..] [fs-specific-options]
Donde:
-C Muestra el progreso en tiempo real de un modo visual.
-A Chequea todos los dispositivos definidos en el fichero /etc/fstab
-M No chequea sistemas montados.
-t Especifica el tipo o tipos de sistema de ficheros a chequear. Si lo acompañamos de la
opción -A, solo chequearemos los sistemas que coincidan con fstype(una lista
separada por comas).
Filesys
Puede ser el nombre de un dispositivo (/dev/hdc1, /dev/sda3), un punto de montaje
pág. 83
(/, /usr, /home)
o
un label o UUID (UUID=f6c797e5-605b-4884-92d7-cdb694a42122,
LABEL=home). Si no se especifica, por defecto se analizaran los definidos en el fichero /etc/fstab
pág. 84
Opciones:
--a repara de manera automática, no pide confirmación.
--n reporta los problemas sin repararlos.
--c busca bloques dañados y los agrega a la lista de bloques dañados.
--f forzar la revisión.
--v verbose, genera más información.
--r modo interactivo. Espera nuestra respuesta.
--y si a todo.
Ejercicio:
Con el siguiente comando determinamos que dispositivo corresponde a /boot:
# df -h | grep /boot
Desmontamos la partición correspondiente a /boot.
# umount /boot
Revisamos nuevamente que la partición /boot esté desmontada:
# df -h | grep /boot
Siempre que se incluye la opción “–y” se asume que se responderá que si a todas las preguntas
de confirmación que mande la ejecución de los comandos y con la opción “–C” muestra una barra
de progreso.
# fsck -fyC /dev/sda1
Si añadimos la opción –c realizara la verificación de solo lectura para realizarla sobre bloques que
pudieran estar dañados, y con la opción –k preservara la lista donde añadirán los nuevos bloques
dañados.
# fsck -fykc /dev/sda1
Realizando la tarera con la opción –cc realizara la verificación de lectura y escritura pero de
manera no destructiva.
# fsck -fykcc /dev/sda1
Con la opción –p realizara la verificación y reparación de manera automática.
# fsck -fpC /dev/sda1
pág. 85
Comando que realiza la misma tarea, pero combinando todas la opciones mencionadas
anteriormente.
# fsck -fpkcc /dev/sda1
Con la opción “–D” realizara la verificación optimizando al mismo tiempo la estrutura de los
directorios.
# fsck -fpD /dev/sda1
La optimización de directorios se realiza volviendo a crear un índice de éstos sí el sistema de
archivos incluye soporte para índices (como es el caso de Ext4) o bien re-ordenando y
comprimiendo directorios en los casos de directorios pequeños o bien sistemas de archivos que
utilicen directorios lineales tradicionales.
Con el comando en este formato este se añade al inodo (nodo índice) de bloques dañados.
# fsck -fpDkcc /dev/sda1
Montaremos /boot una vez terminado el ejercicio.
# mount /boot
Con el siguiente comando forzaremos a realizar una verificación de sistema de archivos:
# shutdown -F -r now
Uso de dd
El comando dd (Dataset Definition), es una herramienta sencilla, útil, y sorprendentemente fácil
de usar; con esta herramienta se puede hacer lo mismo, sobre dispositivos: discos y particiones,
que con programas comerciales como Norton Ghost, en Windows o libres como CloneZilla, en
Linux, con solo una pequeña línea de comandos.
Sintaxis Básica:
La sintaxis más básica para el uso del comando dd, seria esta:
$ sudo dd if=origen of=destino
pág. 86
Donde if significa “input file=archivo de entrada“, es decir, lo que se quiere copiar y of significa
“output file=archivo de salida“, o sea, el archivo destino (donde se van a copiar los datos); origen
y destino pueden ser dispositivos (lectora de CD o DVD, disco duro, diskettera, pendrive, partición,
etc.), archivo de copia de seguridad o imagen de disco, etc, pero no carpetas o subcarpetas.
Para el uso sin problemas de este comando, lo primero siempre es tener claro como se llaman las
particiones/discos duros en Linux (/dev/sda1 por ejemplo; /dev deriva de device= dispositivo, en
inglés). Para saber el disco/partición de origen y el de destino, algo que averiguamos fácilmente
con el comando sudo fdisk -l o con algún programa gráfico de particiones como gparted. Toda la
información sobre el comando dd, se puede consultar con el comando man dd e info dd ,
Se debe utilizar este comando con precaución, y comprobando siempre el orden y nombre de los
discos/particiones, porque lo mismo que se clona un disco, lo borra en un visto y no visto.
Sintaxis con el comando pv: Usar el comando dd con la sintaxis anterior tiene un pequeño
inconveniente, ya que es un comando muy reservado – no da información – , pues al ejecutarlo,
el prompt de la terminal queda inmóvil, por lo que no sabemos que es lo que esta pasando y
cuanto tiempo falta para que termine de ejecutarse. Este pequeño inconveniente se puede
solucionar añadiendo el comando pv, ( *) – el cual actúa como una tubería de terminal que mide
los datos que pasan a través de ella- a la sintaxis del comando dd , de forma que ahora la sintaxis
seria:
$ dd if=origen |pv|dd of=destino
Como resultado obtendríamos en el terminal una especie de barra de progreso, la información
sobre bytes transferidos, el tiempo que lleva ejecutándose y la tasa de transferencia, todo esto
en tiempo real.
( alf ) – ( ~ )
>> dd if=/demmcblk0p1 |pv|dd of=/dev/mmcblk0p2
1,630GB 0:21:30 [1,12MB/s] [
pág. 87
Además al terminar nos muestra estadísticas de la tasa de transferencia, el total de bytes
transferidos y el tiempo total que tardó en transferir todos los datos.
( alf ) - ( ~ )
└──┤ dd if=/devmmcblk0p1 |pv|dd of=/dev/mmcblk0p2
10530816+0 registros leídos <=>
10530816+0 registros escritos
5391777792 bytes (5.4 GB) copiados, 3873,48 s, 1,4 MB/s
5,02GB 1:04:33 [1,33MB/s] [ <=>
10530816+0 registros leídos <=>
10530816+0 registros escritos
5391777792 bytes (5.4 GB) copiados, 3873,48 s, 1,4 MB/s
( alf ) - ( ~ )
└──┤
(*) Comprobar antes de ejecutar cualquier linea de comandos con esta segunda sintaxis, que
tenemos instalado en el sistema el paquete pv, o instalarlo si no lo tuviéramos.
Vamos a ver algunos ejemplos prácticos y opciones de este comando ( en su versión con el truco
explicado anteriormente con el comando pv ) :
pág. 88
A) Sobre discos duros y particiones:
= Clonar un disco duro:
Con esto clonaríamos el disco hda en hdb. (discos IDE):
$ sudo dd if=/dev/hda |pv|dd of=/dev/hdb bs=1M
Con esto clonaríamos el disco sda en sdb. (discos SATA):
$ sudo dd if=/dev/hda |pv|dd of=/dev/sdb bs=1M
Con la opción bs=1M , se consigue que tanto la lectura como la escritura se haga en bloques de 1
megabyte, (menos, seria mas lento pero mas seguro, y con mas nos arriesgamos a perder datos
por el camino).
Hay que tener en cuenta que de esta forma se graba el disco “tal cual”, MBR, tabla de particiones,
espacio vacío, etc…, por lo que solo podrás grabar en un disco del mismo o mayor tamaño.
= Grabar solo la primera partición (hda1) del disco de origen en el disco (hdb) de destino:
$ sudo dd if=/dev/hd1 |pv|dd of=/dev/hdb bs=1M
= Grabar el disco completo (hda) en la primera partición (hdb1) del disco de destino:
$ sudo dd if=/dev/hda |pv|dd of=/dev/hdb1 bs=1M
= Crear una imagen – puede ser bin o iso – del disco duro (hda) , en el directorio /home:
$ sudo dd if=/dev/hda |pv|dd of=/home/hda.bin
= Borrar totalmente la información de un disco: para ello, llena el disco con caracteres aleatorios,
cinco veces. No va a quedar ni rastro de información en el disco:
For n in {1..5}; do dd if=/dev/undandom |pv|dd of=/dev/hda bs=8b
Conv=notrunc;
= Borrar cualquier partición y disco completo de cualquier dispositivo:
pág. 89
$ sudo dd if=/dev/zero |pv|dd of=/dev/sdx (borrado del disco completo)
$ sudo dd if=/dev/zero |pv|dd of=/dev/sdxa (borrar una partición)
donde: x es el disco a borrar , a es la partición a borrar
Esta operación es muy útil para borrar completamente cualquier partición, además los datos que
se borrarán no se pueden recuperar, por lo tanto es un borrado a bajo nivel y muy seguro, muy
útil por ejemplo para cuando los pendrives se nos infectan de virus con nuestro querido windows.
B) Sobre un CD/DVD
= Crear/Montar una imagen .iso de un CD (o DVD)
Para crear la imagen .iso de un CD en el directorio /home:
$ sudo dd if=/dev/cdrom |pv|dd of=/home/imagendeCD.iso
Para montar la imagen .iso del CD:
$ sudo mount –o loop imagendeCD.iso /mnt/home
= Recuperar un DVD rayado (Esto no recupera todo el DVD, en este caso, solo los sectores
legibles). Sirve también para discos duros defectuosos:
$ sudo dd if=/dev/cdrom |pv|dd of=/home/dvd_recuperadp.iso
conv=noerror,sync
La opción noerror, sirve para obviar los errores de lectura en cualquier situación.
pág. 90
C) Sobre MBR y VBS:
Los primeros 512 bytes del disco duro o unidad de almacenamiento utilizado para el sistema
operativo, corresponde al sector de arranque maestro, donde:
Los primeros 446 bytes corresponden al gestor de arranque
Los siguientes 64 bytes corresponden a la tabla de particiones. 16 bytes para cada partición
primaria y/o extendida que existan.
Los últimos 2 bytes corresponden a la firma de unidad con capacidad de inicio. También se
les conoce como los 2 bytes mágicos.
= Copiar/Restaurar el Master Boot Record (MBR):
Para copiar el MBR:
# dd if=/dev/sda of=mbr.bin bs=512 count=1
Para restaurar el MBR:
# dd if=mbr.bin of=/dev/sda bs=512 count=1
= Limpiar nuestro MBR y la tabla de particiones:
$ sudo dd if=/dev/zero |pv|dd of=/dev/had bs=512 count=1
= Limpia el MBR pero no toca la tabla de particiones, ( muy útil para borrar el GRUB sin perder
datos en las particiones):
$ sudo dd if=/dev/zero |pv|dd of=/dev/had bs=446 count=1
= Copiar/Restaurar el Volume Boot Sector (VBS):
Para copiar el VBS:
pág. 91
$ sudo dd if=/dev/hda |pv|dd of=/home/sector_arranque_hda count=1 bs=512
Para restaurar el VBS:
$ sudo dd if=/home/sector_arranque_hda |pv|dd of=/dev/had
D) Otros:
= Grabar una imagen del disco en nuestro directorio /home saltándonos los errores del disco (muy
útil para discos que se están muriendo):
$ sudo dd conv=noerror if=/dev/hda |pv|dd of=~/home/imagen_disco_con_errores-iso
= Crear un archivo vacío de 1 Mb:
$ sudo dd if=/dev/zero |pv|dd of=archivo_nuevo_vacio bs=1024 count=1024
= Crear un archivo swap de 2Gb:
$ sudo dd if=/dev/zero |pv|dd of=/swapspace bs=4k count=2048 mkswap /swapspace
#
swapon
/swapspace
= Convertir todas las letras en mayúsculas:
$ sudo dd if=miarchivo |pv|dd of=miarchivo conv=ucase
Formato de bajo nivel.
Si es necesario dar un formato de bajo nivel a fin de eliminar toda la información del disco duro,
puede ejecutar lo siguiente, considerando en el ejemplo que se intenta dar formato de bajo nivel
al disco duro /dev/sda, para escribir 0 (ceros) en cada sector de la unidad de almacenamiento.
if=/dev/zero of=/dev/sda
pág. 92
pág. 93
Ejecute lo siguiente para dar formato de bajo nivel escribiendo números aleatorios en todos los
sectores de una unidad de almacenamiento que corresponde a /dev/sda:
if=/dev/urandom of=/dev/sda
pág. 94
Unidad 3. -Administración de Sofware y servicios.
Antiguamente muchos programas Linux eran distribuidos como código fuente, que el usuario
construía en el programa o en la serie de programas en los que era necesario, junto con las páginas
de los manuales que fueran necesarias, los archivos de configuración, y demás. Hoy en día, la
mayoría de los distribuidores de Linux utilizan programas o sets de programas prearmados
denominados paquetes, los cuales son enviados para su distribución listos para instalar.
Aprenderá de qué manera las herramientas para administración de programas lo ayudan a
instalar, actualizar, y eliminar paquetes. Este manual trata particularmente el tema del Red Hat
Package Manager (RPM), desarrollado por by Red Hat, y del Yellowdog Updater Modified (YUM),
originalmente desarrollado para administrar los sistemas Red Hat Linux en el Departamento de
Física de la Universidad Duke.
Dado que los desarrolladores de Linux se han esforzado para que el uso de Linux sea más fácil, las
herramientas básicas han sido complementadas por otras, incluyendo las herramientas GUI, las
cuales ocultan al usuario algunas de las complejidades de las herramientas básicas. RPM, YUM, y
APT (para los sistemas Debian) poseen muchas similitudes. Todos ellos pueden instalar y quitar
paquetes. La información sobre los paquetes instalados se guarda en una base de datos. Todos
ellos tienen funcionalidad de línea básica de comando, además de herramientas adicionales que
pueden proporcionar al usuario interfaces de uso más sencillo. Todos ellos pueden recuperar
paquetes de Internet.
Al instalar un sistema Linux, por lo general usted puede instalar una gran variedad de paquetes.
El set puede personalizarse según el uso que se quiera dar al sistema, como servidor, escritorio,
o terminal de trabajo del desarrollador. Y en algún momento probablemente sea necesario
instalar paquetes nuevos para obtener alguna otra funcionalidad, actualizar el paquete que
posee, o incluso borrar paquetes que ya no se necesitan o son obsoletos debido a la aparición de
nuevos paquetes. Demos un vistazo a la forma en la que usted realiza estas tareas, y a algunos de
los desafíos a los que debe hacer frente, como la búsqueda de algún paquete que contenga algún
comando en particular.
pág. 95
Si no sabemos o tenemos información de algún paquete o programa, podremos utilizar
inicialmente el comando info, que es el encargado de mostrar la información en forma de manual
del programa si esta instalado con el comando info:
# info yum
Gestión de paquetes RPM
Red Hat lanzó RPM en 1995. Actualmente RPM es el sistema de gestión de paquetes usado para
crear paquetes en Linux Standard Base (LSB). Las opciones del comando rpm están agrupadas en
tres subgrupos según se utilicen para:
Consultar y verificar paquetes
Instalar, actualizar y borrar paquetes
Realizar varias funciones
En este manual nos ocuparemos de los dos primeros subgrupos de opciones de comandos. Usted
encontrará información sobre el tercer subgrupo en las páginas de los manuales para RPM.
Deberíamos tener en cuenta también que rpm es el nombre de comando para el comando
principal utilizado con RPM, mientras que .rpm es la extensión utilizada en los archivos RPM. Por
lo tanto "un rpm" o "el xxx rpm" se referirá generalmente a un archivo RPM, mientras que rpm por
lo general se referirá al comando.
Si en algún momento la base de datos que contiene la información de los rpm’s se corrompe por
cualquier tipo de daño, sea software o hardware con el siguiente comando puede reconfigurarla
a su estado original:
# rpm –rebuilddb
Si lo que necesita es revisar si tiene instalado algún paquete dentro de su sistema, ejecutando el
siguiente comando puede realizar esta consulta, agregando la opción –q la cual realizara un query
como el bases de datos, es decir una consulta, para el siguiente ejemplo tomaremos como
ejemplo el paquete coreutils, el cual debe estar instalado, dándonos una salida con la información
del paquete:
pág. 96
# rpm -q coreutils
Si necesitamos una infomacion mas detallada de dicho paquete usaremos el comando agregando
la opción “–i”:
# rpm -qi coreutils
Al substituir la i por la opción “–l” (ele) podríamos listar todos los componentes que son afectados
por dicho paquete:
# rpm -ql coreutils
Si nos interesa saber a que paquete pertenece alguna aplicación ejecutaríamos al comando como
sigue
# rpm -qf /bin/kill
Ejecutando el siguiente comando nos mostrara la lista de paquetes instalados.
# rpm -qa |more
Si buscamos un paquete en específico utilizaremos el siguiente.
# rpm -qa |grep utils
Si queremos ver los paquetes en orden de instalación, es decir los que se instalaron primero hasta
los últimos, teclearemos el siguiente:
# rpm -qa --last|more
Si queremos verificar todos los componentes del sistema mostrando los modificados ,
ejecutaremos lo siguiente:
# rpm -Va
pág. 97
Instalación de paquetes.
Lo primero es descargar el rpm que vamos a utilizar lo cual lo haremos en la siguiente liga:
http://get.adobe.com/es/flashplayer/
Una vez descargado lo transferiremos a la maquina virtual.
Una vez descargado el paquete de flash podríamos realizar una revisión detallada de lo que
incluye el paquete ejecutando el siguiente comando:
# rpm -qpi flash-plugin-11.2.202.424-release.i386.rpm
Para realizar la instalación después de descargar el rpm que vallamos a utilizar, se instala con el
comando:
En este ejemplo vamos a instalar el paquete de flash-plugin-11.2.202.424-release.i386.rpm
# rpm –ivh y el nombre del paquete
Para ver los componentes que esta instalando el paquete ejecutamos el siguiente comando:
# rpm -qpl y el nombre del paquete instalado
Para verificar que el paquete de firmas es el adecuado para el paquete ejecutamos el siguiente
comando:
# rpm -K el nombre del paquete instalado
En caso contrario nos podría salir un mensaje parecido al siguiente:
Nombre del paquete instalado: (sha1) dsa sha1 MD5 GPG NOT OK
Si tuviera alguna complicación y el paquete no se instalara agregara al comando la opción --force:
# rpm -ivh --force Nombre del paquete a instalar
Si le interesa saber en algún momento las dependencias del paquete podría ejecutar el siguiente
pág. 98
comando:
# rpm -qp --requires Nombre del paquete a instalar
Si se desea desinstalar cualquier paquete sin importar que otros dependan de este, se puede
utilizar con la opción --nodeps. Esto es contraindicado y sólo debe ser utilizado en situaciones
muy particulares. Evite siempre desinstalar paquetes que sean dependencia de otros en el
sistema a menos que vaya a reinstalar inmediatamente un paquete que cubra las dependencias
que se hayan visto afectadas.
Para desinstalar un rpm necesitaría ejecutar el siguiente comando:
# rpm –e Nombre del paquete.
En resumen:
Para instalar:
# rpm -i paquete.rpm
Para desinstalar:
# rpm -e paquete.rpm
Para instalar y ver el progreso:
# rpm -iv paquete.rpm
Para instalar o actualizar segun el caso y ver el progreso (opción recomendada):
# rpm -Uvh paquete.rpm
Para confirmar si esta instalado o no:
# rpm -q paquete.rpm
Para forzar la desinstalacion (opción no recomendada):
# rpm -e paquete.rpm --force
Instalar un paquete que tiene una versión anterior previamente instalada:
pág. 99
# rpm –Fvh paquete.rpm
Uso de YUM.
Yellow dog Updater, Modified (YUM) es una herramienta libre de gestión de paquetes para
sistemas Linux basados en RPM. Fue desarrollado por Seth Vidal y un grupo de programadores
voluntarios, y actualmente se mantiene como parte del proyectoLinux@DUKE de la Universidad
de Duke. A pesar de que yum es una utilidad para línea de comandos, otras herramientas proveen
a yum de una interfaz gráfica de usuario, como pup, pirut y yumex. Desde que Seth Vidal trabaja
en Red Hat, programadores de dicha compañía están implicados en el desarrollo de yum.
Yum es una utilidad totalmente reescrita a partir de su herramienta predecesora, Yellowdog
Updater (YUP), y fue desarrollada principalmente para actualizar y controlar los sistemas Red
Hat utilizados en el departamento de física de la Universidad de Duke. Desde entonces, ha sido
adoptada por Fedora, CentOS, y otras distribuciones de GNU/Linux basadas en RPM, incluyendo
el mismo Yellow Dog, donde reemplazó a la utilidad original YUP. El manejador de paquetes
de Red Hat, up2date, también puede hacer uso de los repositorio de software de yum cuando
realiza actualizaciones de software. Red Hat Enterprise 5 reemplazó up2date por yum y pirut.
Con los paquetes "yum-updatesd" o "yum-updateonboot" se puede hacer una actualización de
software automática.
El sistema de repositorios yum está convirtiéndose rápidamente en un estándar para los
repositorios basados en RPM. En SUSE Linux 10.1 se añade soporte para repositorios YUM
en YaST, y los repositorios de openSUSE están basados exclusivamente en Yum.
Yellow dog Updater, Modified está disponible bajo licencia GNU GPL versión 2 o superiores.
pág. 100
Ejercicio:
# yum list available | more > Lista todo los paquetes disponibles
# yum list installed | more > Lista los paquetes instalados
# yum list installed kernel > Lista la versión instalada en el kernel
# yum list updates | less > Lista los paquetes que pueden ser actualizados
# yum list all | less > Lista todos los paquetes existentes
# yum grouplist > Lista los grupos de paquetes disponibles en YUM
# yum search nombre-paquete > Realiza la búsqueda de un paquete(cups)
# yum info nombre-paquete > Consulta de información de paquetes(cups)
#yum groupinfo "Grupo" > Muestra la información de un grupo(servidor web)
#yum install nombre-paquete > Instala un paquete(openssh)
# yum install --nogpgcheck nombre-paquete > Instala con resolución de
dependencias
pág. 101
# yum -y install nombre-paquete > Instala con respuesta positiva a los
modulos que instala(cups-pdf)
Instalación de grupos de paquetes con resolución automática de dependencias:
# yum groupinstall "Nombre
paquetes(servidor web)
del
Grupo" >
Instala
grupos de
# yum -y groupinstall "Nombre del Grupo" > Instala con respuesta positiva a
los modulos que instala(servidor web)
# yum remove nombre-paquete > Desinstala paquetes(cups-pdf)
# yum groupremove "Nombre del Grupo" > Desinstala grupos(servidor web)
# yum update > Actualizacion de base de datos del sistema
# yum -y update > Realiza la actualización resolviendo las preguntas de
instalación.
# yum --skip-broken update > Actualiza la base omitiendo las dependencias
corruptas
# yum update nombre-paquete > Actualiza un solo paquete(cups)
# yum -y update nombre-paquete > Actualiza resolviendo las preguntas de
instalación(cups)
# yum groupupdate "Nombre del Grupo" > Actualiza un grupo(servidor web)
# yum -y groupupdate "Nombre del Grupo" > Actualiza grupo con resolución
de preguntas de instalación(Base de datos MySQL).
# yum clean all > Limpia el cache de YUM
# yum clean metadata > Limpia los metadatos
pág. 102
# yum clean packages > Limpia paquetes descargados
# yum check > Chekear las bases de datos de RPM
Una tarea importante como administrador de sistemas es tener el sistema actualizado, para eso:
Instalamos el aquete PackageKit-cron con el siguiente comando:
# yum -y install PackageKit-cron
Editamos el archivo /etc/sysconfig/packagekit-background:
Active el servicio cambiando el valor de ENABLED a yes y habilite MAILTO=root para enviar a root
un reporte de las actualizaciones aplicadas:
# should we attempt to do this? (valid: yes|no)
ENABLED=yes
# if MAILTO is set, the mail command is used to deliver PackageKit output
# by default MAILTO is unset, so crond mails the output by itself
MAILTO=root
Reiniciamos el servicio “crond”:
# service crond restart
Despues:
Instalamos el paquete yum-updatesd con el siguiente comando:
pág. 103
# yum -y install yum-updatesd
Edite el archivo /etc/yum/yum-updatesd.conf:
# vi /etc/yum/yum-updatesd.conf
Cambiamos los valores de do_update, do_download y do_download_deps a yes.
# automatically install updates
do_update = yes
# automatically download updates
do_download = yes
# automatically download deps of updates
do_download_deps = yes
Activamos el servicio “yum-updatesd” con la siguiente instruccion.
# chkconfig yum-updatesd on
Iniciamos el servicio “yum-updatesd”:
# service yum-updatesd start
Y por ultimo reiniciamos el servicio crond:
# service crond restart
pág. 104
De esta manera estaremos automatizando las actualizaciones del sistema, mandando un registro
de actualizaciones.
Gestor de Servicios
La gestión de servicios consiste en activar o desactivar servicios en los distintos niveles de
ejecución del sistema y en iniciar, detener o activar éstos cuando las circunstancias lo requieran.
El sistema operativo GNU/Linux puede aprovechar los niveles de ejecución a través de los
programas del proyecto sysvinit. Después de que el núcleo Linux ha arrancado, el
programa init lee el archivo /etc/inittab para determinar el comportamiento para cada nivel de
ejecución. A no ser que el usuario especifique otro valor como un parámetro
de autoarranque del núcleo, el sistema intentará entrar (iniciar) al nivel de ejecución por defecto.
La mayor parte de usuarios de sistemas puede comprobar el nivel de ejecución actual con
cualquiera de los comandos siguientes:
# runlevel
# como usuario root
$ who –r
# como cualquier usuario
En sistemas GNU/Linux y otras versiones de Unix, init es el programa encargado de llevar la
estación al nivel de ejecución en que se desea que opere. Init es el primer proceso en ejecución
después del la carga del Kernel e implementa dos sistemas de inicio: System V, o BSD-Like. Estos
sistemas especifican los guiones (scripts) de arranque para inicializar los diferentes servicios,
programas o registros que sean necesarios para que el sistema funcione como el usuario quiere
o como el administrador estableció.
Una vez que el sistema inicia y root a montado el file system, se ejecuta el /sbin/init y el ID que se
asigna al proceso es el 1 o monousuario.
En los sistemas GNU/Linux se especifican hasta 7 niveles de ejecución (también conocidos como
runlevels o niveles de corrida). En las distribuciones Red Hat, así como en la gran mayoría de
distribuciones, la especificación de los niveles de ejecución son como sigue:
Nivel de ejecución 0#
Halt. Este nivel de ejecución se encarga de detener todos los procesos activos en el sistema,
enviando a la placa madre una interrupción para el completo apagado del equipo.
pág. 105
Nivel de ejecución 1#
Single. Nivel de ejecución monousuario, sin acceso a servicios de red. Este nivel es regularmente
utilizado en tareas de mantenimiento del sistema, y el usuario que ejecuta es root.
Nivel de ejecución 2#
Al igual que el nivel de ejecución monousuario, pero con funciones de red y compartición de datos
mediante nfs.
Nivel de ejecución 3#
Sistema multiusuario, con capacidades plenas de red, sin entorno gráfico. Este nivel de ejecución
es el recomendado para sistemas de servidor, ya que evita la carga innecesaria de aplicaciones
consumidoras de recursos.
Nivel de ejecución 4#
Nivel especificado como nivel de experimentacion, pero no se utiliza.
Nivel de ejecución 5#
Al igual que el nivel de ejecución 3, pero con capacidades gráficas. Ideal para entornos de
escritorio.
Nivel de ejecución 6#
Reboot. Este nivel de ejecución se encarga de detener todos los procesos activos en el sistema,
enviando a la placa madre una interrupción para el reinicio del equipo.
Con el siguiente comando verificaríamos en que nivel se esta trabajando
# cat /etc/inittab |grep initdefault |grep id
5 es el nivel predeterminado de inicio del sistema. Para cambiar el valor del nivel de ejecución
predeterminado, se edita como root el archivo /etc/inittab:
# vim /etc/inittab
Con el siguiente comando podríamos ver el nivel actual de el sistema
pág. 106
# runlevel
Cuando nos muestra una N antes del nivel quiere decir que el nivel inicial es el actual
#N5
Cuando se muestran 2 valores distintos quiere decir que se conmuto el nivel inicial
#35
Con el siguiete comando podríamos ver de forma mas detallada la información del nivel de
ejecución:
“ who -r
Con el comando init podremos hacer la conmutación o cambio de nivel de ejecución:
# init 1
Con el siguiente comando cambiaremos al nivel de ejecución 3:
# init 3
Con el siguiente cambiaremos al nivel 6 lo cual probocaria que el sistema reiniciara de manera
inmediata:
# init 6
Con el siguiente el sistema se apagara, pues cambiaria al nivel 0 o apagado:
# init 0
Secuencia de arranque
1.- CentOS arranca ejecutando el programa init. El archivo de configuración de init es /etc/inittab.
La entrada initdefault determina el nivel de ejecución inicial del sistema.
2.- Edita el fichero /etc/inittab, localiza la entrada initdefault, y determina en que nivel de
ejecución está trabajando el sistema.
3.- También puedes obtener el nivel de ejecución actual ejecutando la
instrucción runlevel.
pág. 107
4.- Los primeros scripts que se ejecutan a continuación (indicado en la linea del fichero
/etc/inittab: si::sysinit:/etc/init.d/rcS) son los que se encuentra en el directorio /etc/rcS. Estos
scripts
son
los
encargados
de
realizar
algunas
tareas
como:
Monta el file system root y /proc.
Elimina temporales y archivos de bloqueo.
Establece el reloj
Inicia scripts de red y activa la partición swap.
Activa el teclado y fuentes.
Carga módulos.
Establece valores a muchas variables del entorno:PATH, HOSTNAME,...
Arranca la swap
Arranca fsck automático, si hace falta.
Activa quotas.
Chequea los argumentos pasados al kernel.
Chequea los filesystems
Inicializa los puertos serie.
Puertos USB.
5.- Lista los ficheros que se encuentran en el directorio /etc/rc.d
6.- Comprueba que son enlaces simbólicos a los scripts que se encuentran en el directorio
/etc/init.d
7.- A continuación se ejecutan los scripts de inicialización de los servicios del nivel de ejecución
por defecto. Estos scripts se encuentran en los directorios /etc/rcn donde n es el nivel de
ejecución.
Ejemplo:
Nivel Script Directorio
0 rc 0 /etc/rc0.d/
1 rc 1 /etc/rc1.d/
2 rc 2 /etc/rc2.d/
3 rc 3 /etc/rc3.d/
pág. 108
Es el script /etc/init.d/rc el que procesa todos los archivos K y S de los directorios /etc/rcn.d
Para ( con el argumento stop ) aquellos procesos que comienzan por K ( kill )
Lanza ( con el argumento start ) los que comienzan por S ( start ).
Después de la letra S o K hay dos dígitos numéricos que indican el orden de ejecución. El
orden es ASCII.
Todos los ficheros K o S son enlaces simbólicos a los scrips de cada servicio que están en el
directorio /etc/init.d
1) Visualiza los ficheros de los distintos directorios /etc/rcn.d.
2) Comprueba los ficheros de ejecución del nivel de ejecución que se ejecuta por defecto en
Debian.
3) Con la instrucción telinit podemos ejecutar otrps niveles de ejecución. Entra en el nivel
monousuario. Entra en el nivel de reinicio. Entra en el nivel de parada del sistema.
pág. 109
De modo esquemático podemos ver:
Un servicio que tenga un enlace simbólico denominado S80XXX, significa que el servicio iniciará
después de todos los demás servicios que tengan un número menor.
Es decir, S80XXX iniciará después de S70YYY.
Un servicio que tenga un enlace simbólico denominado K30XXX, significa que el servicio terminará
antes que todos los demás servicios que tengan un número mayor.
Es decir, K30XXX terminará primero que K40YYY.
¿Qué hacer para eliminar un servicio en un determinado nivel?
Borrar el vínculo simbólico en /etc/rcn.d/
Renombrarlo con algo que no empiece con S o K y dejarlo por si queremos luego activarlo.
Lo que no hay que hacer nunca es eliminar el archivo original en /etc/init.d/
1) Vamos a eliminar el servicio ssh (encargado de iniciar el servidor gráfico) del nivel de
ejecución 2, para ello elimina el fichero que inicia ese servicio.
2) Reinica el sistema y comprueba que el servidor gráfico no se ha iniciado.
3) Para restablecer el enlace simbólico para que podamos iniciar el servicio usamos la
instrucción update-rc.d (busca la página del manual para aprender más sobre esta
instrucción.
Ejecuta:
pág. 110
update-rc.d gdm defaults para crear los enlaces simbólicos que ejecutan el script de gdm
4) Vuelve a reiniciar el sistema y comprueba que el servidor gráfico se vuelve a ejecutar.
5) Pregunta: ¿Para qué podríamos utilizar la configuración de distintos niveles de
ejecución?
Tambien podría utilizar el siguiente comando para crear enlaces simbólicos:
# ln –s file1 link-to-file1 ó cp –s file1 link-to-file1 que serian equivalentes
Ahora hay que tener en cuenta que:
Un enlace simbolico puede apuntar a un archivo aunque este en un file system distinto
Si elimina el archivo original, el enlace sigue apuntando, pero a un archivo inexistente.
Arranque y parada de lo servicios
Una vez que se han cargado los servicios que se encuentran en el directorio /etc/rc2.d, podemos
comprobar que los demonios correspondientes a cada servicio se están ejecutando con la
instrucción:
# ps -A
En cualquier momento podemos parar o reiniciar cualquier servicio ejecutando los scripts
del directorio /etc/init.d con las siguientes opciones: start, stop, restart, force-reload,...
1) Comprueba que el servicio ssh se está ejecutando.
2) Para el servicio, y comprueba con la instrucción ps que el proceso no se está
ejecutando.
3) Vuelve a reiniciar el servicio.
pág. 111
Envío de señales a los procesos
Es posible el envío de distintas señales a los procesos. La más usada es matar un proceso, si por
ejemplo se queda inactivo. Para ello utilizamos la siguiente instrucción:
kill -9 PID
El PID es el identificador del proceso, y lo puedes obtener mirando la lista de procesos por
ejemplo con ps -A.
Podemos también utilizar la siguiente instrucción
killall nombredelproceso
Del mismo modo puedes ver el nombre del proceso mirando la lista de procesos con ps.
1) Imagínate que el servidor gráfico se queda "colgado". Entra en un terminal de texto
con CTRL+ALT+F1, y tras iniciar sesión como root mata el proceso gdm (Gestor de
arranque del servidor gráfico).
2) Para comprobar que el servidor gráfico no funciona puedes hacer varias cosas: lista los
procesos y comprueba que no existe el proceso gdm ni el Xorg. También puedes intentar
entrar en la consola gráfica con CTRL+ALT+F7.
3) Vuelve a ejecutar el gestor de arranque gráfico gdm.
4) Del mismo modo puedes matar el demonio del servicio ssh, y volver a reiniciarlo
posteriormente.
Servicios.
La gestión de servicios se hace a través de dos herramientas: chkconfig y service. Ambas utilizan
como argumentos los nombres de los archivos de inicio de los servicios, los cuales se localizan
dentro del directorio/etc/init.d
pág. 112
Chkconfig
Chkconfig permite configurar que servicios arrancan/detienen en cada nivel de ejecucción.
Aclaración: chkconfig no inicia ni detiene servicios al momento (excepto aquellos bajo xinetd), tan
solo crea o elimina precisamente los enlaces de los que se habló en el punto anterior de una
manera mas amigable. Si lo que se quiere es iniciar o detener el servicio en tiempo real o
manualmente hay que usar service o directamente el script con su argumento conveniente tal
como se explicó anteriormente.
Veamos ejemplos que muestran como trabajar con chkconfig.
Con la opción --list nos da una lista completa de todos los servicios instalados y para cada nivel si
arrancará (on) al entrar a ese nivel o se detendrá (off) o simplemente no se iniciara. Nótese que
al final de la lista vienen los servicios que dependen del superservidor xinetd.
# chkconfig –list
Con el siguiente comando eliminaremos el servicio del sistema, es decir se eliminara el link del
/etc/init.d
# chkconfig --del sshd
Con el siguiente comando agregaremos el servicio al inicio del sistema, es decir arrancara al inicio
del sistema, añadiéndolo al directorio /etc/init.d
# chkconfig --add sshd
Lo anterior por lo general se ejecuta automáticamente junto con la instalación de los paquetes
RPM correspondientes para cada servicio. Sólo es necesario ejecutarlo cuando se instalan
servicios que fueron compilados a partir de paquetes de código fuente o bien casos donde las
instrucciones de instalación explícitamente solicitan hacerlo.
Al ejecutar chkconfig con el nombre del servicio y on como argumentos para activar un servicio
que ha sido previamente añadido al sistema.
# chkconfig crond on
pág. 113
Con el siguiente comando se detendría el servicio
# chkconfig crond off
Con el siguiente comando podremos ver en que niveles esta activo y desactivo el servicio:
# chkconfig --list network
Ejecutaremos el siguiente comando para verificar que el servicio de crond esta desactivo en todos
los niveles
# chkconfig –list crond
Ahora ejecutaremos el siguiente comando y lo activaremos en el nivel 3 y 5:
# chkconfig --level 35 crond on
Verificamos con el comando nuevamente y veremos que ya esta activo en los niveles que
necesitamos:
# chkconfig –list crond
Si ejecutamos el comando nuevamente con la opción off se desactivara nuevamente
# chkconfig --level 35 crond off
Si ejecutamos el comando con la opción reset los valores que se asignan son los predeterminados.
chkconfig crond reset
Este proceso se puede trabajar también con una interfaz grafica, esta se denomina ntsysv
pág. 114
Con esta podemos administrar los servicios principales, pudiendo interactuar con ella para la
utilización de los servicios.
Service.
Un daemon
(demonio)
(nomenclatura
usada
en
sistemas
UNIX
y
UNIX
like), service(servicio) (nomenclatura usada en Windows) o programa residente (nomenclatura
usada en MS-DOS) es un tipo especial de proceso informático no interactivo, es decir, que se
ejecuta en segundo plano en vez de ser controlado directamente por el usuario. Este tipo de
programas continua en el sistema, es decir, que puede ser ejecutado en forma persistente o
reiniciado si se intenta matar el proceso dependiendo de configuración del demonio y políticas
del sistema. La palabra daemon viene de las siglas en inglés D.A.E.MON (Disk And Execution
Monitor).
Iniciar un servicio
Al ejecutar el siguiente comando, iniciaremos un servicio, si esta detenido:
# service network start ó /etc/init.d/ network start
Para un servicio
Al ejecutar el siguiente comando, detendremos el servicio de ser necesario:
pág. 115
# service network stop ó /etc/init.d/network stop
Estado de un servicio
Al ejecutar el siguiente comando, verificaremos el estado del servicio en cuestio:
# service network status ó /etc/init.d/network status
Reinicio de un servicio
# service network restart ó /etc/init.d/network restart
pág. 116
Unidad 4.-Gestión de usuarios, grupos y privilegios.
Gestión de cuentas de usuario.
Linux es un sistema multiusuario, por lo tanto, la tarea de añadir, modificar, eliminar y en general
administrar usuarios se convierte en algo no solo rutinario, sino importante, además de ser un
elemento de seguridad que mal administrado o tomado a la ligera, puede convertirse en un
enorme hoyo de seguridad. En este manual aprenderás todo lo necesario para administrar
completamente tus usuarios en GNU/Linux.
Tipos de usuarios
Los usuarios en Unix/Linux se identifican por un número único de usuario, User ID, UID. Y
pertenecen a un grupo principal de usuario, identificado también por un número único de grupo,
Group ID, GID. El usuario puede pertenecer a más grupos además del principal.
Aunque sujeto a cierta polémica, es posible identificar tres tipos de usuarios en Linux:
Usuario root
También llamado superusuario o administrador.
Su UID (User ID) es 0 (cero).
Es la única cuenta de usuario con privilegios sobre todo el sistema.
Acceso total a todos los archivos y directorios con independencia de propietarios y permisos.
Controla la administración de cuentas de usuarios.
Ejecuta tareas de mantenimiento del sistema.
Puede detener el sistema.
Instala software en el sistema.
Puede modificar o reconfigurar el kernel, controladores, etc.
Usuarios especiales
Ejemplos: bin, adm, lp, sync, shutdown, mail, operator, squid, apache, etc.
Se les llama también cuentas del sistema.
No tiene todos los privilegios del usuario root, pero dependiendo de la cuenta asumen
distintos privilegios de root.
Lo anterior para proteger al sistema de posibles formas de vulnerar la seguridad.
No tienen contraseñas pues son cuentas que no están diseñadas para iniciar sesiones con
ellas.
pág. 117
También se les conoce como cuentas de "no inicio de sesión" (nologin).
Se crean (generalmente) automáticamente al momento de la instalación de Linux o de la
aplicación.
Generalmente se les asigna un UID entre 1 y 100 (definifo en /etc/login.defs)
Usuarios normales
Se usan para usuarios individuales.
Cada usuario dispone de un directorio de trabajo, ubicado generalmente en /home.
Cada usuario puede personalizar su entorno de trabajo.
Tienen solo privilegios completos en su directorio de trabajo o HOME.
Por seguridad, es siempre mejor trabajar como un usuario normal en vez del usuario root, y
cuando se requiera hacer uso de comandos solo de root, utilizar el comando su.
En las distros actuales de Linux se les asigna generalmente un UID superior a 500.
etc/passwd
Cualquiera que sea el tipo de usuario, todas las cuentas se encuentran definidas en el archivo de
configuración 'passwd', ubicado dentro del directorio /etc. Este archivo es de texto tipo ASCII, se
crea al momento de la instalación con el usuario root y las cuentas especiales, más las cuentas de
usuarios normales que se hayan indicado al momento de la instalación.
El nombre que es asignado al grupo que se almacena en /etc/passwd es Primary group
El archivo /etc/passwd contiene una línea para cada usuario, similar a las siguientes:
root:x:0:0:root:/root:/bin/bash
sergio:x:501:500:Sergio González:/home/sergio:/bin/bash
pág. 118
La información de cada usuario está dividida en 7 campos delimitados cada uno por ':' dos puntos.
/etc/passwd
Campo 1 Es el nombre del usuario, identificador de inicio de sesión (login). Tiene que ser
único.
Campo 2 La 'x' indica la contraseña encriptada del usuario, además también indica que se
está haciendo uso del archivo /etc/shadow, si no se hace uso de este archivo,
este campo se vería algo así como: 'ghy675gjuXCc12r5gt78uuu6R'.
Campo 3 Número de identificación del usuario (UID). Tiene que ser único. 0 para root,
generalmente las cuentas o usuarios especiales se numeran del 1 al 100 y las de
usuario normal del 101 en delante, en las distribuciones mas recientes esta
numeración comienza a partir del 500.
Campo 4 Numeración de identificación del grupo (GID). El que aparece es el número de
grupo principal del usuario, pero puede pertenecer a otros, esto se configura
en/etc/groups.
Campo 5 Comentarios o el nombre completo del usuario.
Campo 6 Directorio de trabajo (Home) donde se sitúa al usuario después del inicio de
sesión.
Campo 7 Shell que va a utilizar el usuario de forma predeterminada.
Nota: Recuerde usted puede ver las características de pasword ejecutando el comando passwd
con la opción –S y el nombre del usuario.
/etc/shadow
Anteriormente (en sistemas Unix) las contraseñas cifradas se almacenaban en el
mismo/etc/passwd. El problema es que 'passwd' es un archivo que puede ser leído por cualquier
usuario del sistema, aunque solo puede ser modificado por root.
Con cualquier computadora potente de hoy en día, un buen programa de descifrado de
contraseñas y paciencia es posible "crackear" contraseñas débiles (por eso la conveniencia de
cambiar periódicamente la contraseña de root y de otras cuentas importantes). El archivo
'shadow', resuelve el problema ya que solo puede ser leido por root. Considérese a 'shadow' como
una extensión de 'passwd' ya que no solo almacena la contraseña encriptada, sino que tiene otros
campos de control de contraseñas.
El archivo /etc/shadow contiene una línea para cada usuario, similar a las siguientes:
pág. 119
root:ghy675gjuXCc12r5gt78uuu6R:10568:0:99999:7:7:-1::
sergio:rfgf886DG778sDFFDRRu78asd:10568:0:-1:9:-1:-1::
La información de cada usuario está dividida en 9 campos delimitados cada uno por ':' dos puntos.
/etc/shadow
Campo 1
Campo 2
Campo 3
Campo 4
Campo 5
Campo 6
Campo 7
Campo 8
Campo 9
Nombre de la cuenta del usuario.
Contraseña cifrada o encriptada, un '*' indica cuenta de 'nologin'.
Días transcurridos desde el 1/ene/1970 hasta la fecha en que la contraseña fue
cambiada por última vez.
Número de días que deben transcurrir hasta que la contraseña se pueda volver
a cambiar.
Número de días tras los cuales hay que cambiar la contraseña. (-1 significa
nunca). A partir de este dato se obtiene la fecha de expiración de la contraseña.
Número de días antes de la expiración de la contraseña en que se le avisará al
usuario al inicio de la sesión.
Días después de la expiración en que la contraseña se inhabilitara, si es que no
se cambio.
Fecha de caducidad de la cuenta. Se expresa en días transcurridos desde el
1/Enero/1970 (epoch).
Reservado.
/etc/group
Este archivo guarda la relación de los grupos a los que pertenecen los usuarios del sistema,
contiene una línea para cada usuario con tres o cuatro campos por usuario:
root:x:0:root
ana:x:501:
sergio:x:502:ventas,supervisores,produccion
cristina:x:503:ventas,sergio
El campo 1 indica el usuario.
El campo 2 'x' indica la contraseña del grupo, que no existe, si hubiera se mostraría un 'hash'
encriptado.
El campo 3 es el Group ID (GID) o identificación del grupo.
El campo 4 es opcional e indica la lista de grupos a los que pertenece el usuario
pág. 120
Actualmente al crear al usuario con useradd se crea también automáticamente su grupo
principal de trabajo GID, con el mismo nombre del usuario. Es decir, si se añade el usuario
'sergio' también se crea el /etc/group el grupo 'sergio'. Aun asi, existen comandos de
administración de grupos que se explicarán más adelante.
/etc/login.defs
En el archivo de configuración /etc/login.defs están definidas las variables que controlan los
aspectos de la creación de usuarios y de los campos de shadow usada por defecto. Algunos de los
aspectos que controlan estas variables son:
Número máximo de días que una contraseña es válida PASS_MAX_DAYS
El número mínimo de caracteres en la contraseña PASS_MIN_LEN
Valor mínimo para usuarios normales cuando se usa useradd UID_MIN
El valor umask por defecto UMASK
Si el comando useradd debe crear el directorio home por defecto CREATE_HOME
Basta con leer este archivo para conocer el resto de las variables que son autodescriptivas y
ajustarlas al gusto. Recúerdese que se usaran principalmente al momento de crear o
modificar usuarios con los comandos useradd y usermod que en breve se explicaran.
pág. 121
Añadir usuarios con useradd
useradd o adduser es el comando que permite añadir nuevos usuarios al sistema desde la línea
de comandos. Sus opciones más comunes o importantes son las siguientes:
-c añade un comentario al momento de crear al usuario, campo 5 de /etc/passwd
-d directorio de trabajo o home del usuario, campo 6 de /etc/passwd
-e fecha de expiración de la cuenta, formato AAAA-MM-DD, campo 8 de /etc/shadow
-g número de grupo principal del usuario (GID), campo 4 de /etc/passwd
-G otros grupos a los que puede pertenecer el usuario, separados por comas.
-r crea una cuenta del sistema o especial, su UID será menor al definido en/etc/login.defs en
la variable UID_MIN, además no se crea el directorio de inicio.
-s shell por defecto del usuario cuando ingrese al sistema. Si no se especifica, bash, es el que
queda establecido.
-u UID del usuario, si no se indica esta opción, automáticamente se establece el siguiente
número disponible a partir del último usuario creado.
Ahora bien, realmente no hay prácticamente necesidad de indicar ninguna opción ya que si
hacemos lo siguiente:
#> useradd juan
Se creará el usuario y su grupo, asi como las entradas correspondientes en /etc/passwd,
/etc/shadow y /etc/group. También se creará el directorio de inicio o de trabajo: /home/juan y
los archivos de configuración que van dentro de este directorio y que más adelante se detallan.
Las fechas de expiración de contraseña, etc. Quedan lo más amplias posibles asi que no hay
problema que la cuenta caduque, asi que prácticamente lo único que faltaría sería añadir la
contraseña del usuario y algún comentario o identificación de la cuenta. Como añadir el password
o contraseña se estudiara en un momento y viendo las opciones con '-c' es posible establecer el
comentario, campo 5 de /etc/passwd:
#> useradd -c "Juan Perez Hernandez" juan
Siempre el nombre del usuario es el último parámetro del comando. Asi por ejemplo, si queremos
salirnos del default, podemos establecer algo como lo siguiente:
pág. 122
#> useradd -d /usr/juan -s /bin/csh -u 800 -c "Juan Perez Hernandez" juan
Con lo anterior estamos cambiando su directorio de inicio, su shell por defautl sera csh y su UID
será el 800 en vez de que el sistema tome el siguiente número disponible.
En algunas distribuciones es posible con el siguiente comando:
# useradd –m –p “password” juan
Donde password es el password asignado y juan es el usuario.
Modificar usuarios con usermod
Como su nombre lo indica, usermod permite modificar o actualizar un usuario o cuenta ya
existente. Sus opciones más comunes o importantes son las siguientes:
-c añade o modifica el comentario, campo 5 de /etc/passwd
-d modifica el directorio de trabajo o home del usuario, campo 6 de /etc/passwd
-e cambia o establece la fecha de expiración de la cuenta, formato AAAA-MM-DD, campo 8
de /etc/shadow
-g cambia el número de grupo principal del usuario (GID), campo 4 de /etc/passwd
-G establece otros grupos a los que puede pertenecer el usuario, separados por comas.
-l cambia el login o nombre del usuario, campo 1 de /etc/passwd y de /etc/shadow
-L bloque la cuenta del usuario, no permitiendolé que ingrese al sistema. No borra ni cambia
nada del usuario, solo lo deshabilita.
-s cambia el shell por defecto del usuario cuando ingrese al sistema.
-u cambia el UID del usuario.
-U desbloquea una cuenta previamente bloqueada con la opción -L.
Si quiseramos cambiar el nombre de usuario de 'sergio' a 'sego':
#> usermod -l sego sergio
Casi seguro también cambiará el nombre del directorio de inicio o HOME en /home, pero si no
fuera así, entonces:
#> usermod -d /home/sego sego
Otros cambios o modificaciones en la misma cuenta:
pág. 123
#> usermod -c "supervisor de area" -s /bin/ksh -g 505 sego
Lo anterior modifica el comentario de la cuenta, su shell por defecto que ahora sera Korn shell y
su grupo principal de usuario quedó establecido al GID 505 y todo esto se aplicó al usuario 'sego'
que como se observa debe ser el último argumento del comando.
El usuario 'sego' salió de vacaciones y nos aseguramos de que nadie use su cuenta:
#> usermod -L sego
Eliminar usuarios con userdel
Como su nombre lo indica, userdel elimina una cuenta del sistema, userdel puede ser invocado
de tres maneras:
#> userdel sergio
Sin opciones elimina la cuenta del usuario de /etc/passwd y de /etc/shadow, pero no elimina su
directorio de trabajo ni archivos contenidos en el mismo, esta es la mejor opción, ya que elimina
la cuenta pero no la información de la misma.
#> userdel -r sergio
Al igual que lo anterior elimina la cuenta totalmente, pero con la opción -r además elimina su
directorio de trabajo y archivos y directorios contenidos en el mismo, asi como su buzón de
correo, si es que estuvieran configuradas las opciones de correo. La cuenta no se podrá eliminar
si el usuario esta logueado o en el sistema al momento de ejecutar el comando.
#> userdel -f sergio
La opción -f es igual que la opción -r, elimina todo lo del usuario, cuenta, directorios y archivos
del usuario, pero además lo hace sin importar si el usuario esta actualmente en el sistema
trabajando. Es una opción muy radical, además de que podría causar inestabilidad en el sistema,
asi que hay que usarla solo en casos muy extremos.
pág. 124
Cambiar contraseñas con passwd
Crear al usuario con useradd es el primer paso, el segundo es asignarle una contraseña a ese
usuario. Esto se logra con el comando passwd que permitirá ingresar la contraseña y su
verificación:
#> passwd sergio
Changing password for user prueba.
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
#>
El usuario root es el único que puede indicar el cambio o asignación de contraseñas de cualquier
usuario. Usuarios normales pueden cambiar su contraeña en cualquier momento con tan solo
invocar passwd sin argumentos, y podrá de esta manera cambiar la contraseña cuantas veces lo
requiera.
Password tiene integrado validación de contraseñas comunes, cortas, de diccionario, etc. asi que
si por ejemplo intento como usuario normal cambiar mi contraseña a 'qwerty' el sistema me
mostrará lo siguiente:
$> passwd
Changing password for user prueba.
New UNIX password:
BAD PASSWORD: it is based on a dictionary word
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
$>
Nótese que al ingresar 'qwerty' como contraseña se detectó que es una secuencia ya conocida
como contraseña y me manda la advertencia: "BAD PASSWORD: it is based on a dictionary word",
sin embargo me permite continuar, al ingresar la verificación. Es decir, passwd avisa de malas o
débiles contraseñas pero permite establecerlas si realmente se desea.
pág. 125
Resumiendo entonces, se podría decir que todo este tutorial se reduce a dos líneas de comandos
para crear y dejar listo para trabajar a un usuario en Linux:
#> useradd ana
#> passwd ana
Se crea el usuario 'ana', useradd hace todo el trabajo de establecer el shell, directorio de inicio,
copiar archivos iniciales de configuración de la cuenta, etc. y después passwdestablece la
contraseña. Asi de simple.
passwd tiene varias opciones que permiten bloquear la cuenta '-l', desbloquearla '-u', y varias
opciones más que controlan la vigencia de la contraseña, es decir, es otro modo de establecer los
valores de la cuenta en /etc/shadow. Para más información consulta las páginas del manual:
$> man passwd
Archivos de configuración
Los usuarios normales y root en sus directorios de inicio tienen varios archivos que comienzan
con "." es decir están ocultos. Varían mucho dependiendo de la distribución de Linux que se tenga,
pero seguramente se encontrarán los siguientes o similares:
#> ls -la
drwx------ 2 ana ana 4096 jul 9 09:54 .
drwxr-xr-x 7 root root 4096 jul 9 09:54 ..
-rw-r--r-- 1 ana ana 24 jul 9 09:54 .bash_logout
-rw-r--r-- 1 ana ana 191 jul 9 09:54 .bash_profile
-rw-r--r-- 1 ana ana 124 jul 9 09:54 .bashrc
.bash_profile aquí podremos indicar alias, variables, configuración del entorno, etc. que
deseamos iniciar al principio de la sesión.
.bash_logout aquí podremos indicar acciones, programas, scripts, etc., que deseemos ejecutar al
salirnos de la sesión.
.bashrc es igual que .bash_profile, se ejecuta al principio de la sesión, tradicionalmente en este
archivo se indican los programas o scripts a ejecutar, a diferencia de .bash_profile que configura
el entorno.
pág. 126
Lo anterior aplica para terminales de texto 100%.
Si deseamos configurar archivos de inicio o de salida de la sesión gráfica entonces, en este caso,
hay que buscar en el menú del ambiente gráfico algún programa gráfico que permita manipular
que programas se deben arrancar al iniciar la sesión en modo gráfico. En la mayoría de las
distribuciones existe un programa llamado "sesiones" o "sessions", generalmente esta ubicado
dentro del menú de preferencias. En este programa es posible establecer programas o scripts que
arranquen junto con el ambiente gráfico, sería equivalente a manipular 'bashrc'.
Además Linux permite que el usuario decida que tipo de entorno Xwindow a utilizar, ya sea algún
entorno de escritorio como KDE o Gnome o algún manejador de ventanas como Xfce o Twm.
Dentro del Home del usuario, se creará un directorio o archivo escondido "." , por ejemplo
'.gnome' o '.kde' donde vendrá la configuración personalizada del usuario para ese entorno.
Dentro de este directorio suele haber varios directorios y archivos de configuración. Estos son
sumamente variados dependiendo de la distribución y del entorno. No es recomendable
modificar manualmente (aunque es perfectamente posible) estos archivos, es mucho mas sencillo
modificar vía las interfases gráficas que permiten cambiar el fondo, protector de pantalla, estilos
de ventanas, tamaños de letras, etc.
Resumen de comandos y archivos de administración de usuarios
Existen varios comandos más que se usan muy poco en la administración de usuarios, que sin
embargo permiten administrar aun más a detalle a tus usuarios de Linux. Algunos de estos
comandos permiten hacer lo mismo que los comandos previamente vistos, solo que de otra
manera, y otros como 'chpasswd' y 'newusers' resultan muy útiles y prácticos cuando de dar de
alta a múltiples usuarios se trata.
pág. 127
A continuación te presento un resumen de los comandos y archivos vistos en este tutorial más
otros que un poco de investigación.
Comandos de administración y control de usuarios
adduser
Ver useradd
chage
Permite cambiar o establecer parámetros de las fechas de control de la
contraseña.
chpasswd
Actualiza o establece contraseñas en modo batch, múltiples usuarios a
la vez. (se usa junto con newusers)
id
Muestra la identidad del usuario (UID) y los grupos a los que pertence.
gpasswd
Administra las contraseñas de grupos (/etc/group y /etc/gshadow).
groupadd
Añade grupos al sistema (/etc/group).
groupdel
Elimina grupos del sistema.
groupmod
Modifica grupos del sistema.
groups
Muestra los grupos a los que pertence el usuario.
newusers
Actualiza o crea usuarios en modo batch, múltiples usuarios a la vez. (se
usa junto chpasswd)
pwconv
Establece la protección shadow (/etc/shadow) al archivo /etc/passwd.
pwunconv
Elimina la protección shadow (/etc/shadow) al archivo /etc/passwd.
useradd
Añade usuarios al sistema (/etc/passwd).
userdel
Elimina usuarios del sistema.
usermod
Modifica usuarios.
Archivos de administración y control de usuarios
.bash_logout
Se ejecuta cuando el usuario abandona la sesión.
.bash_profile
Se ejecuta cuando el usuario inicia la sesión.
.bashrc
Se ejecuta cuando el usuario inicia la sesión.
/etc/group
Usuarios y sus grupos.
/etc/gshadow
Contraseñas encriptadas de los grupos.
/etc/login.defs Variables que controlan los aspectos de la creación de usuarios.
/etc/passwd
Usuarios del sistema.
/etc/shadow
Contraseñas encriptadas y control de fechas de usuarios del sistema.
pág. 128
Gestion de cuentas de grupos:
Creación de grupos
El comando groupadd permite añadir un grupo indicando como parámetro el nombre del grupo.
Ejemplo, si deseamos crear un grupo llamado 'alumnos' ejecutaremos:
// Añadir un grupo
$ sudo groupadd alumnos
Modificación de grupos
El comando groupmod permite modificar el nombre de un grupo o el gid del mismo. La sintaxis
es: sudo groupmod [-g nuevo-gid] [-n nuevo-nombre] nombre-grupo, ejemplo:
// Cambiar el gid del grupo profesores
$ sudo groupmod -g 2000 profesores
Eliminación de grupos
Se realiza con el comando groupdel seguido del nombre del grupo, ejemplo:
// Eliminación de un grupo
$ sudo groupdel profesores
Eliminaría el grupo profesores. Si algún usuario tuviera dicho grupo como grupo primario, el
comando groupdel no eliminará el grupo.
Añadir usuarios a un grupo
Se utiliza el comando adduser seguido del nombre del usuario y del nombre del grupo al que
queremos añadirle, ejemplo:
// Añadir a 'juan' al grupo 'profesores'
$ sudo adduser juan profesores
Quitar usuarios de un grupo
Se utiliza el comando deluser seguido del nombre del usuario y del nombre del grupo del que
queremos quitarle, ejemplo:
// Quitar a 'juan' del grupo 'profesores'
$ sudo deluser juan profesores
pág. 129
SUDO
El programa sudo (del inglés substitute user do) es una utilidad de los sistemas
operativos tipo Unix, como Linux, BSD, o Mac OS X, que permite a los usuarios ejecutar programas
con los privilegios de seguridad de otro usuario (normalmente el usuario root) de manera segura.
Se instala por defecto en /usr/bin.
Sudo fue escrito originalmente por Bob Coggeshall y Cliff Spencer en 1980, en el departamento
de ciencias de la computación de la Universidad estatal de Nueva York. La versión actual la
mantiene el desarrollador de OpenBSD Todd C. Miller y se distribuye bajo una licencia BSD.
En 1985 se publicó en el grupo de noticias net.sources una versión mejorada acreditada a Phil
Betchel, Cliff Spencer, Gretchen Phillips, John LoVerso y Don Gworek. Garth Snyder publicó otra
versión mejorada en el verano de 1986 y durante los siguientes cinco años fue mantenido con la
colaboración de muchas personas, incluyendo Bob Coggeshall, Bob Manchek, y Trent Hein.
En 1991 Dave Hieb y Jeff Nieusma escribieron una nueva versión con un formato mejorado para
el fichero /etc/sudoers bajo contrato con la firma consultora The Root Group, versión que
posteriormente fue publicada bajo los términos de la Licencia Pública General
de GNU (GNU/GPL).
Desde 1996 el proyecto es mantenido por Todd Miller con la colaboración de Chris Jepeway y
Aaron Spangler.
Seguro que todo el mundo ha utilizado o como mínimo ha oído hablar de sudo, el comando que
permite ejecutar sentencias con los privilegios de cualquier usuario -incluidos los privilegios de
superusuario- y que es una medida muy interesante para evitar tener que entrar directamente
como estos usuarios con el más tradicional su.
pág. 130
Ilustración 8 La famosa tira cómica de XKCD deja claro qué es lo que permite hacer sudo
En Linux.com han publicado una fantástica introducción a sudo, que significa “substitute user do”
o “super user do” (según como lo usemos), y que como indican en ese artículo realiza una tarea
importante y crucial en muchas distribuciones Linux. Hay cierta polémica en si el uso de sudo es
bueno o malo para la seguridad, pero sea como fuere, seguro que hay un buen montón de
ocasiones en las que os vendrá bien usar el sudo.
En el artículo nos cuentan la historia de sudo, que comenzó a utilizarse en 1.980 y que poco a
poco se fue popularizando hasta llegar a las distribuciones gracias al trabajo de Todd Miller, que
sigue siendo su desarrollador principal.
Las diferencias entre sudo y su son claras, ya que su permite loguearnos como cualquier otro
usuario o como superusuario, mientras que sudo sólo permite ejecutar comandos con los
privilegios de otros usuarios -incluido el superusuario, como ya hemos comentado-. Los riesgos
para la seguridad son menores -aunque podemos seguir cagándola con sudo, por supuesto- y por
eso es bueno que sepáis cómo configurar y utilizar sudo.
pág. 131
La configuración es clave, y para ello es necesario editar -con mimo y cuidado- el
fichero/etc/sudoers. Precaución, amigo conductor, porque un error en este fichero puede tener
consecuencias graves para el sistema. En el artículo explican cómo añadir nuevos perfiles y
usuarios a la lista de los que pueden realizar sudo y con qué privilegios pueden hacerlo, así que
os recomiendo este artículo (en inglés, pero que puedes leer en un español aceptable gracias a la
magia de servicios como Google Translate) para conocer detalles importantes de esa
configuración y uso del famoso comando sudo.
Visudo
Permite la edición del archivo de configuración de sudo sudoers. Invoca al editor que se tenga por
defecto que generalemente es 'vi'. visudo cuando es usado, bloquea el archivo /etc/sudoers de
tal manera que nadie más lo puede utilizar, esto por razones obvias de seguridad que evitarán
que dos o más usuarios administradores modifiquen accidentalmente los cambios que el otro
realizó.
Otra característica importande de visudo es que al cerrar el archivo, verifica que el archivo este
bien configurado, es decir, detectará si hay errores de sintaxis principalmente en sus múltiples
opciones o reglas de acceso que se tengan. Por esta razón no debe editarse /etc/sudoers
directamente (perfectamente posible ya que es un archivo de texto como cualquier otro) sino
siempre usar visudo.
Si al cerrar visudo detecta un error nos mostrará la línea donde se encuentra, y la pregunta "What
now?":
>>> sudoers file: syntax error, line 15 <<<
What now?
Se tienen tres opciones para esta pregunta:
e - edita de nuevo el archivo, colocando el cursor en la línea del error (si el editor soporta
esta función.)
x - salir sin guardar los cambios.
Q - salir y guarda los cambios.
pág. 132
Por defecto el archivo de configuración es /etc/sudoers pero se pueden editar otros archivos que
no sean ese y que se aplique la sintaxis de sudo, y esto se logra con la opción -f(visudo -f
/otro/archivo).
Si tan solo se desea comprobar que /etc/sudoers esta bien configurado se usa la opción -c, toma
por el archivo de configuración por defecto o si no se indica algún otro.
#> visudo -c
/etc/sudoers file parsed OK
La opción -s activa el modo 'estricto' del uso de visudo, es decir no solo se comprobará lo
sintáctico sino también el orden correcto de las reglas, por ejemplo si se define el alias para un
grupo de comandos y este se usa antes de su definición, con esta opción se detectará este tipo de
errores.
Sudoers
Archivo de configuración de sudo, generalmente ubicado bajo /etc y se modifica a través del uso
de visudo. En este archivo se establece quien (usuarios) puede ejecutar que (comandos) y de que
modo (opciones), generando efectivamente una lista de control de acceso que puede ser tan
detallada como se desee.
Es más fácil entender sudo si dividimos en tres partes su posible configuración, estás son:
Alias
Opciones (Defaults)
Reglas de acceso
Por extraño que parezca ninguna de las secciones es obligatoria, o tienen que estar en algún orden
específico, pero la que al menos debe de existir es la tercera, que es la definción de los controles
o reglas de acceso. Se detallará cada uno de estos en un momento. Para los que les gusta saber
más la cuestión técnica es interesante saber que la construcción de un archivo sudoers esta
basado en la forma BNF (Backus-Naur Form), concretamente en versión extendida (EBNF), si
estudiaste algún curso de informática universitario seguramente sabes de lo que hablo. EBNF
describe de una forma precisa y exacta la gramática de un lenguaje, esta se va creando a través
de reglas de producción que a la vez son la base para ser referenciadas por otras reglas.
Afortunadamente no necesitas saber nada de esto, solo entender como se aplican estas reglas.
pág. 133
Alias
Un alias se refiere a un usuario, un comando o a un equipo. El alias engloba bajo un solo nombre
(nombre del alias) una serie de elementos que después en la parte de definición de reglas serán
refiridos aplicados bajos cierto criterio. Es decir, regresando a EBNF estamos creando las reglas
de producción inicial. La forma para crear un alias es la siguiente:
tipo_alias NOMBRE_DEL_ALIAS = elemento1, elemento2, elemento3, ... elementoN
tipo_alias NOMBRE1 = elemento1, elemento2 : NOMBRE2 = elemento1, elemento2
En el segundo caso, separado por ":" es posible indicar más de un alias en una misma definción.
El tipo_alias define los elementos, es decir, dependiendo del tipo de alias serán sus elementos.
Los tipo de alias son cuatro y son los siguientes:
Cmnd_Alias - define alias de comandos.
User_Alias - define alias de usuarios normales.
Runas_Alias - define alias de usuarios administradores o con privilegios.
Host_Alias - define alias de hosts o equipos.
El NOMBRE_DEL_ALIAS puede llevar letras, números o guión bajo ( _ ) y DEBE de comenzar con
una letra mayúscula, se acostumbra a usarlos siempre en mayúsculas.
Los elementos del alias varian dependiendo del tipo de alias, asi que veámoslos por partes asi
como varios ejemplos para que comience a quedar claro todo esto.
Comando Cmnd_Alias
Definen uno o más comandos y otros alias de comandos que podrán ser utilizados después en
alias de usuarios. Ejemplos:
Cmnd_Alias WEB = /usr/sbin/apachectl, /usr/sbin/httpd, sudoedit /etc/httpd/
Indica que a quien se le aplique el alias WEB podrá ejecutar los comandos apachectl, httpd y editar
todo lo que este debajo del directorio /etc/httpd/, nótese que debe de terminar con '/' cuando
se indican directorios. También, la ruta completa a los comandos debe ser indicada.
Cmnd_Alias APAGAR = /usr/bin/shutdown -h 23\:00
Al usuario que se le asigne el alias APAGAR podrá hacer uso del comando 'shutdown' exactamente
pág. 134
con los parámetros como están indicados, es decir apagar -h (halt) el equipo a las 23:00 horas.
Nótese que es necesario escapar el signo ':', asi como los símbolos ' : , = \
Cmnd_Alias NET_ADMIN = /sbin/ifconfig, /sbin/iptables, WEB
NET_ADMIN es un alias con los comandos de configuración de interfaces de red ifconfig y de
firewall iptables, pero además le agregamos un alias previamente definido que es WEB, asi que a
quien se le asigne este alias podrá hacer uso de los comandos del alias WEB.
Cmnd_Alias TODO_BIN = /usr/bin/, !/usr/bin/rpm
A quien se le asigne este alias podrá ejecutar todos los comandos que estén dentro del directorio
/usr/bin/ menos el comando 'rpm' ubicado en el mismo directorio.
NOTA IMPORTANTE: este tipo de alias con un permiso muy amplios menos '!' algo,
generalmente no son una buena idea, ya que comandos nuevos que se añadan después a ese
directorio también podrán ser ejecutados, es mejor siempre definir específicamente lo que se
requiera.
User_Alias
Definen a uno o más usuarios, grupos del sistema (indicados con %), grupos de red (netgroups
indicados con +) u otros alias de usuarios. Ejemplos:
User_Alias MYSQL_USERS = andy, marce, juan, %mysql
Indica que al alias MYSQL_USERS pertenecen los usuarios indicados individualmente más los
usuarios que formen parte del grupo 'mysql'.
User_Alias ADMIN = sergio, ana
'sergio' y 'ana' pertenecen al alias ADMIN.
User_Alias TODOS = ALL, !samuel, !david
Aqui encontramos algo nuevo, definimos el alias de usuario TODOS que al poner como elemento
la palabra reservada 'ALL' abarcaría a todos los usuarios del sistema, pero no deseamos a dos de
ellos, asi que negamos con '!', que serían los usuarios 'samuel' y 'david'. Es decir, todos los usuarios
menos esos dos.
NOTA IMPORTANTE: este tipo de alias con un permiso muy amplios menos '!' algo,
generalmente no son una buena idea, ya que usuarios nuevos que se añadan después al sistema
también serán considerados como ALL, es mejor siempre definir específicamente a los usuarios
que se requieran. ALL es válido en todos los tipos de alias.
pág. 135
User_Alias OPERADORES = ADMIN, alejandra
Los del alias ADMIN más el usuario 'alejandra'.
Runas_Alias
Funciona exactamente igual que User_Alias, la única diferencia es que es posible usar el ID del
usario UID con el caracter '#'.
Runas_Alias OPERADORES = #501, fabian
Al alias OPERADORES pertenecen el usuario con UID 501 y el usuario 'fabian'
Host_Alias
Definen uno o más equipos u otros alias de host. Los equipos pueden indicarse por su nombre (si
se encuentra en /etc/hosts) por nombre de dominio, si existe un resolvedor de dominios, por
dirección IP, por dirección IP con máscara de red.
Ejemplos:
Host_Alias LANS = 192.168.0.0/24, 192.168.0.1/255.255.255.0
El alias LANS define todos los equipos de las redes locales.
Host_Alias WEBSERVERS = 172.16.0.21, web1 : DBSERVERS = 192.168.100.10, dataserver
Se define dos alias en el mismo renglón: WEBSERVERS y DBSERVERS con sus respectivas listas de
elementos, el separador ':' es válido en cualquier definición de tipo de alias.
Opciones (defaults)
Las opciones o defaults permiten definir ciertas características de comportamiento para los alias
previamente creados, para usuarios, usuarios privilegiados, para equipos o de manera global para
todos. No es necesario definir opciones o defaults, sudo ya tiene establecidas el valor de cada
uno, y es posible conocerlas a través de sudo -V (ver en la sección sudo de este tutorial).
Sin embargo, la potencia de sudo está en su alta granularidad de configuración, asi que es
importante conocer como establecer opciones espécificas.
pág. 136
Las opciones o defaults es posible establecerlos en cuatro niveles de uso:
De manera global, afecta a todos
Por usuario
Por usuario privilegiado
Por equipo (host)
Se usa la palabra reservada 'Defaults' para establecer las opciones y dependiendo del nivel que
deseamos afectar su sintaxis es la siguiente:
Global: Defaults opcion1, opcion2 ...
Usuario: Defaults:usuario opcion1, opcion2 ...
Usuario Privilegiado: Defaults>usuario opcion1, opcion2 ...
Equipo: Defaults@equipo opcion1, opcion2 ...
La lista de opciones es algo extensa, pueden consultarse en las páginas del manual (man sudoers)
o en el excelente manual sobre sudo del sitio web de www.rpublica.net,
http://www.rpublica.net/sudo/indice.html#defaults, está en español y define muy claramente lo
que significa cada opción. En este tutorial de LinuxTotal.com.mx me concretaré a ejemplificar
varios ejemplos del uso de establecer opciones.
Los defaults los divide el manual (man sudoers) en cuatro: flags o booleanos, enteros, cadenas y
listas. Veamos entonces algunos ejemplos de uso para cada uno de ellos:
Listas
Permite establecer/eliminar variables de entorno propias de sudo. Los 'Defaults' para variables es
de los menos usados en las configuraciones de sudo y ciertamente de los más confusos. Para
entender como se aplican es más fácil si primero ejecutas como 'root' el comando sudo -V, y al
final del listado encontrarás en mayúsculas las posibles variables de entorno que se pueden
establecer o quitar y que vienen del shell.
Solo existen tres opciones de listas: env_check, env_delete y env_keep, las listas pueden ser
remplazadas con '=', añadidas con '+=', eliminadas con '-=' o deshabilitadas con '!'. Con un par de
ejemplos quedará más claro.
pág. 137
Defaults env_delete -= HOSTNAME
Elimina la variable de entorno 'HOSTNAME', (pero preserva todas las demás que hubiera) y
comandos que se ejecuten bajo sudo y que requieran de esta variable no la tendrían disponible.
Defaults env_reset
Defaults env_check += DISPLAY, PS1
La primera opción 'env_reset' reinicializa las variables de entorno que sudo utilizará o tendrá
disponibles, y solo quedan disponibles LOGNAME, SHELL, USER y USERNAME. La siguiente línea
indica que agregue (+=) a lo anterior, también la variable de entorno DISPLAY a su valor
establecido antes del reset.
Reglas de acceso
Aunque no es obligatorio declarar alias, ni opciones (defaults), y de hecho tampoco reglas de
acceso, pues el archivo /etc/sudoers no tendría ninguna razón de ser si no se crean reglas de
acceso. De hecho podríamos concretarnos a crear solamente reglas de acceso, sin opciones ni
alias y podría funcionar todo muy bien.
Las reglas de acceso definen que usuarios ejecutan que comandos bajo que usuario y en que
equipos. La mejor y (según yo, única manera) de entender y aprender a configurar sudoers es con
ejemplos, asi que directo al grano:
usuario host = comando1, comando2, ... comandoN
Sintaxis básica, 'usuario' puede ser un usuario, un alias de usuario o un grupo (indicado por %),
'host' puede ser ALL cualquier equipo, un solo equipo, un alias de equipo, una dirección IP o una
definición de red IP/máscara, 'comandox' es cualquier comando indicado con su ruta completa.
Si se termina en '/' como en /etc/http/ entonces indica todos los archivos dentro de ese directorio.
daniela ALL = /sbin/iptables
Usuario 'daniela' en cualquier host o equipo puede utiliar iptables.
ADMIN ALL = ALL
Los usuarios definifos en el alias 'ADMIN' desde cualquier host pueden ejecutar cualquier
comando.
%gerentes dbserver = (director) /usr/facturacion, (root) /var/log/*
Un ejemplo más detallado. Los usuarios que pertenezcan al grupo del sistema llamado 'gerentes'
pueden en el equipo llamado 'dbserver' ejecutar como si fueran el usuario 'director' la aplicación
llamada 'facturacion', además como usuarios 'root' pueden ver el contendido de los archivos que
pág. 138
contenga el directorio /var/log.
Lo anterior intoduce algo nuevo, que en la lista de comandos es posible indicar bajo que usuario
se debe ejecutar el permiso. Por defecto es el usuario 'root', pero no siempre tener que asi.
Además la lista 'hereda' la primera definición de usuario que se indica entre paréntesis ( ), por eso
si se tiene más de alguno hay que cambiar de usuario en el comando conveniente, el ejemplo
anterior también sería válido de la siguiente manera:
%gerentes dbserver = /var/log/*, (director) /usr/facturacion
No es necesario indicar (root) ya que es el usuario bajo el cual se ejecutan los comandos por
defecto. También es válido usar (ALL) para indicar bajo cualquier usuario. El ejemplo siguiente da
permisos absolutos.
sergio ALL = (ALL) ALL
Se establece permiso para el usuario 'sergio' en cualquier host, ejecutar cualquier comando de
cualquier usuario, por supuesto incluyendo los de root.
SUPERVISORES PRODUCCION = OPERACIÓN
Una regala formada solo por alias. En el alias de usuario ‘SUPERVISORES’ los usuarios que esten
indicado en ese alias, tendrán permiso en los equipos definidos en el alias de host 'PRODUCCION',
de ejecutar los comandos definidos o listados en el alias de comandos 'OPERACION'.
En este último ejemplo se aprecia lo últil que pueden ser los alias, ya que una vez definida la regla,
solo debemos agregar o eliminar elementos de las listas de alias definidos previamente. Es decir,
se agrega un equipo más a la red, se añade al alias 'PRODUCCION', un usuario renuncia a la
empresa, alteramos el alias 'SUPERVISORES' eliminándolo de la lista, etc.
checo ALL = /usr/bin/passwd *, !/usr/bin/passwd root
Este es un ejemplo muy interesante de la potencia y flexibilidad . Al usuario 'checo', desde
cualquier equipo, tiene permiso de cambiar la contraseña de cualquier usuario (usando el
comando 'passwd'), excepto '!' la contraseña del usuario 'root'. Lo anterior se logra mediante el
uso de argumentos en los comandos. En el primer ejemplo '/usr/bin/passwd *' el asterisco indica
una expansión de comodin (wildcard) que indica cualquier argumento, es decir, cualquier usuario.
En el segundo caso '!/usr/bin/passwd root', si indica un argumento específico 'root', y la '!' como
ya se sabe indica negación, negando entonces el permiso a cambiar la contraseña de root.
pág. 139
Cuando se indica el comando sin argumentos: /sbin/iptables sudo lo interpreta como 'puede usar
iptables con cualquiera de sus argumentos'.
mariajose ALL = "/sbin/lsmod"
Al estar entre comillas dobles un comando, entonces sudo lo interpreta como 'puede hacer uso
del comando lsmod pero sin argumentos'. En este caso el usuario 'mariajose' podrá ver la lista de
módulos del kernel, pero solo eso.
Tags (etiquetas de comandos)
Cuando se definen reglas, en la lista de comandos, estos pueden tener cero (como en los ejemplos
anteriores) o más tags. Existen 6 de estas etiquetas o tags,
NOPASSWD Y PASSWD
Por defecto sudo requiere que cualquier usuario se identifique o auténtifique con su contraseña.
Aprendimos en la sección de 'Opciones' o 'Defaults' que es posible indicar que un usuario o alias
de usuario no requiera de autentificación. Pero el control granular propio desudo, permite ir aun
más lejos al indicar a nivel de comandos, cuáles requieren contraseña para su uso y cuáles no.
gerardo webserver = NOPASSWD: /bin/kill, /usr/bin/lprm, /etc/httpd/conf/
Usuario 'gerardo' en el equipo 'webserver' no requerira contraseña para los comandos listados.
El tag se hereda, es decir no solo el primer elemento de la lista de comandos, sino los
subsiguientes. Suponiendo que el último '/etc/httpd/conf/' elemento, que permite modificar
cualquier archivo contenido en el directorio, si deseamos que use contraseña, lo siguiente lo
conseguirá:
gerardo webserver = NOPASSWD: /bin/kill, /usr/bin/lprm, PASSWD: /etc/httpd/conf/
Aunque ya que solicitar contraseña es el default o defecto preestablecido, lo anterior también
funcionará de la siguiente manera:
gerardo webserver = /etc/httpd/conf/, NOPASSWD: /bin/kill, /usr/bin/lprm,
pág. 140
Unidad 5. Permisos y Atributos del Sistema de Archivos.
Sistema plano de ficheros
La estructura en forma de árbol tiene el inconveniente de que se requiere ir recorriendo el
árbol para ir localizando cada uno de los elementos. Por ello se hace necesario un sistema
mucho más directo.
A cada ficheros se le asocia un número para poder localizarlo directamenta. Dicho
número se llama inodo. Los números de inodos sonel índice del sistema plano de ficheros,
también llamado por ello tabla deinodos. Cada fichero de cada sistema de ficheros tiene un inodo
distintosalvo que se trate de un enlace rígido (hard link). Sin embargo hay inodos que no se
corresponden con ningún fichero.
Un fichero en sentido estricto indica capacidad de contener una secuencia de bytes.
Un inodo indica básicamente la capacidad de tener un nombre asociado al sistema de
ficheros.
pág. 141
Un fichero tiene asociadas funciones de posición y de lectura y escritura
de
información
dentro del fichero. Un inodo es una referencia muy directa a un fichero y a grandes
rasgos tiene asociadas funciones que permiten manejar y cosntruir la estrauctura del árbol
del sistema de ficheros.
Tipos de ficheros:
a. Regular: Son meros almacenes de información. Algunos contiene código
ejecutable.
b. Directorios: Son una tabla con números de inodos y nombres de ficheros.
c. Ficheros especiales: Pueden ser dispositivo tipo carácter o dispositivo
de bloques. El manejo de estos ficheros depende del dispositivo en particular.
d. Fifo: son pipes con nombre. Son propios de System V y en BSD no
existen pero en Linux si están disponibles.
e. Enlaces simbólicos (symbolic links): Son ficheros que contiene un puntero a otro
fichero que podría perfectamente estar en un sistema de ficheros distinto.
f. El Soket: es un fichero especial de 4.3 BSD y se utiliza para comunicar
procesos que pueden estar en máquinas distintas.
g. Enlaces rígidos (hard links): Realmente es un único fichero que puede ser
visto con distintos nombres dentro de un mismo sistema
de ficheros. Es decir se pueden observar como si fueran ficheros
idénticos con el mismo inodo. La información reside en un mismo lugar y lo que
ocurra aparentemente en un sitio ocurrirá instantáneamente en el otro lugar.
Los enlaces de este tipo no pueden ocurrir entre sistemas de ficheros distintos.
No todos los visto sistemas de ficheros soportan hard links ya que es un concepto
muy ligado a los SO tipo Unix
Generalmente los diferentes tipos de ficheros son capaces de aceptar operaciones de
Por
ello
apertura, cierre, lectura y escritura de forma similar.
se puede redirigir una entrada y una salida a diferentes tipos deficheros. Parte de la enorm
e potencia y flexibilidad de los SO tipo Unix
residen en este hecho. Gracias a esto la combinación de entradas salidas entre procesos,
ficheros, dispositivos, etc... resulta muy sencilla y flexible.
pág. 142
Existe una salvedad importante. Los directorios en este sentido son totalmente
especiales y un intento de escribir en un directorio dará siempre un error siempre
aunque sea realizado por 'root'. No tiene sentido permitirlo. Los directorios
se crean, borran, y modifican con comandos específicos para ellos.
Atributos de fecha en ficheros
En Unix y Linux los ficheros en sentido amplio tienen asociadas siempre
tres
fechas.
En
realidad
estas
fechas
están
almacenadas
internamente como
el
número
de
segundos
transcurridos
desde
el '1 de Enero de 1970'.
Una de ellas indica el tiempo del último acceso realizado sobre ese
fichero. La otra indica la fecha de creación (en realidad es la fecha del
ultimo
cambio
de
estado)
de
ese
fichero
y
la
última
y
quizás
más
importante (es la que vemos al consultar con 'ls l') indica la fecha de la ultima
modificación.
En realidad si cambiamos el estado de un fichero por ejemplo cambiando permisos
O el propietario se modificará las fechas de creación
y
del
último
acceso.
Por eso la fecha que hemos denominado de creación puede
ser
posterior
a
la
a la fecha de modificación del fichero.
Cuando se crea un fichero las tres fechas tendrán el mismo valor. Cuando se
lee un fichero se modifica la fecha de acceso del mismo pero acceder al nombre
de un fichero o consultar el estado de un fichero no modifica ninguna fecha.
Su fecha de acceso tampoco ya que en realidad lo que se hace es leer la información del
directorio que lo contiene el cual si que vera modificada su fecha de acceso.
Las fechas de modificación asociadas a los directorios cambian con las altas o bajas de los
elementos dentro del directorio. Esto es debido a que dichas operaciones se consideran
como si fueran escrituras en el ficheroespecial de tipo directorio. Un directorio es al fin y alcabo
una simple tabla. Esto lo recordaremos cuando hablemos de permisos asociados a directorios.
Para modificar las
comando touch.
fechas
de
modificación y de acceso de un fichero se puede usar el
pág. 143
Permisos de ficheros
Usaremos el término fichero en su sentido más amplio. Es decir que el
tema de permisos e aplicable a distintos tipos de ficheros con algunas
matizaciones que explicaremos más adelante. Los ficheros tienen muchos
atributos además de su nombre.
Para ver los más significativos haremos:
$ ls -l
Supongamos que tenemos el siguiente fichero llamado 'kkkkk'
. - r w x r w x r w x 1 root root 14740 abr 15 12:05 kkkkk
l Enlace simbólico
p Fifo con nombre
b Dispositivo de bloques
c Dispositivo de caracteres
d Directorio
En inglés se usan los términos owner , group, y others para designar
respectivamente al propietario, al grupo y a cualquier usuario.
Notación numérica para permisos
Los
permisos de los ficheros son almacenados en formato binario y se puede
referenciar
numéricamente.
Vimos
que
a
cada
permiso
individual
le
asociábamos un número de tres dígitos formado por dos ceros y un tercer número que podía
ser
únicamente 1,
2,
o
4.
Por
ejemplo
el
permiso
de
escritura para un usuario cualquiera era 002. Con estos números se puede codificar
los
permisos de la forma que indicamos en el siguiente ejemplo:
r w x - - w x - r - x Esto equivaldría a un permiso 735
4 2 1 - 0 2 1 - 4 0 1 ( 4+2+1 , 0+2+1 , 4+0+1 = 7,3,5)
pág. 144
Los permisos también pueden representarse como una secuencia de bits.
Un bit es un valor que solo puede valer 0 o 1. En el caso anterior,
podríamos representarlo de la forma 111 010 101 donde 1 indica que si hay
permiso 0 que no lo hay y la posición de cada 0 y cada 1 representa a cada uno
de los permisos.
Umask
Es un comando interno del bash. Se utiliza cuando se crean ficheros.
No podemos profundizar mucho en temas de matemática binaria porquenos saldríamos del te
ma pero la umask se aplica mediante una operación llamada AND NOT.
Consiste en tomar a umask como una máscara
especifican los bits de permisos que se pondrán a cero.
donde
Por ejemplo si queremos abrir un fichero con permisos 664 y tenemos una
umask de 022 obtendremos un fichero 644.
664 110 110 100
022 000 010 010
----------------644 110 100 100
pág. 145
los
bits
a
1
Valor octal
Valor simbólico
Descripción
0
rwx
Lectura, escritura y acceso a directorios
1
rw-
Lectura y escritura
2
r-x
Lectura y acceso a directorios
3
r--
Sólo lectura
4
-wx
Escritura y acceso a directorios
5
-w-
Sólo escritura
6
--x
Sólo acceso a directorios
7
---
Nada
Esto tiene la utilidad de proteger
descuidos durante la creación de ficheros.
el
sistema
frente
a
cierto
tipo
de
Por ejemplo supongamos que un administrador de un sistema considera que por
defecto
todos
los
ficheros
que
el
crea
deberían
carecer
de
permisos de ejecución y de escritura para todo el mundo y que para los usuarios
de su mismo grupo deberían de carecer de permiso de ejecución.
Para ello establecerá una 'umask = 023'. Es decir una umask que elimina los permisos
.w.wx
Para un script que genere ficheros que solo deban ser accesibles para el usuario que los ha
generado usaríamos. 'umask = 077'
El valor predeterminado de la máscara de usuario del sistema en CentOS, es 0022, es decir se
asigna permiso 0755 (-rwxr-xr-x) para nuevos directorios y 0644 (-rw-r--r--) para nuevos archivos.
El sistema jamás permite crear nuevos archivos con atributos de ejecución. El valor
predeterminado se define en una variable de entorno del archivo “/etc/profile” y puede ser
cambiado por el que el administrador del sistema considere pertinente. El valor también puede
establecerse por usuario en el archivo “~/.bash_profile” CentOS.
pág. 146
Comando chmod
Este comando sirve para alterar una serie de atributos del fichero.
Existen dos formas de usarlo. Una indicando el tipo de acceso y a
queremos conceder o eliminar. Existen una serie de atributos
pueden modificar usando este comando.
quien lo
que se
04000 Set uid on execute.
02000 Set gid on execute.
01000 Save text on image after execution.
00400 r Permiso de lectura para el propietario (owner)
00200 w Permiso de escritura para el propietario
00100 x Permiso de ejecución para el propietario
00040 r Permiso de lectura para el grupo (group)
00020 w Permiso de escritura para el grupo
00010 x Permiso de ejecucion para el grupo
00004 r Permiso de lectura para cualquiera (others)
00002 w Permiso de escritura para cualquiera
00001 x Permiso de ejecucion para cualquiera
Consulte las páginas del manual relativas a este comando. Como de costumbre
el manual resulta imprescindible a la hora de recordar la utilización de un
comando pero no a la hora de comprender conceptos nuevos.
No se preocupe con los ejercicios que
perfectamente:
le
proponemos
$ cd /tmp
$ touch chmod.txt
$ ##################################
$ chmod 777 chmod.txt
$ ls -l kk
-rwxrwxrwx .... .... ......
$ ##################################
$ chmod 707 chmod.txt
pág. 147
a continuación comprenderá
$ ls -l kk
-rwx---rwx .... .... ......
$ ##################################
$ chmod 421 chmod.txt
$ ls -l kk
-r---w---x .... .... ......
$ ##################################
$ chmod 124 chmod.txt
$ ls -l kk
---x-w-r-- .... .... ......
$ ##################################
$ # 'chmod 0 chmod.txt ' equivale a 'chmod 000 chmod.txt '
$ chmod 0 chmod.txt
$ ls -l kk
---------- .... .... ......
$ ##################################
$ chmod +r chmod.txt
$ ls -l kk
-r--r--r-- .... .... ......
$ ##################################
$ chmod +x chmod.txt
$ ls -l chmod.txt
-r-xr-xr-x .... .... ......
$ ##################################
$ chmod -r chmod.txt
$ ls -l chmod.txt
---x--x--x .... .... ......
$ ##################################
pág. 148
$ chmod u+r chmod.txt
$ ls -l chmod.txt
-r-x--x--x .... .... ......
$ ##################################
$ chmod a-x chmod.txt
$ ls -l chmod.txt
-r-------- .... .... ......
$ ##################################
$ chmod g+x chmod.txt
$ ls -l chmod.txt
-r----x--- .... .... ......
$ ##################################
$ chmod o+x chmod.txt
$ ls -l chmod.txt
-r----x--x .... .... ......
$ ##################################
$ chmod a+rwx chmod.txt
$ ls -l chmod.txt
-rwxrwxrwx .... .... ......
rm chmod.txt
pág. 149
Opciones de chmod.
-R
Cambia permisos de forma descendente en un directorio dado. Es la única opción de los
estándares POSIX.
-c
Muestra cuáles archivos han cambiado recientemente en una ubicación dada
-f
Omite mostrar errores de archivos o directorios que haya sido imposible cambiar
-v
Descripción detallada de los mensajes generados por el proceso
Para obtener una descripción completa del uso de chmod, ejecute:
man 1 chmod
Comando chown
El comando 'chown' sirve para cambiar el UID y el GID de un fichero. Esto solo se puede
hacer si tenemos los permisos para ello.
Normalmente su uso está reservado a 'root' y por ello no diremos nada más. Es muy
posible que si usted usa Linux en un ordenador personal necesite algunos de estos
conocimientos pero se sale de los propósitos de este curso. Le basta con saber que existe
y para que sirve.
Concesión de acceso por parte del kernel
Explicaremos el funcionamiento de los permisos de la forma más precisa que nos sea posible.
Para ello usaremos unas abreviaturas que ya conocemos.
EUID es el Identificador de usuario efectivo de un proceso
EGID es el Identificador de grupo efectivo de un proceso
UID en un fichero es un atributo que identifica al propietario.
GID en un fichero es un atributo que identifica al grupo del propietario.
pág. 150
En realidad hablamos de propietario como el usuario que creo el fichero.
El Kernel realizará el siguiente test para conceder a un proceso el acceso de
un fichero.
cierto
tipo
a
1. Si el EUID del proceso es 0 se da acceso. (root puede hacer lo que sea).
2. Si el EUID del proceso es igual al UID del owner (propietario del fichero) se concede el
acceso si los permisos de usuario rwx son los adecuados.
3. Si el EUID del proceso es distinto al UID del owner, y si el EGID del proceso es igual al
GID del owner, se concede el acceso si los permisos de grupo rwx son los adecuados.
4.Si el EUID del proceso es distinto al UID del owner, y si el EGID
del proceso es distinto al GID del owner, se concede el acceso si
others rwx son los adecuados.
los
permisos
de
los
NOTA : el comando rm permite borrar cualquier fichero sea cual sean los permisos cuando el proceso
tiene un EUID coincidente con el propietario el fichero. Únicamente ocurre que si el fichero esta protegido
contra escritura suele pedir (dependiendo de la configuración) confirmación antes de borrarlo. El
permiso para borrar un fichero no se guarda como atributo del fichero. Esto se hace a nivel de
directorio y pasamos a explicarlo inmediatamente.
Significado de los permisos en directorios
Para
entender
como funcionan los permisos aplicados a un directorio
hay
que imaginar que un directorio es un fichero normal que solo contiene una
tabla en la que se relacionan los ficheros presentes en ese directorio.
En
todos los directorios existen siempre un par de entradas obligadas que son
'.' y '..' para el directorio actual y para el directorio padre respectivamente.
pág. 151
Vamos a explicarlo sobre la marcha a la vez que hacemos el ejercicio.
Recuerde usar un usuario normal (distinto de root) para realizar los ejercicios.
$ cd /tmp
$ mkdir otromas
$ cd otromas
$ echo > k1
$ echo > k2
$ cd /tmp
$ chmod 777 otromas
Para ver como ha quedado los permisos hacemos...
$ ls -ld otromas
Para ver que ficheros contiene el directorio “otromas” hacemos...
$ ls otromas
Si un directorio
no tiene permiso de lectura,
cualquier comando incluido ls averiguar cual es su contenido.
resultara imposible
para
Sin abandonar la sesión anterior continuamos el ejercicio
Eliminamos los premisos de lectura del directorio kk
$ chmod -r otromas
$ ls -ld otromas
Nos dara un resultado, pero si ejecutamos el siguiente codigo
$ ls -l otromas
Esto nos podría mandar un mensaje como este “ls: otromas: Permiso denegado”
En este intante podemos entrar dentro del directorio
Incluso podemos crear un nuevo fichero pero ya no podemos saber cual es el contenido del
directorio.
pág. 152
$ cd otromas
$pwd
Debemos ver lo siguiente;
/tmp/ otromas
Ahora crearemos un tercer archive
$ echo > k3
Y al dar el comando siguiente nos daremos cuenta que ya no tendremos permisos
$ ls -l
ls: .: Permiso denegado
Hemos podido meternos dentro del directorio “otromas” porque aun tenemos permiso para ello
pero seguimos sin poder saber cual es su contenido.
$ cd /tmp
Si no se tiene permiso de ejecución en un directorio no se podrá hacer cd
a ese directorio, ni a ninguno de los directorios que cuelgan de el.
Esto imposibilita todas las operaciones que utilicen ese directorio como parte del camino.
Sin abandonar la sesión anterior continuamos el ejercicio
Ahora eliminamos permiso de ejecución
$ chmod -x otromas
$ ls -ld otromas
Nos mostrara algo como lo siguiente;
d-w--w--w- 2 ..... ...... kk
pág. 153
Ahora intentamos entrar
$ cd otromas
Y nos mandara un mensaje parecido al siguiente;
bash: cd: otromas: Permiso denegado
Nos damos cuenta que no hemos podido entrar
$ rm kk/k2
bash: cd: otromas: Permiso denegado
Tampoco nos deja borrar el fichero desde fuera
Recuperamos permiso de ejecución
$ chmod +x otromas
$ ls -ld kk
$ rm kk/k2
$ ls otromas
k1
Si no tiene permiso de escritura no se podra dar
modificaciones en la tabla lo que se traduce en que no se pueden borrar
sus ficheros ni crear otros nuevos, ni renombrar ficheros.
Sin abandonar la sesión anterior continuamos el ejercicio
Ahora eliminaremos permisos de escritura
$ chmod 666 otromas
$ ls -ld otromas
Ahora no tenemos permiso de escritura
$ cd otromas
pág. 154
altas,
baja
o
$ ls
rm: ¿borrar `k1'? (s/n) s
rm: k1: Permiso denegado
$ echo > k3
bash: k3: Permiso denegado
$ touch k3
touch: k3: Permiso denegado
Sin permiso de escritura en el directorio no se pueden crear ficheros nuevos dentro de el ni borrar
ficheros pero los ficheros son perfectamente accesibles
$ echo "Mensaje de prueba" > k1
$ cat k1
Vamos a limpiar
$ chmod 777 /tmp/ otromas
$ rm /tmp/ otromas /*
$ rmdir /tmp/ otromas
pág. 155
Unidad 6.- Herramientas básicas del Sistema Operativo.
Comandos de uso básico, muévete por la consola.
Para realizar el siguiente ejercicio iniciaremos instalando los siguientes paquetes que
complememtaran elementos necesarios para poder realizar las tareas en la consola y poder hacer
uso de los comandos que se demostraran en el ejercicio:
# yum -y install man perl less file man-pages-es finger
El commando makewhatis sirve para generar un índice de las páginas de manual presentes en el
sistema.
# Makewhatis
Una vez ejecutado el comando esperaremos unos segundos o minutos dependiendo del Hw
disponible para la generación de los manuales.
Generaremos un usuario común para poder realizar el siguiente ejercicio:
Ejecutaremos el siguiente comando;
# useradd usuarioconsola
Después asignaremos el password a nuestro usuario;
# passwd usuarioconsola
Le asignaremos un password
Cierre la sesión de root ejecutando el mandato exit:
# Exit
pág. 156
Ejercicio;
Nos loguearemos con nuestro usuario “usuarioconsola” en una terminal para la realización del
ejercicio;
Cambiar de usuario a super-usuario.
Ejecute el mandato “su” sin argumentos e ingrese la clave de acceso de “root” cuando se le
solicite:
$ su
Con el siguiente comando visualizaremos lo que se conoce como variables de entorno:
# echo $USER; echo $LOGNAME; echo $SHELL; echo $PATH; echo $HOME
Observe que aunque se tienen privilegios de “root”, se carece de las variables de entorno de éste,
por lo cual algunos mandatos sólo se podrán ejecutar si se específica la ruta exacta de éstos
(ejemplos: /sbin/service, /sbin/chkconfig, /sbin/fsck y /sbin/fdisk).
Ahora nos sadremos de la consola con el siguiente comando.
# Exit
Ejecutando el comando “su” acompañado de la opción “-l” ingresamos la clave de acceso de
“root” una vez que nos lo ordene:
su –l
Ejecutamos ahora el comando y podremos ver las variables de entorno:
echo $USER; echo $LOGNAME; echo $SHELL; echo $PATH; echo $HOME
Observe que además de los privilegios de “root”, se tienen también de las variables de entorno
de éste, pues en realidad se ha realizado un ingreso (login) como “root”.
Nos volvemos a salir con el siguiente comando
“usuarioconsola”
para regresar como usuario regular
Exit
Ejecutando el siguiente comando nos mostrara la informacion del sistema:
$ uname –a
$ hdparm en suse y el centos con parámetros.
pág. 157
Lo anterior nos mostrará el nombre del núcleo, nombre de anfitrión, número de lanzamiento del
núcleo, versión del núcleo de Linux, tipo de microprocesador, plataforma del sistema y nombre
del sistema operativo, algo parecido a lo siguiente:
Linux localhost.localdomain 2.6.32-71.29.1.el6.i686 #1 SMP Mon Jun 27
18:07:00 BST 2011 i686 i686 i386 GNU/Linux
Ejecutando el siguiente comando nos mostrara el nombre de usuario que está usted está
utilizando:
$ whoami
Con el siguiente comando nos mostrara los usuarios que están conectados en el sistema y dónde
lo están haciendo:
$ who
Con el siguiente nos mostrara cuáles usuarios están conectados en el sistema, en qué tipo de
terminal lo están haciendo y qué están haciendo o ejecutando:
$w
Con el siguiente nos mostrara el grupo al que pertenece en caso de pertenecer a alguno:
$ id
Con el siguiente comando podrá visualizar cuáles usuarios están conectados en el sistema, en qué
tipo de terminal lo están haciendo y mostrar la información de usuario definida en el archivo
/etc/passwd:
$ finger
Ejecutando el siguiente podrá ver bitácora de acceso de los más recientes ingresos a sistema de
todos los usuarios existentes en el sistema;
$ lastlog
Con el siguiente podremos visualizar la bitácora, con los ultimos accesos hacia el sistema;
$ last
Con el siguiente podremos ver los privilegios de root de la bitácora de intentos fallidos de acceso
al sistema;
pág. 158
$ su -l root -c "lastb"
Ejecute lo siguiete, esto devolverá que /etc/hosts es un archivo de texto:
$ file /etc/hosts
Ejecutando lo siguiente, podremos ver que /boot/grub/e2fs_stage1_5 es un archivo que carga el
boot y sus propiedades:
$ file /boot/grub/e2fs_stage1_5
Ejecutando el siguiente, nos mostrara el directorio en el cual estamos ubicados:
$ pwd
Para poder cambiarnos de directorio utilizaremos el comando cd, de la guiente forma:
$ cd /usr/local
Ahora ejecutaremos de nuevo el siguiente comando y podremos ver que el directorio a cambiado:
$ pwd
Si utilizamos el comando cd sin argumentos, nos devolverá al hogar el usuario que estemos
usando:
$ cd
Ejecute nuevamente el mandato “pwd” para verificar que se encuentra en su directorio de inicio.
Ahora ejecutamos el comando, el cual listara los archivos contenidos en la ruta que describamos,
sin necesidad de cambiarnos de directorio:
$ ls /usr/local
Ejecutando el comando siguiente listara los archivos directos del directorio donde estemos
ubicados, en este caso no debe mostrar ninguno pues nos encontramos en el home de nuestro
usuario:
$ ls
Ahora si ejecutamos el siguiente, podremos ver los archivos ocultos
$ ls –a
Ejecutando el siguiente nos mostrara los mismos archivos per de manera ordenada por nombre,
pág. 159
los atributos y permisos:
$ ls –la
Ejecutando el siguiente, nos mostrara los archivos en orden inverso:
$ ls -lar
Ejecutando el siguiente nos los mostrara por nombre, en orden inverso y el tamaño de los
archivos:
$ ls -hlar
Ejecutando el siguiente, mostrara los permisos, los atributos además de que los ordenara por
tamaño:
$ ls -Sla
Ejecutando el siguiente mostrara lo mismo que el comando anterior pero en orden inverso:
$ ls –Slar
Ejecutando el siguiente, mostrara los permisos y atributos, pero el orden lo realizara por fecha de
modificacion:
$ ls –tla
Ejecutando el siguiente será lo mismo pero en orden inverso:
$ ls -tlar
Ejecutando el siguiente nos mostrara lo mismo agregando el tamaño de los archivos:
$ ls -htlar
Ejecutando el siguiente mostrara la información del inodo que corresponde a cada archivo:
$ ls -ia
Ejecutando el siguiente, mostrara también el detalle del inodo de cada archivo:
$ ls -lia
pág. 160
El comando touch crea archivos, pero se pueden generar también en cadenas, es decir generar
varios archivos con un comando, ejecuaremos el siguiente para generar archivos vacios:
$ touch texto1 texto2 texto11 texto12 texto136 texto246
$ touch textoA textoB textoaa textoAB textoabc textoABC
Ejecutando el siguiente, nos mostrara como, común el valor 1 y tomando como universo el *, de
esta manera los archivos que mostrara serán todos lo que contenga 1 entre “algo y algo”
$ ls texto*1*
Ejecutando el siguiente comando, nos listara todos los archivos que inicien con la cadena texto1,
pero solo los que carecen de 1 en cualquier parte después de la cadena descrita:
$ ls texto[!*1]*
Ejecutando el siguiente comando nos listara todos los archivos que inician con la cadena texto,
pero solo los que tienen 3 caracteres consecutivamente:
$ ls texto???
Ejecutando el siguiente, nos mostrara todos lo que inician con la cadena texto, pero solo 2
caracteres consecutivos:
$ ls texto??
Ejecutando el siguiente solo listara los archivos que inicien con la cadena texto, pero solo aquellos
que incluyan números después de la cadena antes descrita:
$ ls texto[[:digit:]]*
Ejecutando el siguiente listara solo los archivos que inician con la cadena texto, pero solo aquellos
que terminan con letras minusculas:
$ ls texto[[:lower:]]*
Ejecutando la siguiente nos listara solo los archivos que inicien con la cadena texto y que terminan
con letras mayusculas:
$ ls texto[[:upper:]]*
Ejecutando el siguiente nos mostrara los archivos que contengan la cadena texto y solo los que
terminan con caracteres distintos de numeros:
pág. 161
$ ls texto*[![:digit:]]
Ejecutando lo siguiente nos listara los archivos que inician con la cadena texto, pero solo aquellos
que terminan con la letra c minúscula o C mayuscula:
$ ls texto*[cC]
Ejecutando el siguiente nos listara todos los archivos que contengan la cadena texto, pero solo
aquellos que cualquier carácter distindo de c minúscula o C mayuscula:
$ ls texto*[!cC]
Ejecutando el siguiente comando, listar todos lo archivos con la cadena texto pero solo los
archivos qe incluyan la letra a, A o el número 1 despues de dicha cadena:
$ ls texto[!aA1]*
Con el siguiente comando crearemos un directorio nuevo llamado ejercicios1:
$ mkdir ejercicios1
Ingresamos dentro de la carpeta con el siguiente comando
$ cd ejercicios1
Y dentro creamos otro directorio llamado UNO con el comando siguiente:
$ mkdir UNO
Nos salimos de la carpeta para realizar este proceso pero desde el directorio original es decir crear
un directorio fuera del directorio con el siguiente comando:
$ mkdir ejercicios1/DOS
Ahora ejecutamos lo siguiente para intentar generar otro directorio denominado “UNO”, pero
dentro del directorio «ejercicios2» (el cual es inexistente).
$ mkdir ejercicios2/UNO/
pág. 162
Lo anterior devolverá un mensaje de error como el siguiente:
mkdir: no se puede crear el directorio «ejemplos2/uno»: No existe el archivo
o el directorio
A fin de poder crear el directorio “UNO”, dentro del directorio «ejercicios2», es necesario crear
primero «ejercicios2». Sin embargo puede indicarle a mkdir que genere toda la ruta añadiendo la
opción -p (path):
$ mkdir -p ejercicios2/uno
Para verificar que esta creada podemos ejecutar lo siguiente:
$ ls
Y ver que existe ya el directorio ejercicios2, y después ejecutar;
$ ls ejercicios2
Y verificar que existe UNO destro de ejercicios2.
El comando cp sirve para copiar archivos, con el siguiente comando copiaremos un archivo dentro
del directorio ejercicios2
$ cp /etc/fstab ~/ejercicios1/
Vuelva a utilizar el mandato cp de este modo:
$ cp /etc/passwd ~/ejercicios1/
Con estos dos procedimientos, se habrán copiado dos distintos archivos (/etc/fstab y
/etc/passwd) dentro del directorio ejericicios1
Intente copiar el directorio ~/ejemplos1/ como el nuevo directorio ~/copia1, ejecutando lo
siguiente:
$ cp ~/ejercicios1/ ~/copia1
Lo anterior devolverá un error porque ~/ejemplos1 es un directorio:
$ cp: se omite el directorio «ejercicios1/»
Para poder llevar acabo la tarea de la copia de un directorio con su contenido hay que utilizar la
opción “-r” por la recuisividad. Ejecute la tarea de la siguiente forma:
$ cp -r ~/ejercicios1/ ~/copia1/
pág. 163
Podremos ver el contenido de ambos directorios utilizando el mandato “ls” con la opción “-l”:
$ ls -l ejercicios1/ copia1/
El comando rm sirve para eliminar archivos y directorios, ahora lo usaremos de la siguiente forma,
elimine el directorio copia1, ejecutando lo siguiente:
$ rm -fr ~/copia1/
Se puede lograr una copia de un directorio, conservando todos los atributos y permisos del
contenido del directorio original, utilizando el mandato “cp# con la opción “-a”:
$ cp -a ~/ejercicios1/ ~/copia1/
Podremos realizar una copia de un directorio, conservando todos los atributos y permisos del
contenido del directorio original, pero sólo copiando los archivos que cambiaron respecto de el
directorio de origen y viendo una salida descriptiva, utilice el mandato cp con las opciones -auv:
$ cp -auv ~/ejercicios1/ ~/copia1/
Visualice de nuevo el contenido de ambos directorios utilizando el mandato ls con la opción -l:
$ ls -l ~/ejercicios1/ ~/copia1/
Utilice el mandato “touch” para cambiar la fecha de modificación del archivo ~/ejericios1/fstab:
$ touch ~/ejercicios1/fstab
Con el comando “cp” y la opción “-a” se realiza una copia exacta del directorio de origen con todo
y sus contenidos, “-u” para realizar solo la copia de los contenidos nuevos y “–v” para visualizar la
salida de una manera mas detallada:
$ cp -auv ~/ejercicios1/* ~/copia1/
Ejecutamos nuevamente el comando mkdir y generamos un directorio con el nombre “nuevo”
dentro del directorio de ejercicios1;
$ mkdir ~/ejercicios1/nuevo
Ingresamos al directorio de “ejercicios1”para continuar y ejecutamos lo siguiente:
$ cd ~/ejercicios1/
Listamos el contenido de este directorio, ejecutando lo siguiente:
$ ls
Nos mostrara los archivos “fstab” y “passwd” y el directorio “nuevo”:
pág. 164
$ adicional fstab passwd
Con el comando “mv” moveremos los archivos de lugar, mostrando su funcionamiento con el
siguiente coamando:
$ mv fstab nuevo/
Examine el contenido del directorio “ejercicios1”utilizando de nuevo el mandato “ls”;
$ ls
Ingresamos al directorio “nuevo”con el comando siguiente;
$ cd nuevo
Visualizamos nuevamente el contenido del directorio de trabajo actual ejecutando el siguiente
comando;
$ ls
Regresamos al directorio “ejercicios1”que se encuentra un nivel arriba utilizando el coamando;
$ cd ../
Eliminamos el archivo “passwd” utilizando el comando “rm” de la siguiente forma;
$ rm passwd
Hacemos lo mismo con el archivo “fstab” que esta dentro de directorio “nuevo”;
$ rm nuevo/fstab
Y eliminamos el directorio “nuevo” de la siguiente forma;
$ rmdir nuevo
Creamos un nuevo sub-directorio con el nombre “NuevoDir1”;
$ mkdir NuevoDir1
Accesamos a este nuevo directorio:
$ cd NuevoDir1
Ejecutamos lo siguiente:
$ mkdir Nuevo Directorio
Listamos el contenido actual mostrando una sola columna:
pág. 165
$ ls -1
Lo anterior creó dos nuevos directorios, uno con el nombre “Nuevo” y otro con el nombre
“Directorio”, por lo que mostrara los siguientes archivos o carpetas:
$ Directorio Nuevo
Ejecutando el comando de la siguiente forma, solo que en esta ocasión utilizará una diagonal
inversa antes del espacio:
$ mkdir Nuevo\ Directorio
Listamos de nueva cuenta el contenido del directorio de trabajo actual mostrando una sola
columna:
$ ls -1
Lo anterior creó un nuevo directorio denominado “Nuevo Directorio”, lo que nos mostrara un
listado como la siguiente:
$ Directorio
Nuevo
Nuevo Directorio
La diagonal inversa funciona como carácter de escape para indicar que espacio entre “Nuevo” y
“Directorio” es parte del nombre el directorio que vamos crear.
Una vez que hemor realizado esta tarea borraremos el directorio con todo su contenido desde el
home con un comando, pero regresando al home
$ cd
Y dando un “ls” podremos ver el directorio o dirctorio principales
$ ls
Y para borrar la carpeta le daremos el siguiente comando;
$ rm –r ejercicios1
pág. 166
Lo cual hara un borrado recursivo, lo cual ralizara un borrado completo
Siempre es recomendable pensar de manera detenida cuando se va a realizar un borrado de
archivos o directorios, o tener en cuenta si se tienen respaldos ola vitalidad de los archivos a
los que se les va a aplicar dicha tarea.
Compresión y descompresión de archivos.
En Linux hay diversas herramientas para empaquetar y comprimir archivos, tomando en cuenta
que empaquetar es juntar dos o más archivos en un solo archivo (paquete) y comprimir es
tomar este archivo-paquete y comprimirlo a continuación te muestro un resumen de las más
comunes, de acuerdo a la extensión que comunmente se acostumbra ponerles.
Ficheros gz
Para comprimir ficheros en formato .gz, se utiliza el siguiente comando:
gzip -9 fichero
-9 : le indica a gz que utilice el mayor factor de compresión posible.
Para descomprimir ficheros .gz, se utilizara el siguiente comando:
gzip -d fichero.gz
-d : indica descompresión
Ficheros bz2
Para comprimir ficheros en formato bz2, se utiliza el siguiente comando:
bzip fichero
Para descomprimir ficheros .bz2, se usa el comando siguiente:
bzip2 -d fichero.bz2
-d : indica descompresión.
Nota: Tanto el compresor gzip como bzip2, solo comprimen ficheros, no directorios, para comprimir
directorios (carpetas), se debe de usar en combinación con tar.
Ficheros tar.gz
Para comprimir ficheros en formato tar.gz, se utiliza el siguiente comando:
tar -czfv archivo.tar.gz ficheros
-c : indica a tar que cree un archivo.
-z : indica que use el compresor gzip
pág. 167
-f : indica a tar que el siguiente argumento es el nombre del fichero.tar
-v : indica a tar que muestre lo que va empaquetando
Para descomprimir ficheros con extensión tar.gz, se usa el siguiente comando:
tar -xzvf archivo.tar.gz
-x : le dice a tar que extraiga el contenido del fichero tar.gz
-z : le indica a tar que esta comprimido con gzip
-v : va mostrando el contenido del fichero
-f : le dice a tar que el siguiente argumento es el fichero a descomprimir.
Para poder ver el contenido de un fichero comprimido en tar.gz, se usa el siguiente comando:
tar -tzf archivo.tar.gz
Ficheros tar.bz2
Para comprimir en tar.bz2, se hace uso del parámetro pipeline ( | ), que consiste en que “filtra”
la salida de un comando a la entrada de otro, como es en este ejemplo: tar empaqueta los
distintos ficheros o directorios y su salida lo pasa al comando bzip2 para que este lo comprima
y el resultado de este, lo redirecciona ( > ) al fichero final tar.bz2
Para realizar una compresión de tipo gzip ejecutaríamos el comando de la forma que sigue;
$ tar zcf comprimido.tar.gz pixmaps/
Para poder ver el contenido del archivo comprimido ejecutaremos el comando de la siguiente
forma:
$ tar ztvf comprimido.tar.gz
Para extraer el contenido del archivo, ejecutariamos lo siguiente:
$ tar zxvf comprimido.tar.gz -C ~/archivosgz/
Para realizar una extracción de los archivos de manera selectiva, ejecutaríamos lo siguiente:
$ tar zxvf foo.tar.gz -C ~/ejemplos1/ --wildcards '*.png'
tar -c ficheros | bzip2 > archivo.tar.bz2
Para descomprimir ficheros tar.bz2, se utiliza el siguiente comando:
bzip2 -dc archivo.tar.bz2 | tar -xv
Y para ver el contenido de un fichero tar.bz2, se usa el siguiente comando:
pág. 168
bzip2 -dc archivo.tar.bz2 | tar –t
Para realizar una compresión en formato BZ2, ejecutaremos lo siguiente:
$ tar jcf comprimido.tar.bz2 pixmaps/
Para poder ver los archivos que están contenidos dentro del archivo, será necesario ejecutar lo
siguiente:
$ tar jtvf comprimido.tar.bz2
Para extraer el contenido del archivo comprimido es necesario ejecutar el comando de extracción
de la siguiente manera:
$ tar jxvf comprimido.tar.bz2 -C ~/archivosbz2/
Para poder realizar una extracción selectiva se ejecutaria de la siguiente manera:
$ tar jxvf comprimido.tar.bz2 -C ~/archivosbz2/ --wildcards '*.png'
Ficheros zip
Para poder comprimir en formato zip, se usara el comando siguiente:
zip archivo.zip ficheros a comprimir
Para poder descomprimir los ficheros zip, se usa el siguiente comando:
unzip archivo.zip
Para ver el contenido de un fichero zip, se pone el siguiente comando:
unzip -v archivo.zip
Ahora procederemos a realizar la comprension y descompresion utilizando el format zip, que es
el analogo de winzip en windows.
Realizamos la compresión del archivo de la siguiente manera
$ zip -r comprimido.zip pixmaps/
El siguiente mostrara el contenido del archivo comprimido.zip:
$ unzip -l comprimido.zip
pág. 169
Para extraer el contenido del archivo comprimido.zip dentro del directorio ~/archivos/,
ejecutando lo siguiente:
$ unzip comprimido.zip -d ~/archivos/
Si la salida le pregunta si desea sobre-escribir los archivos existentes, responda que si a todo
pulsando la letra A y “enter”.
Para extraer una selección de archivos que están dentro el comprimido, realizaríamos la tarea de
la siguiente forma;
$ unzip comprimido.zip -d ~/archivos/ *.png
Si la salida pregunta nuevamente presione A para sobreescribir:
Para extraer los archivos con la misma extencion pero de segundo nivel tendríamos que hacerla
de la siguiente forma;
$ unzip comprimido.zip -d ~/archivos/ */*.png
Si necesita ayuda con el comando con respecto a sus opciones o el uso, puede hacer la consulta
de ambos, tanto de zip, como de unzip con los siguientes comandos;
$ man 1 zip
$ man 1 unzip
Fichero XZ
Para realizar una compresión de tipo XZ necesitaríamos ejecutarlo de la siguiente forma:
$ tar Jcf comprimido.tar.xz pixmaps/
Para poder visualizar el contenido del archivo comprimido es necesario ejecutar el comando de
la siguiente forma:
$ tar Jtvf comprimido.tar.xz
Para extraer el contenido del archivo necesitaríamos realizar la ejecución del comando de la
siguiente forma:
$ tar Jxvf comprimido.tar.xz -C ~/archivosXZ/
Para extraer los archivos de manera selectiva, tendríamos que ejecutarlo de la siguiente manera:
pág. 170
$ tar Jxvf comprimido.tar.xz -C ~/archivosXZ/ --wildcards '*.png'
Ficheros rar
Para comprimir en formato rar, se usara el siguiente comando:
rar -a archivo.rar ficheros
Para descomprimir ficheros en formato rar, se utiliza el siguiente comando:
unrar -x archivo.rar
Para ver el contenido de un fichero rar, se usa el siguiente comando:
unrar -v archivo.rar
unrar -l archivo.rar
Tengo que decir que todos estos comandos, es para hacerlo desde terminal una terminal, como
ejemplo os vendría de maravilla si os quedarais sin entorno gráfico y tuvieseis que descomprimir
algún archivo.
Pero para los que no quieran usar la terminal, pueden estar tranquilos, que existen muy buenas
interfaces gráficas. Como lo es File Roller.
Ejercicio;
Lo primero que haremos para llevar acabo esta práctica, será verificar o realizar la instalación de
los paquetes necesarios para llevar acabo la practica, como la instalación que se hizo fue minima,
lo primero que haremos será instalar dichos paquetes que en este caso son los compresores:
Iniciamos la secion como root, para poder ejecutar el siguiente comando el cual realizara la
instalación
# yum install zip unzip gzip tar bzip2 xz
Una vez que estén instalados los paquete nos salimos para realizar las tareas con un usuario
ordinario, podemos utilizar cualquiera de los usuarios que ya hemos creado o podremos crear
uno nuevo con el siguiente comando;
# useradd compresor
Y le asignamos un password
# passwd compresor
pág. 171
Seguido nos logueamos con este;
Para poder llevar a cabo el ejercicio necesitamos realizar la compresión de alguna carpeta o
algún archivo, para esto realizaremos la copia de una carpeta del mismo sistema, para fines
ilustrativos utilizaremos la carpeta llamada pixmaps, que se encuentra en la ubicación
/usr/shae/pixmaps, para lo cual la copiaremos integra al home del usuario que estemos usando
con el siguiente comando;
$ cp –a /usr/share/pixmaps .
Ficheros tar
Para poder empaquetar ficheros, utilizamos el siguiente comando:
tar -cvf archivo.tar /dir/a/comprimir/
-c : indica a tar que cree un archivo.
-v : indica a tar que muestre lo que va empaquetando.
-f : indica a tar que el siguiente argumento es el nombre del fichero.tar.
Para poder desempaquetar los ficheros .tar, utilizamos el siguiente comando:
tar -xvf archivo.tar
-x : indica a tar que descomprima el fichero.tar.
-v : indica a tar que muestre lo que va desempaquetando.
-f : indica a tar que el siguiente argumento es el nombre del fichero a desempaquetar.
Si se quiere ver el contenido de un fichero .tar, se utiliza el siguiente comando:
tar -tf archivo.tar
-t : Lista el contenido del fichero .tar
-f : indica a tar que el siguiente argumento es el nombre del fichero a ver.
Compresion y desconpresion de archivos con formato tar.
Para comprimir un archivo o carpeta ejecutaríamos lo siguiente:
$ tar cf comprimido.tar pixmaps/
Para mostrar el contenido el archivo comprimido en formato tar, ejecutaríamos lo siguiente:
$ tar tvf comprimido.tar
Para extraer el contenido del comprimido, necesitaríamos ejecutar el siguiente comando;
pág. 172
$ tar xvf comprimido.tar -C ~/archivostar/
Para extraer una selección de archivos, del archivo comprimido hay que ejecutarlo de la manera
siguiente;
$ tar xvf comprimido.tar -C ~/archivostar/ --wildcards '*.png'
Para consultar la sintaxis o las opciones de tar, puede realizar la siguiente ejecución;
$ man 1 tar
Respaldos de archivos en Linux
Una de las tareas mas comunes de los administradores de sistemas es el respaldo de archivos
o información generada o acumulada dentro de nuestros servidores, partiendo del tipo de
utilidad que tenga el server podría ser vital, realizar el respaldo de información contenido
dentro de nuestra infraestructura, para tal motivo existen varios tipos de respaldos, los cuales
se describen a continuacion.
Completos
Se consideran de nivel 0 y es condierado el comprende los respaldos integros de inicio a fin, es
decir del primer archivo al ultimo.
Diferenciales:
Se consideran de nivel 1. Consisten en respaldos que dependen de un respaldo completo o
de nivel 0 para poder restaurar todos los datos, sólo archivando los archivos nuevos o que
cambiaron respecto del último respaldo completo. Es decir, para restaurar los datos se requiere
el último respaldo completo y el respaldo diferencial. Hoy en día se utilizan muy poco, salvo que
el administrador del sistema sea poco experimentado o bien porque así es como lo prefiere,
pues consumen mucho más espacio en el sistema de archivos que los respaldos incrementales.
Incrementales:
Se considera respaldo diferencial cuando hay un solo respaldo completo antes de éste, de nivel
2 cuando hay un respaldo completo y un respaldo incremental antes de éste, de nivel 3 cuando
hay un respaldo completo y dos incrementales antes de éste y así sucesivamente. Son similares
al respaldo diferencial, pero éstos pueden hacerse a partir de un respaldo completo y/o un
pág. 173
diferencial y/o otros incrementales, restaurando los datos en secuencia, por lo cual permiten
ahorrar el espacio disponible en el sistema de archivos. Es decir, para restaurar los datos, se
requiere el último respaldo completo y uno o más respaldos incrementales.
Un respaldo completo se puede realizar con “tar”, con las opciones cpf, el nombre del archivo
*.tar a crear, la opción “-g” (definir crear un archivo incremental en el nuevo formato de GNU)
y el nombre del archivo con extensión “*.snar”. Éste último es utilizado por el compresor “tar”
para almacenar la información respecto de qué fue lo que se respaldó. La opción “p” es
importante para crear y restaurar los respaldos, pues permite preservar los permisos y atributos
originales de los datos. Si se omite esta opción, todo el contenido almacenado y restaurado sería
propiedad del usuario root.
Recuerde que puede lograr sincornizaciones de archivos también incluyendo archivos ocultos con
el comando rsync, ejemplo:
# rsync –a /home/* /backup
Para realizar el ejercicio es necesario loguaerse como root:
# su -l
Para generar un respaldo lo primero es definir en donde se va a poner el respaldo, o definir la
partición en donde se va a guardar el respaldo; para lo cual crearemos una carpeta dentro de
/var al cual nombraremos respaldos, esta tarea la realizaremos de la siguiente manera;
# mkdir /var/respaldos
Con el siguiente comando crearemos el primer respaldo, que es considerado un repaldo completo
o de nivel 0 /usr/share/pixmaps, guardando los archivos de datos y un incremental dentro
de /var/respaldos.
# tar cpf /var/respaldos/completo.tar \
-g /var/respaldos/registro.snar /usr/share/pixmaps
Para generar el respaldo de manera incremental, se define el nombre el archivo utilizado el mismo
archivo con extencion .snar
pág. 174
# tar cpf /var/respaldos/incremental-1.tar \
-g /var/respaldos/registro.snar /usr/share/pixmaps
De la misma manera crearemos el segundo respaldo incremental:
# tar cpf /var/respaldos/incremental-2.tar \
-g /var/respaldos/registro.snar /usr/share/pixmaps
Ahora crearemos un tercer respaldo incremental:
# tar cpf /var/respaldos/incremental-3.tar \
-g /var/respaldos/registro.snar /usr/share/pixmaps
Con el siguiente comando empezaremos a realizar la restauración de los respaldos:
# tar xpf /var/respaldos/completo.tar \
-g /var/respaldos/registro.snar -C /
Con el siguiente recuperaremos el incremental número 1;
# tar xpf /var/respaldos/incremental-1.tar \
-g /var/respaldos/registro.snar -C /
Con el siguiente recuperaremos el incremental número 2;
# tar xpf /var/respaldos/incremental-2.tar \
-g /var/respaldos/registro.snar -C /
Con el siguiente acompletariamos el respaldo terminando de hacer el respaldo y restaurandolo
# tar xpf /var/respaldos/incremental-3.tar \
-g /var/respaldos/registro.snar -C /
Si se dispone de poco espacio estos pueden hacerse también de volúmenes distintos, y asi
distribuir el espacio que ocupan los respaldos o moviendo a otros volúmenes las fracciones del
respaldo si el espacio asi nos lo permite.
Para realizar un respaldo de esta forma tendríamos que usar la opción “-M” lo cual configura el
respaldo para ubicarlo en distintos volúmenes y la opción “-L” para indicar el tamaño que le
pág. 175
asignaremos al la fracción a generar, este se define en bytes.
El ejemplo generara el respaldo de la misma carpeta usada hasta este momento,
/usr/share/pixmaps en una unidad de almacenamiento externa que podría ser una usb o un disco
duro, en cuatro partes de 4 GiB cada una, asumiendo que /usr/share/pixmaps ocupa menos de
16 GiB de espacio en el sistema de archivos y que la unidad de almacenamiento externo está
montada en el directorio /media/DISCO/:
# tar cpf /media/DISCO/respaldo01.tar -g /media/DISCO/registro.snar -M -L
4194304
/usr/share/pixmaps
# tar cpf /media/DISCO/respaldo02.tar -g /media/DISCO/registro.snar -M -L
4194304
/usr/share/pixmaps
# tar cpf /media/DISCO/respaldo03.tar -g /media/DISCO/registro.snar -M -L
4194304
/usr/share/pixmaps
# tar cpf /media/DISCO/respaldo04.tar -g /media/DISCO/registro.snar -M -L
4194304 /usr/share/pixmaps
Para llevar acabo la restauración de dicho respaldo se utilizara la opción “-M” para indicar que se
trata de un respaldo de varios volúmenes, y que debe restaurarse en una unidad como un solo
archivo;
# tar xpf /media/DISCO/respaldo01.tar -g /media/DISCO/registro.snar -M -C
/
# tar xpf /media/DISCO/respaldo02.tar -g /media/DISCO/registro.snar -M -C
/
# tar xpf /media/DISCO/respaldo03.tar -g /media/DISCO/registro.snar -M -C
/
# tar xpf /media/DISCO/respaldo04.tar -g /media/DISCO/registro.snar -M -L C/
Una vez terminado el ejercicio tendremos la recuperación del archivo o archivos originales de
manera incremental.
Gestión de procesos y trabajos.
pág. 176
La más simple definición de un proceso podría ser que es una instancia de un programa en
ejecución (corriendo). A los procesos frecuentemente se les refiere como tareas. El contexto de
un programa que esta en ejecución es lo que se llama un proceso. Este contexto puede ser mas
procesos hijos que se hayan generado del principal (proceso padre), los recursos del sistema que
este consumiendo, sus atributos de seguridad (tales como su propietario y permisos de archivos
asi como roles y demás de SELinux), etc.
Linux, como se sabe, es un sistema operativo multitarea y multiusuario. Esto quiere decir que
múltiples procesos pueden operar simultáneamente sin interferirse unos con los otros. Cada
proceso tiene la "ilusión" que es el único proceso en el sistema y que tiene acceso exclusivo a
todos los servicios del sistema operativo.
Programas y procesos son entidades distintas. En un sistema operativo multitarea, múltiples
instancias de un programa pueden ejecutarse sumultáneamente. Cada instancia es un proceso
separado. Por ejemplo, si cinco usuarios desde equipos diferentes, ejecutan el mismo programa
al mismo tiempo, habría cinco instancias del mismo programa, es decir, cinco procesos distintos.
Cada proceso que se inicia es referenciado con un número de identificación único conocido como
Process ID PID, que es siempre un entero positivo. Prácticamente todo lo que se está ejecutando
en el sistema en cualquier momento es un proceso, incluyendo el shell, el ambiente gráfico que
puede tener múltiples procesos, etc. La excepción a lo anterior es el kernel en si, el cual es un
conjunto de rutinas que residen en memoria y a los cuales los procesos a través de llamadas al
sistema pueden tener acceso.
pág. 177
Comando Ps
El comando ps es el que permite informar sobre el estado de los procesos. ps esta basado en el
sistema de archivos /proc, es decir, lee directamente la información de los archivos que se
encuentran en este directorio. Tiene una gran cantidad de opciones, incluso estas opciones varían
dependiendo del estilo en que se use el comando. Estas variaciones sobre el uso de ps son las
siguientes:
Estilo UNIX, donde las opciones van precedidas por un guión Estilo BSD, donde las opciones no llevan guión
Estilo GNU, donde se utilizan nombres de opciones largas y van precedidas por doble guión
-Sea cual sea el estilo utilizado, dependiendo de las opciones indicadas, varias columnas se
mostrarán en el listado de procesos que resulte, estas columnas pueden ser entre muchas otras,
las siguientes (y principales):
Las opciones completas de ps las encuentras en las páginas del manual (man ps), o escribiendo
en la terminal ps L, y para ver un resumen de sus opciones más comunes usaps --help:
#> ps --help
********* simple selection ********* ********* selection by list *********
-A all processes
-C by command name
-N negate selection
-G by real group ID (supports names)
-a all w/ tty except session leaders -U by real user ID (supports names)
-d all except session leaders
-g by session OR by effective group name
-e all processes
-p by process ID
T all processes on this terminal -s processes in the sessions given
a all w/ tty, including other users -t by tty
g OBSOLETE -- DO NOT USE
-u by effective user ID (supports names)
r only running processes
U processes for specified users
x processes w/o controlling ttys t by tty
*********** output format ********** *********** long options ***********
-o,o user-defined -f full
--Group --User --pid --cols --ppid
-j,j job control s signal
--group --user --sid --rows --info
-O,O preloaded -o v virtual memory --cumulative --format --deselect
pág. 178
-l,l long
u user-oriented --sort --tty --forest --version
-F extra full X registers
--heading --no-heading --context
********* misc options *********
-V,V show version L list format codes f ASCII art forest
-m,m,-L,-T,H threads S children in sum -y change -l format
-M,Z security data c true command name -c scheduling class
-w,w wide output
n numeric WCHAN,UID -H process hierarchy
A continuación algunos cuantos ejemplos de ps con la salida recortada.
El comando siguiente, muestra todos los procesos
# ps –e
El comando siguiente muestra opciones completas
#ps –ef
El siguiente muestra opciones completas extras
# ps –eF
El siguiente comando ,muestra en formato BSD sin guion, usuarios y otras características;
# ps aux
El siguiente muestra un output personalizado, se indican los campos separados por coma
# ps –eo user,pid,tty
El siguiente comando muestra el árbol de procesos;
#ps –eH
El siguiente muestra lo mismo con otro formato
# ps axf
El siguiente se ejecuta cin la ruta, colo con el nombre real
pág. 179
# ps –ec
El siguiente no muestra procesos, lista todos los códigos de formatos
# ps L
Pstree
Muestra los procesos en forma de árbol, pstree --help te da las opciones más comunes.
Recomiendo uses lo uses con la opción -A y -G para que te un árbol con líneas con líneas estilo
ASCII y de terminal VT100 respectivamente, puedes añadir también -u para mostrar entre
paréntesis al usuario propietario del proceso:
# pstree
Configuración y uso de crond.
Esta es una introducción a cron, cubre lo básico de lo que cron puede hacer y la manera de usarse.
¿Qué es cron?
Cron es el nombre del programa que permite a usuarios Linux/Unix ejecutar automáticamente
comandos o scripts (grupos de comandos) a una hora o fecha específica. Es usado normalmente
para comandos de tareas administrativas, como respaldos, pero puede ser usado para ejecutar
cualquier cosa. Como se define en las páginas del manual de cron (#> man cron) es un demonio
que ejecuta programas agendados.
Recuerde que si no tiene lo que busca dentro del manual de cron, podría encontrar mas
información utilizando los comandos:
# whatis crontab
# man –kcrontab
Dependiendo de la distribución que este utilizando.
En prácticamente todas las distribuciones de Linux se usa la versión Vixie Cron, por la persona que
la desarrolló, que es Paul Vixie, uno de los grandes gurús de Unix, también creador, entre otros
sistemas, de BIND que es uno de los servidores DNS más populares del mundo.
pág. 180
Iniciar cron
Cron es un demonio (servicio), lo que significa que solo requiere ser iniciado una vez,
generalmente con el mismo arranque del sistema. El servicio de cron se llama crond. En la mayoría
de las distribuciones el servicio se instala automáticamente y queda iniciado desde el arranque
del sistema, se puede comprobar de varias maneras:
#> /etc/rc.d/init.d/crond status
#> /etc/init.d/crond status Usa cualquiera de los dos dependiendo de tu distro
crond (pid 507) is running...
o si tienes el comando service instalado:
#> service crond status
crond (pid 507) is running...
se puede también revisar a través del comando ps:
# ps -ef | grep crond
si por alguna razón, cron no esta funcionando:
#> /etc/rc.d/init.d/crond start
Starting crond:
[ OK ]
Si el servicio no estuviera configurado para arrancar desde un principio, bastaría con agregarlo
con el comando chkconfig:
#> chkconfig --level 35 crond on
Con esto lo estarías agregando al nivel de ejecución 3 y 5, para que inicie al momento del arranque
del sistema.
Usando cron
Hay al menos dos maneras distintas de usar cron:
La primera es en el directorio etc, donde muy seguramente encontrarás los siguientes directorios:
cron.hourly
cron.daily
cron.weekly
pág. 181
cron.monthly
Si se coloca un archivo tipo script en cualquiera de estos directorios, entonces el script se
ejecutará cada hora, cada día, cada semana o cada mes, dependiendo del directorio.
Para que el archivo pueda ser ejecutado tiene que ser algo similar a lo siguiente:
#!/bin/sh
#script que genera un respaldo
cd /usr/documentos
tar czf * respaldo
cp respaldo /otra_directorio/.
Nótese que la primera línea empieza con #!, que indica que se trata de un script shell de bash, las
demás líneas son los comandos que deseamos ejecute el script. Este script podría nombrarse por
ejemplo respaldo.sh y también debemos cambiarle los permisos correspondientes para que
pueda ser ejecutado, por ejemplo:
#> chmod 700 respaldo.sh
#> ls -l respaldo.sh
-rwx------ 1 root root 0 Jul 20 09:30 respaldo.sh
La "x" en el grupo de permisos del propietario (rwx) indica que puede ser ejecutado.
Si este script lo dejamos en cron.hourly, entonces se ejecutará cada hora con un minuto de todos
los
días,
en
un
momento
se
entenderá
el
porque.
Como segundo modo de ejecutar o usar cron es a través de manipular directamente el
archivo /etc/crontab. En la instalación por defecto de varias distribuciones Linux, este archivo se
verá a algo como lo siguiente:
#> cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
pág. 182
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
Las primeras cuatro líneas son variables que indican lo siguiente:
SHELL es el 'shell' bajo el cual se ejecuta el cron. Si no se especifica, se tomará por defecto el
indicado en la línea /etc/passwd correspondiente al usuario que este ejecutando cron.
PATH contiene o indica la ruta a los directorios en los cuales cron buscará el comando a ejecutar.
Este path es distinto al path global del sistema o del usuario.
MAIL TO es a quien se le envía la salida del comando (si es que este tiene alguna salida). Cron
enviará un correo a quien se especifique en este variable, es decir, debe ser un usuario válido del
sistema o de algún otro sistema. Si no se especifica, entonces cron enviará el correo al usuario
propietario del comando que se ejecuta.
HOME es el directorio raíz o principal del comando cron, si no se indica entonces, la raíz será la
que se indique en el archivo /etc/passwd correspondiente al usuario que ejecuta cron.
Los comentarios se indican con # al inicio de la línea.
Después de lo anterior vienen las líneas que ejecutan las tareas programadas propiamente. No
hay límites de cuantas tareas pueda haber, una por renglón. Los campos (son 7) que forman estas
líneas están formados de la siguiente manera:
Minuto Hora DiaDelMes Mes DiaDeLaSemana Usuario Comando
Campo
Descripción
Minuto
Controla el minuto de la hora en que el comando será ejecutado, este valor
debe de estar entre 0 y 59.
Hora
Controla la hora en que el comando será ejecutado, se especifica en un
formato de 24 horas, los valores deben estar entre 0 y 23, 0 es medianoche.
pág. 183
Día del Mes
Día del mes en que se quiere ejecutar el comando. Por ejemplo se indicaría
20, para ejecutar el comando el día 20 del mes.
Mes
Mes en que el comando se ejecutará, puede ser indicado numéricamente
(1-12), o por el nombre del mes en inglés, solo las tres primeras letras.
Día en la semana en que se ejecutará el comando, puede ser numérico (0-7)
Día de la
o por el nombre del día en inglés, solo las tres primeras letras. (0 y 7 =
semana
domingo)
Usuario
Usuario que ejecuta el comando.
Comando
Comando, script o programa que se desea ejecutar. Este campo puede
contener múltiples palabras y espacios.
Un asterisco * como valor en los primeros cinco campos, indicará inicio-fin del campo, es decir
todo. Un * en el campo de minuto indicará todos los minutos.
Para entender bien esto de los primeros 5 campos y el asterisco usaré mejor varios ejemplos:
Ejemplo
Descripción
01 * * * *
Se ejecuta al minuto 1 de cada hora de todos los días
15 8 * * *
A las 8:15 a.m. de cada día
15 20 * * * A las 8:15 p.m. de cada día
00 5 * * 0
A las 5 a.m. todos los domingos
* 5 * * Sun Cada minuto de 5:00a.m. a 5:59a.m. todos los domingos
45 19 1 * * A las 7:45 p.m. del primero de cada mes
01 * 20 7 * Al minuto 1 de cada hora del 20 de julio
10 1 * 12 1 A la 1:10 a.m. todos los lunes de diciembre
00 12 16 *
Al mediodía de los días 16 de cada mes y que sea Miércoles
Wen
30 9 20 7 4 A las 9:30 a.m. del dia 20 de julio y que sea jueves
pág. 184
30 9 20 7 * A las 9:30 a.m. del dia 20 de julio sin importar el día de la semana
20 * * * 6
Al minuto 20 de cada hora de los sábados
20 * * 1 6
Al minuto 20 de cada hora de los sábados de enero
Ejecutando Cron con múltiples usuarios, comando crontab
Linux es un sistema multiusuario y cron es de las aplicaciones que soporta el trabajo con varios
usuarios a la vez. Cada usuario puede tener su propio archivo crontab, de hecho el/etc/crontab se
asume que es el archivo crontab del usuario root, aunque no hay problema que se incluyan otros
usuarios, y de ahí el sexto campo que indica precisamente quien es el usuario que ejecuta la tarea
y es obligatorio en /etc/crontab.
Pero cuando los usuarios normales (e incluso root) desean generar su propio archivo de crontab,
entonces utilizaremos el comando crontab.
En el directorio /var/spool/cron (puede variar según la distribución), se genera un archivo cron
para cada usuario, este archivo aunque es de texto, no debe editarse directamente.
Se tiene entonces, dos situaciones, generar directamente el archivo crontab con el comando:
$> crontab -e
Con lo cual se abrira el editor por default (generalemente vi) con el archivo llamado crontab vacio
y donde el usuario ingresará su tabla de tareas y que se guardará automáticamente como
/var/spool/cron/usuario.
El otro caso es que el usuario edite un archivo de texto normal con las entradas de las tareas y
como ejemplo lo nombre 'mi_cron', después el comando $> crontab mi_cron se encargará de
establecerlo como su archivo cron del usuario en /var/spool/cron/usuario:
$> vi mi_cron
# borra archivos de carpeta compartida
0 20 * * * rm -f /home/sergio/compartidos/*
# ejecuta un script que realiza un respaldo de la carpeta documentos el primer día de cada mes
0 22 1 * * /home/sergio/respaldomensual.sh
# cada 5 horas de lun a vie, se asegura que los permisos sean los correctos en mi home
1 *5 * * * 1-5 chmod -R 640 /home/sergio/*
pág. 185
:wq (se guarda el archivo)
$> ls
mi_cron
$>
mi_cron
(se establece en /var/spool/cron/usuario)
Resumiendo lo anterior y considerando otras opciones de crontab:
$> crontab archivo.cron (establecerá el archivo.cron como el crontab del usuario)
$> crontab -e
(abrirá el editor preestablecido donde se podrá crear o editar el archivo
crontab)
$> crontab -l
(lista el crontab actual del usuario, sus tareas de cron)
$> crontab -r
(elimina el crontab actual del usuario)
En algunas distribuciones cuando se editan crontabs de usuarios normales es necesario reiniciar
el servicio para que se puedan releer los archivos de crontab en /var/spool/cron.
#> service crond restart
Para entender mejor como iniciar/detener/reiniciar servicios, en este artículo encontrarás más
información.
Controlando el acceso a cron
Cron permite controlar que usuarios pueden o no pueden usar los servicios de cron. Esto se logra
de una manera muy sencilla a través de los siguientes archivos:
/etc/cron.allow
/etc/cron.deny
Para impedir que un usuario utilice cron o mejor dicho el comando crontab, basta con agregar su
nombre de usuario al archivo /etc/cron.deny, para permitirle su uso entonces sería agregar su
nombre de usuario en /etc/cron.allow, si por alguna razón se desea negar el uso de cron a todos
los usuarios, entonces se puede escribir la palabra ALL al inicio de cron.deny y con eso bastaría.
#> echo ALL >>/etc/cron.deny
o para agregar un usuario mas a cron.allow
#> echo juan >>/etc/cron.allow
pág. 186
Si no existe el archivo cron.allow ni el archivo cron.deny, en teoría el uso de cron esta entonces
sin restricciones de usuario. Si se añaden nombres de usuarios en cron.allow, sin crear un archivo
cron.deny, tendrá el mismo efecto que haberlo creado con la palabra ALL. Esto quiere decir que
una vez creado cron.allow con un solo usuario, siempre se tendrán que especificar los demás
usuarios que se quiere usen cron, en este archivo.
Por último y no menos importante:
Administracion de trabajos en cron
crontab archivo
pág. 187
Remplaza el existente archivo crontab con un archivo definido por el usuario
crontab -e
Editar el archivo crontab del usuario, cada linea nueva sera una nueva tarea de crontab.
crontab -l
Lista todas las tareas de crontab del usuario
crontab -d
Borra el crontab del usuario
crontab -c dir
Define el directoriod e crontab del usuario (este debe tener permisos de escritura y ejecucion del
usuario)
crontab -u usuario
prefijo para manejar el crontab de otro usuario, ejemplos:
$ sudo crontab -l -u root
$ sudo crontab -e usuario2
#crontab -d -u usuario
Ejercicio;
Para iniciar comenzaremos instalando el paquete necesarios;
# yum –y install cronie
# yum –y install anacron
El formato del archivo /etc/crontab.
Cualquier usuario que sea definido para ejecutar un programa en el archivo /etc/crontab, podrá
ejecutar todo aquello para lo cual tenga privilegios, siempre y cuando se defina un intérprete de
mandatos válido (por ejemplo /bin/bash o /bin/sh) en la variable de entorno SHELL, así como las
rutas de binarios ejecutables que sean necesarias, sin importar lo que esté definido en el archivo
/etc/passwd o las variables de entorno definidas en el archivo ~/.bashrc del usuario a utilizar.
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
pág. 188
El archivo /etc/crontab permite además definir a cuál usuario enviar un mensaje de correo
electrónico con los resultados de las salidas de los programas que las generen y el intérprete de
mandatos a utilizar.
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
[email protected]
El archivo utiliza un formato de 7 campos, donde se define, respectivamente, minuto, hora, día
del mes, mes, día de la semana, usuario a utilizar y el programa a ejecutar.
.-----------------------· Minuto (0 - 59)
| .--------------------· Hora (0 - 23)
| | .-----------------· Día del mes (1 - 31)
| | | .--------------· Mes (1 - 12)
| | | | .-----------· Día de la semana (0 - 6) (domingo=0 o 7), y
| | | | |
también acepta como valores:
| | | | |
mon, tue, wed, thu, fri, sat y sun
| | | | | .--------· Usuario
| | | | | | .-· Programa a ejecutar
↓ ↓ ↓ ↓ ↓ ↓ ↓
1 14 * * * hector /home/hector/bin/tarea.sh > /dev/null 2>&1
Formato exclusivo de cronie.
A diferencia de vixie-cron, con cronie se pueden omitir los primeras 5 campos y en su lugar utilizar
las siguientes opciones:
@reboot (ejecutar una vez después de reiniciar el sistema)
@yearly y @annually (ejecutar anualmente, es decir: «0 0 1 1 *»)
@monthly (ejecutar mensualmente, es decir: «0 0 1 * *»)
@weekly (ejecutar semanalmente, es decir: «0 0 * * 0»)
@daily (ejecutar diariamente, es decir: «0 0 * * *»)
@hourly (ejecutar cada hora, es decir: «0 * * * *»)
pág. 189
Formato para utilizar con crontab -e.
Todos los usuarios del sistema pueden ejecutar crontab con la opción -e, a excepción de aquellos
quienes tengan /dev/null (dispositivo nulo) como intérprete de mandatos o bien que se
encuentren listados en el archivo /etc/cron.deny.
Para los usuarios que tengan /sbin/nologin como intérprete de mandatos, será necesario se
defina /bin/bash o /bin/sh en la variable de entorno SHELL al inicio del archivo cron
correspondiente. Con este tipo de usuarios, habría que ejecutar lo siguiente para poder hacer uso
de crontab.
# su -l usuario -s /bin/bash -c "crontab -e"
ATD
El At tiene basicamente la misma funcionalidad, solo cambia el formato con el que se especifica
un 'momento'. Tiene una sintaxis muy parecida al ingles. Dare ejemplos para que se entienda,
pero antes debemos comprender que el At no ejecuta un comando o script, sino una serie de
comandos, que At nos solicitara interactivamente. Tambien podemos especificar un script (y NO
un binario) para que sea ejecutado, mediante el parametro '-f', que ahora veremos.
Veamos unos ejemplos, para comprender mejor el uso de at:
at midnight - Ejecutara a la medianoche el script que ingresemos interactivamente al ejecutar el
comando. Tambien podemos usar noon (mediodia) o teatime (4pm). Por otra parte, podemos
agregar today (hoy) o tomorrow (maniana) como sufijo. Ejemplo: at 8:30am tomorrow (8.30 am
de maniana).
at 3:15pm - Ejecutara a las 3:15 de la tarde.
at now + 2 days - Ejecutara dentro de dos dias.
at 10am + 1 week - Ejecutara a las 10am dentro de una semana.
at 11pm Jul 22 - Ejecutara a las 23hs del 22 de Julio.
Y usando el parametro '-f', podriamos hacer: at -f ~/algun_script now + 10 minutes (ejecutar el
script ~/algun_script dentro de 10 minutos a partir de ahora).
En vez de usar day[s], week[s], tambien podemos usar minute[s], hour[s]. El now indica "AHORA".
Fecha u hora se pueden especificar con los siguientes formatos: HH:MM (hora:minutos),
MMDDYY o MM/DD/YY o DD.MM.YY (mes dia anio).
Los diferentes comandos que hacen al paquete AT son:
atd - El AT Daemon - Como cron, se debe cargar desde un script de /etc/rc.d
at - El at propiamente dicho. Ver los ejemplos.
atq - Ver la lista de trabajos ('jobs') pendientes.
atrm - Para eliminar un trabajo pendiente de la cola (queue).
pág. 190
batch - Como at, pero ejecutara el script cuando el nivel de carga del sistema haya bajado lo
suficiente. (default, 0.8).
El atq es el at con el parametro '-l', y el atrm es el at, pero con el parametro '-d'.
El at tambien admite el parametro '-m', que enviara un eMail al usuario una vez realizado el
trabajo.
Para permitir o denegar el uso de at podemos hacer lo mismo que con cron, y los archivos Allow
y Deny se encuentran en /etc/at.allow y /etc/at.deny, y se respeta el mismo esquema que en
Cron.
Kill
El comando kill, que literalmente quiere decir matar, sirve no solo para matar o terminar procesos
sino principalmente para enviar señales (signals) a los procesos. La señal por default (cuando no
se indica ninguna es terminar o matar el proceso), y la sintaxis es kill PID, siendo PID el número
de ID del proceso. Asi por ejemplo, es posible enviar una señal de STOP al proceso y se detendrá
su ejecución, después cuando se quiera mandar una señal de CONTinuar y el proceso continuara
desde donde se quedo.
El siguiente comando muestra todas las posibles señales que puedan enviarse a un proceso;
# kill –l
Es decir todos los procesos que están en un nivel Start.
La lista previa presenta una lista de todas las posibles señales que pueden mandarse a un proceso
y estas pueden ser invocadas a través del número de la señal o de su código, por ejemplo:
#> kill -9 11428
(termina, mata un proceso completamente)
#> kill -SIGKILL 11428 (Lo mismo que lo anterior)
Las señales más comunes son la 19 y 20 que detienen momentáneamente la ejecución de un
proceso o programa, 18 la continua, 1 que es la señal de hang up que obliga al proceso a releer
sus archivos de configuración estando en ejecución y 9 que termina rotundamente un proceso.
Killall
pág. 191
El comando killall, que funciona de manera similar a kill, pero con la diferencia de en vez de indicar
un PID se indica el nombre del programa, lo que afectará a todos los procesos que tengan ese
nombre. Asi por ejemplo si se tienen varias instancias ejecutándose del proxy server squid,
con killall squid eliminará todos los procesos que se esten ejecutando con el nombre 'squid'
#> killall -l
(lista de posibles señales)
#> killall -HUP httpd
configuración y reiniciar)
(manda una señal de "colgar", detenerse releer sus archivos de
#> killall -KILL -i squid (manda señal de matar a todos los procesos squid pero pide confirmación
en cada uno)
Nice
Permite cambiar la prioridad de un proceso. Por defecto, todos los procesos tienen una prioridad
igual ante el CPU que es de 0. Con nice es posible iniciar un programa (proceso) con la prioridad
modificada, más alta o más baja según se requiera. Las prioridades van de -20 (la más alta) a 19
la más baja. Solo root o el superusuario puede establecer prioridades negativas que son más altas.
Con la opción -l de ps es posible observar la columna NI que muestra este valor.
#> nice
(sin argumentos, devuelve la prioridad por defecto)
renice
Asi como nice establece la prioridad de un proceso cuando se incia su ejecución, renicepermite
alterarla en tiempo real, sin necesidad de detener el proceso.
#> nice -n -5 yes (se ejecuta el programa 'yes' con prioridad -5)
(dejar ejecutando 'yes' y en otra terminal se analiza con 'ps')
#> ps -el
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY
TIME CMD
4 S 0 12826 12208 4 75 -5 - 708 write_ pts/2 00:00:00 yes
#> renice 7 12826
12826: prioridad antigua -5, nueva prioridad 7
#> ps -el
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY
TIME CMD
4 S 0 12826 12208 4 87 7 - 708 write_ pts/2 00:00:15 yes
pág. 192
(obsérvese el campo NI en el primer caso en -5, y en el segundo con renice quedó en 7, en tiempo
real)
nohup y &
Cuando se trata ejecutar procesos en background (segundo plano) se utiliza el comandonohup o
el operador & . Aunque realizan una función similar, no son lo mismo.
Si se desea liberar la terminal de un programa que se espera durará un tiempo considerable
ejecutándose, entonces se usa. Esto funciona mejor cuando el resultado del proceso no es
necesario mandarlo a la salida estándar (stdin), como por ejemplo cuando se ejecuta un respaldo
o se abre un programa Xwindow desde la consola o terminal. Para lograr esto basta con escribir
el comando en cuestión y agregar al final el símbolo & (ampersand).
$> yes > /dev/null &
$> tar czf respaldo /documentos/* > /dev/null/ &
$> konqueror & (con estos ejemplos se ejecuta el comando y se libera la terminal regresando el
prompt)
Sin embargo lo anterior produce que el padre del proceso PPID que se invocó sea el proceso de
la terminal en si, por lo que si cerramos la terminal o salimos de la sesión también se terminaran
los procesos hijos que dependan de la terminal, no muy conveniente si se desea que el proceso
continué en ejecución.
Para solucionar lo anterior, entonces se usa el comando nohup que permite al igual que '&'
mandar el proceso y background y que este quede inmune a los hangups (de ahí su nombre
nohup) que es cuando se cuelga o termina la terminal o consola de la cual se ejecutó el proceso.
$> nohup yes > /dev/null &
$> nohup czf respaldo /documentos/* > /dev/null/
$> nohup konqueror
Asi se evita que el proceso se "cuelgue" al cerrar la consola.
Jobs
Si por ejemplo, se tiene acceso a una única consola o terminal, y se tienen que ejecutar varios
comandos que se ejecutarán por largo tiempo, se pueden entonces como ya se vió previamente
con nohup y el operador '&' mandarlos a segundo plano o background con el objeto de liberar la
pág. 193
terminal y continuar trabajando.
Pero si solo se está en una terminal esto puede ser difícil de controlar, y para eos tenemos el
comando jobs que lista los procesos actuales en ejecución:
#> yes > /dev/null &
[1] 26837
#> ls -laR > archivos.txt &
[2] 26854
#> jobs
[1]- Running
yes >/dev/null &
[2]+ Running
ls --color=tty -laR / >archivos.txt &
En el ejemplo previo, se ejecutó el comando yes y se envió a background (&) y el sistema devolvió
[1] 26837, indicando asi que se trata del trabajo o de la tarea [1] y su PID, lo mismo con la segunda
tarea que es un listado recursivo desde la raíz y enviado a un archivo, esta es la segunda tarea.
Con los comandos fg (foreground) y bg background es posible manipular procesos que esten
suspendidos temporalmente, ya sea porque se les envió una señal de suspensión como STOP (20)
o porque al estarlos ejecutando se presionó ctrl-Z. Entonces para reanudar su ejecución en primer
plano usaríamos fg:
#> jobs
[1]- Stopped
[2]+ Stopped
#> fg %1
#> jobs
[1]+ Running
[2]- Stopped
yes >/dev/null &
ls --color=tty -laR / >archivos.txt &
yes >/dev/null &
ls --color=tty -laR / >archivos.txt &
Obsérvese como al traer en primer plano al 'job' o proceso 1, este adquirió el símbolo [+] que
indica que esta al frente. Lo mismo sería con bg que volvería a reinicar el proceso pero en segundo
plano. Y también es posible matar los procesos con kill indicando el número que
devuelve jobs: kill %1, terminaría con el proceso en jobs número 1.
Top
pág. 194
Una utilería muy usada y muy útil para el monitoreo en tiempo real del estado de los procesos y
de otras variantes del sistema es el programa llamado top, se ejecuta desde la línea de comandos,
es interactivo y por defecto se actualiza cada 3 segundos.
$> top
top - 13:07:30 up 8 days, 6:44, 4 users, load average: 0.11, 0.08, 0.08
Tasks: 133 total, 1 running, 131 sleeping, 0 stopped, 1 zombie
Cpu(s): 0.0%us, 0.2%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.2%si, 0.0%st
Mem: 497356k total, 472352k used, 25004k free, 21500k buffers
Swap: 1156640k total, 257088k used, 899552k free, 60420k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
26156 sergon 15 0 2160 1016 784 R 1 0.2 0:00.93 top
1 root 15 0 2012 616 584 S 0 0.1 0:00.98 init
2 root RT 0 0 0 0 S 0 0.0 0:00.29 migration/0
3 root 34 19 0 0 0 S 0 0.0 0:00.00 ksoftirqd/0
4 root RT 0 0 0 0 S 0 0.0 0:00.00 watchdog/0
5 root RT 0 0 0 0 S 0 0.0 0:00.38 migration/1
...
Estando adentro de la apliación, presionando 'h' muestra una ayuda de los posibles comandos
que permiten configurar top, por ejemplo, al presionar 's' pregunta por el tiempo en segundos
de actualización, etc.
Estas son algunas de las herramientas, las más importantes y usadas, para adminsitrar procesos,
hay varios programas en ambientes gráficos que en una sola pantalla permiten todo lo anterior y
más, y en línea de comandos te recomiendo htop, que es como un toppero en esteroides.
pág. 195
Ejercicio;
Para desarrollar el ejercicio, primero hay que realizar un par de instalaciones de algunos paquetes
que van a ser necesarios para lo cual nos loguearemos como root y realizarlas con el siguiente
comando:
# yum -y install procps top util-linux-ng
Una vez realizadala instalación, nos salimos de la secion o nos logueamos en otra terminal, con
cualquiera de los usuarios antes creados para poder llevar acabo el ejercicio.
Ejecutamos un proceso sleep con un tiempo estimado de 700 segundos, esto lo lograremos con
el siguiente comando;
$ sleep 700
Pulsaremos las teclas CTRL+Z, lo cual pondrá el proceso en segundo plano:
Ejecutamos el comando “jobs” o trabajos, para visualizar el trabajo detenido:
$ jobs
Ejecutando el comando bg reactivaremos el trabajo 1 que esta en backgroud o en segundo plano:
$ bg 1
Ejecute nuevamente sleep con el valor 900 y un signo “&” al final, para generar otro proceso mas:
$ sleep 900 &
Con esto lo que haremos será enviar el trabajo a segundo plano.
Ejecutamos nuevamente el comando de Jobs para poder ver los trabajos que hemos ejecutado:
$ jobs
[1]- Ejecutando
sleep 600 &
[2]+ Ejecutando
sleep 700 &
Ejecutando el comando “fg” con 1 como argumento podremos enviar al primer plano el primer
trabajo:
$ fg 1
Realizando esto, hará que el proceso o trabajo sleep 700 regrese a primer plano.
Para terminar este último trabajo, pulse CTRL+C.
Acontinuacion ejecutaremos el comando ps aux, que en la parte de ps, dice que mostrara todas
las terminales, incluyendo los procesos, pero a diferencia del otro agregaremos una pipa, y un
pág. 196
atributo llamado less el cual nos mostrara toda la información de manera pausada según se
requiera;
$ ps aux |less
Si realizamos la conbinacion de la pipa junto con grep, nos realizara una búsqueda selectiva de los
procesos que incluyan el nombre de “sleep”;
$ ps aux |grep sleep
En este caso deberemos de ver aun uno de los procesos sleep que declaramos anteriormente.
Ahora de lo que estamos viendo el proceso sleep debe de mostrar un numero de proceso, si
ejecutamos el comando kill seguido del proceso se terminara con esta tarea;
$ kill No.de proceso
Si ejecutamos de nuevo el comando sleep, pero ahora con un tiempo de 300, como argumento,
con un signo “&” al final, se generar otro trabajo en segundo plano;
$ sleep 300 &
Como sabemos que el trabajo es el único y esta en proceso 1, podríamos terminarlo con el
siguiente comando:
$ kill %1
Generaremos otro proceso pero ahora con un tiempo de 500 segundo pasándolo a segundo plano
también;
$ sleep 500 &
Si ejecutamos el ps con la pipa y el argumento sleep podremos ver el proceso que acabamos de
generar.
$ ps aux |grep sleep
Observaremos cual el numero de PID o numero de indentidad, y lo terminaremos con el comando
kill, pero en esta ocacion agregaremos el argumento -9
$ kill -9 No.de Proceso
Para poder ver mejor el funcionamiendo de “jobs” agregaremos dos tareas al mismo tiempo de
la siguiente forma:
$ sleep 500 & sleep 900 &
Correremos de nuevo el comando para poder visualizar los trabajos que están corriendo:
pág. 197
$ jobs
Si ejecutamos nuevamente “ps”, pero con la opción “-j”, podremos visualizar los números de
proceso o de ID de estos:
$ ps -j
Ejecutaremos el comando “killall” con la cadena “sleep” como argumento, a fin de terminar de
manera normal de todos los procesos denominados sleep.
$ killall sleep
Repetimos el proceso de dar de alta dos tareas al mismo tiempo, las visualizamos con ps, pero
ahora los terminaremos con un comando killall, agregando la opción –s y el valos 9, con la misma
cadena como argumento y veremos que termina todos los procesos
$ killall -s 9 sleep
Comandos nice y renice.
Realizaremos la compresión de los archivos que están en la carpeta /lib/modules, en español los
modulos de las libreras en un archivo tar llamado comprimidonice
# tar jcf comprimidonice.tar.bz2 /lib/modules
Al terminar utilice time para cuantificar la ejecución del compresor con las opciones “jxf”, para
descomprimir el archivo comprimidonice.tar.bz2. Esto con la finalidad de cuantificar la
descompresión con la prioridad de planificación 0 (valor predeterminado del sistema), la cual
permite utilizar los recursos que regularmente permite utilizar el sistema al usuario.
# time tar jxf comprimidonice.tar.bz2
La salida nos debe mostrar unas medidas de tiempo.
Para darle prioridad a esta tarea utilizaremos el comando “nice”, esto le dara una planificación a
10(valor predeterminado de nice), esto con el objetivo de utilizar menos recursos de sistema, para
ello ejecutaremos el comando del la siguiente manera:
# time nice -n +10 tar jxf comprimidonice.tar.bz2
pág. 198
Los resultados deberán ser ligeramente mayores, en cuanto a tiempo de ejecución pues la
prioridad fue aumentada.
El usuario ordinario solo puede definir valores de prioridad de planificación del 0 al 19,
prioridad de planificación predeterminada a prioridad de planificación menos favorable. Los
valores negativos, del -1 al -20, que son los más favorables, sólo los pude utilizar “root”.
Para verificar lo descrito anteriormente podríamos ejecutar “su” con la opción “-c”, con la cual se
indicará entre comillas cualquier cosa para ser ejecutada como “root”, de la siguiente forma.
$ su -c "time nice -n -20 tar jxf cmprimidonice.tar.bz2"
Los resultados deberán ser sensiblemente inferiores que la ejecución con el valor predeterminado
de prioridad de planificación (0).
La ejecución del comando anterior, creara un directorio denominado lib dentro del directorio de
inicio del usuario, pero éste le pertenece de root, por lo cual el usuario regular será incapaz de
borrarlo. Borrelo para evitar tener que realizar nuevamente el procedimiento, para esto es
recoemndable tener 2 terminales abiertas y poder realizar las tareas de manera mas fluida.
$ su -c "rm -fr /home/fulano/lib"
Ulitizaremos “renice” para cambiar la prioridad de planificación de procesos en ejecución. Para
poder demostrar de forma mas clara este comando, iniciaremos utilizando “ps” con las opciones
“alx” las cuales nos mostrarn todos los procesos de todas las terminales:
$ ps alx |less
Con el siguiente comando cambiaremos la prioridad de planificación a un valor de -10, al proceso
que en el ejemplo corresponde al PID que elija:
$ su -c "renice -n -10 -p PID"
Con el siguiente cambiaremos la prioridad de planificación a -10 a todos los procesos del usuario
con el que estemos trabajando:
$ su -c "renice -n -10 -u user"
El siguiente ejemplo cambia la prioridad de planificación a -10 a todos los procesos del grupo
desarrollo:
$ su -c "renice -n -10 -g desarrollo"
pág. 199
Top.
Top es una herramienta que proporciona una visualización continua y en tiempo real de los
procesos activos en un sistema, como una lista que de modo predeterminado lo hace de acuerdo
al uso del CPU. Puede ordenar la lista por uso de memoria y tiempo de ejecución.
Para ordenar la lista de procesos por orden de uso de memoria, pulse SHIFT+M. Para ordena la
lista de procesos por orden de tiempo de ejecución, pulse SHIFT+T. Para invertir el orden de la
lista, pulse SHIFT+R. Para activar o bien desactivar, la visualización por hilos, pulse SHIFT+H. Para
ordenar de nuevo la lista de procesos por orden de uso de CPU, pulse SHIFT+P.
Para mostrar los procesos de un usuario en específico, pulse la tecla u y defina a continuación el
nombre del usuario.
Para terminar o aniquilar cualquier proceso, pulse la tecla k y defina a continuación el número de
identidad de proceso que corresponda y luego la señal a utilizar (9 o 15).
Para cambiar la prioridad de planificación de cualquier proceso, pulse la tecla r y a continuación
defina el número de identidad de proceso que corresponda y luego el valor de prioridad de
planificación deseado.
Pulse la tecla h para ver el la ayuda completa de top.
La ejecución es;
$ top
lsof.
Lsof significa «listar archivos abiertos» (list open files). Es utilizado ampliamente en sistemas
operativos tipo POSIX para hacer reportes de archivos y los procesos que están utilizando a éstos.
Se puede utilizar para revisar que procesos están haciendo uso de directorios, archivos
ordinarios, tuberías (pipes), zócalos de red (sockets) y dispositivos. Uno de los principales usos de
determinar que procesos están haciendo uso de archivos en una partición cuando esta no se
puede desmontar. Lsof fue desarrollado por Vic Abell, quien alguna vez fue director del Centro de
Cómputo de la Universidad de Purdue.
Lo primero que tenemos que hacer s instalar el paquete, para instalar lsof, ejecute lo siguiente:
yum -y install lsof
pág. 200
Ejercicio;
Utilizando lsof podremos ver todos los procesos que utilizan el sistema de archivos en general,
ejecute lsof:
# lsof
Si lo ejecutamos de la siguiente manera podremos visualizar más cómodamente esta salida:
# lsof | more
Usted podría especificar que se muestren todos los procesos desde un directorio en particular, de
la siguiente manera podríamos solicitar, que se muestren los procesos que están conpartiendo o
haciendo uso de /var.
# lsof /var
Si se necesita mostrar solamente el archivo utilizado por un proceso en particular, podría usar con
la opción -p seguida del número del proceso en el cual tuviéramos interes:
# lsof -p PID
Con la opción -i podrá mostrar todos los archivos de red utilizados por procesos de red. Si deseara
mostrar los archivos de red en uso por algún proceso de red en particular, se utilizan las opciones
-i seguido de la opcion grep y el nombre de algún servicio. En el siguiente ejemplo se pide a lsof
mostrar solamente los archivos de red utilizados por los procesos de red derivados de named:
# lsof -i | grep named
Si tiene dudas y desea consultar el manual de lsof puede consultarse ejecutando lo siguiente:
# man 8 lsof
pág. 201
Implementar y Administrar Cuotas De Disco (Disk Quotas) en Linux
Sistemas Linux con gran cantidad de usuarios, como servidores de correo, servidores samba, etc.,
tarde o temprano tienen el problema de usuarios que almacenan demasiada información en sus
directorios de trabajo, pudiendo incluso en casos extremos llenar completamente discos duros
haciendo el sistema inservible. Con el uso de cuotas de disco (disk quotas) es posible limitar la
cantidad de espacio disponible para cada usuario o de manera global para todos. En este manual
de LinuxTotal.com.mx conocerás a fondo como implementar y administrar cuotas de disco para
control de los usuarios.
Tipos de cuota
Por Bloques (blocks): Un bloque corresponde a 1 kb y una cuota por bloques correspondería al
total de bloques que un usuario puede utilizar en el sistema. Recuerda que los archivos se guardan
en bloques de disco. Asi un archivo de 100 bytes, ocupará un un bloque de 1kb en el disco duro.
Por Inodos (inodes): Un inodo o inode en inglés (Index Node) es un número que actua como
apuntador para el sistema de archivos de Linux y le indica en que bloques específicos del disco
duro se encuentran los datos de un archivo. También el inodo en su referencia guarda información
sobre permisos, propietario, atributos, etc. Se podría ver en una analogía simple que un inodo es
como un número de serie único para cada archivo del sistema y a través de este número el sistema
recupera sus datos (bloques) y sus atributos (permisos, propietario, fechas, etc.).
En el caso de las cutoas, una cuota por inodos indicaría el total de indos a los que el usuario tiene
derecho, casi representaría el total de archivos que el usuario puede crear y digo "casi" porque
los usuarios podemos crear enlaces simbólicos (ln -s) sobre archivos ya existentes que no
aumentan las cantidad de inodos. Pero por simplicidad puedes verlo como un 1 inodo = 1 archivo.
Límites
Tanto las cuotas por bloques o por inodos, tienen límites de uso y son de dos tipos:
HARD: (Duro) Cuando se establece (para bloques o inodos), es el límite absoluto. El usuario no
podrá exceder este límite.
SOFT: (Suave) Este límite (para bloques o inodos) que es siempre menor al HARD, puede ser
excedido por el usuario, pero será constantemente advertido que el límite de uso para bloques o
inodos ya ha sido excedido. Podría verse como un límite de advertencia que le estará indicando
pág. 202
al usuario que su límite ya se excedió y tome medidas.
Cuando se usa el límite SOFT, dos situaciones pueden ocurrir. La primera es que NO se tenga
establecido un tiempo de gracia, y entonces el usuario podrá seguir usando bloques o inodos
hasta llegar al límite HARD que será su límite absoluto de uso.
La segunda situación es que SI se tenga establecido el tiempo de gracia, que puede ser en días,
horas, minutos o segundos. En este caso, el usuario podrá seguir usando bloques o inodos hasta
que termine el tiempo de gracía o llegue al límite HARD, cualquiera que ocurra primero.
El tiempo de gracias se puede establecer por usuario o globalmente y más adelante veremos como
establecerlo.
¿Donde se implementan?
Las cuotas se establecen por filesystem o sistema de archivos, es decir, debes de decidir en donde
es más conveniente instalar un sistema de cuotas, pero no hay ningún problema si se instala en
todos. Las cuotas pueden establecerse por usuario, por grupos o ambos.
En el siguiente ejemplo:
#> mount
/dev/sda1 on /boot type ext3 (rw,noatime)
/dev/sda2 on / type ext3 (rw,noatime)
/dev/sda3 on /home type ext3 (rw,noatime)
none on /proc type proc (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
Lo anterior es un ejemplo típico de un equipo Linux con varios sistemas de archivos (/boot, / y
/home). Como se sabe en /home es donde los usuarios tienen sus directorios de trabajo (HOME),
asi que solo en este sistema de archivos crearemos cuotas, en los otros dos no tiene caso.
Configuración
Todo debe hacerse como root, y lo primero que haremos es editar el archivo "/etc/fstab" y
añadiremos "usrquota" o "grpquota", dependiendo si se desea cuotas por usuario o grupos, o
incluso ambas.
pág. 203
#> vi /etc/fstab
/dev/sda2 /
/dev/sda1 /boot
/dev/sda3 /home
....
ext3
ext3
ext3
noatime
noatime
noatime
1
1
1
1
2
2
(Añadimos en la cuarta columna el tipo de cuotas que deseamos)
/dev/sda2 /
ext3
noatime
1
1
/dev/sda1 /boot
ext3
noatime
1
2
/dev/sda3 /home
ext3
noatime,usrquota,grpquota
...
1
2
Algo similar a lo anterior deberá tener tu archivo de configuración, y como ya se indicó solo
agregamos el soporte para cuotas en el sistema de archivos que nos interese. Lo anterior por si
solo, es obvio que no hace nada, habría que reiniciar el sistema para que se apliquen los cambios
pero realmente no es necesario, lo siguiente re-monta el sistema de archivos "/home":
#> mount -o remount /home
#> mount
/dev/sda1 on /boot type ext3 (rw,noatime)
/dev/sda2 on / type ext3 (rw,noatime)
/dev/sda3 on /home type ext3 (rw,noatime,usrquota,grpquota)
none on /proc type proc (rw)
El sistema de archivos "/home" esta listo ahora para soportar cuotas de disco. El siguiente paso
es verificar con el comando quotacheck por sistemas de archivos que soporten cuotas. Este
comando crea, verifica o repara el control de cuotas en los sistemas que lo soporten, en este caso
creara el soporte:
#> quotacheck -augmv
quotacheck: Scanning /dev/sda3 [/home] done
quotacheck: Cannot stat old user quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old group quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old user quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old group quota file: No existe el fichero o el directorio
quotacheck: Checked 2539 directories and 35556 files
quotacheck: Old file not found.
pág. 204
quotacheck: Old file not found.
Los errores que envía es precisamente porque no existía un sistema de cuotas previo, es normal
que los envíe. Cuando las cuotas esten en pleno uso, es conveniente ejecutar
quotacheck periódicamente para que verifique inconsistencias y se corrijan a tiempo. En cuanto
a las opciones estas indican lo siguiente:
a - all, es decir verifica todos los sistemas de archivos por cuotas.
u - user, verifica por soporte de cuotas para usuarios.
g - group, verifica por soporte de cuotas para grupos.
m - no-remount, evita que el sistema se remonte como de solo lectura.
v - verboso, reporta lo que hace conforme progresa, son los mensajes que salen a la
terminal.
Como ves, la opción -a en este caso no era necesario puesto que solo tenemos "/home" con
cuotas, asi que el comando anterior también pudiera ser invocado de esta manera:
#> quotacheck -ugmv /home
Pues el sistema esta listo para manipular cuotas de usuario, esto lo podemos comprobar porque
en la raíz del sistema de archivos soportado con cuotas deben existir los archivos "aquota.user" y
"aquota.group" que son binarios, no trates de modificarlos o manipularlos:
#> cd /home
#> ls -l
total 72
-rw------- 1 root root 8192 2008-05-17 21:38 aquota.group
-rw------- 1 root root 8192 2008-05-17 21:38 aquota.user
drwx--x--x 4 user1 user1 4096 2008-05-12 16:13 user1/
drwx--x--x 4 user2 user2 4096 2008-05-12 16:13 user2/
drwx--x--x 3 user3 user3 4096 2008-05-05 12:01 user3/
drwx--x--x 3 user4 user4 4096 2008-05-05 12:01 user4/
(obsérvese los dos archivos de control de cuotas, para usuarios y grupos)
Si se tuvieran más sistemas de archivos con soporte para cuotas en la raíz de cada uno estarían
estos archivos, o solo uno dependiendo lo que se pidió, usuarios, grupos o ambos. Por cierto, en
pág. 205
sistemas con kernel 2.2 o anterior se usaba la versión 1 de cuotas y sus archivos de control se
nombraban "quota.user" y "quota.group", del kernel 2.4 y posteriores con la versión 2 y 3, se
utiliza los mostrados anteriormente.
Ahora bien, lo anterior deja listo el sistema para el soporte de cuotas pero estás siguen sin ser
activadas se requiere activar el soporte de cuotas, para lo cual invocamos el comandoquotaon:
#> quotaon -ugv /home
/dev/sda3 [/home]: group quotas turned on
/dev/sda3 [/home]: user quotas turned on
Activamos para "/home" cuotas de usuario y grupos. Cuando por alguna razón sea necesario
desactivar las cuotas, entonces utiliza la contraparte, que es el comando quotaoff:
#> quotaoff -v /home
/dev/sda3 [/home]: group quotas turned off
/dev/sda3 [/home]: user quotas turned off
Muy bien, hasta aqui ya tienes el sistema de archivos "/home" o el que hayas elegido (o todos)
para trabajar con soporte de cuotas para los usuarios y grupos, ahora veremos como aplicar estas
cuotas con los usuarios.
Aplicando la cuota a usuarios
Ahara hay que aplicar la cuota por usuario, aunque el sistema de archivos ya soporta cuotas y
están habilitadas, por defecto ningún usuario tiene establecidas cuotas. Asi que para iniciar habrá
que administrar cada usuario a través del comando edquota, que abrirá el editor de texto que se
tenga por defecto y mostrará lo siguiente:
#> edquota -u user1
Disk quotas for user user1 (uid 502):
Filesystem
blocks
soft
/dev/sda3
56
0
hard inodes
0
14
0
soft
0
hard
Las columnas "blocks" e "inodes" son informativas, es decir nos indican la cantidad de bloques o
inodos utilizados actualmente por el usuario, y las que podemos editar son las columnas "soft" y
"hard" de cada caso. Como ya se explicó en la primera parte de este artículo, se puede indicar
pág. 206
libremente cualquiera de los cuatro valores, es perfectamente posible establecer valores por
bloques, por inodos o ambos, solo recuerda que el límite soft debe ser menor al hard.
Si se establece solo el hard, no habrá advertencias previas y el usuario ya no podrá guardar
archivos cuando se llegue al valor. Si se establece soft y hard, avisará cuando se rebase el límite
soft y entrará en juego el periodo de gracia. Si se acaba el tiempo de gracias o se llega al har (lo
que sea primero) ya no se podrán crear más archivos hasta que no se eliminen algunos de los que
se tengan actualmente.
Para modificar cuotas a nivel grupo, se usa el mismo comando pero con la opción -g(edquota -g
ventas).En el ejemplo previo se modifica la cuota del usuario "user1" en el sistema de archivos
"/home" que es el que se ha usado de ejemplo en este artículo de LinuxTotal.com.mx, el
comportamiento por default es modificar cuotas para ese usuario en todos los sistemas de
archivos que tengan activo el control de cuotas (quotaon). Si se desea control de cuotas para un
filesystem en específico entonces se agrega la opción -f:
#> edquota -u user1 -f /home
(solo aplica la cuota en el sistema de archivos indicado)
Verificando el uso de las cuotas
Como usuario administrador 'root' puedes ver el uso de cuotas de cualquier usuario, ya sea
individualmente o por medio de un reporte global.
Por usuario o individualmente se usa el comando quota, estando como "root":
#> quota -u user1
Disk quotas for user user1 (uid 502):
Filesystem blocks quota limit grace files quota limit grace
/dev/sda3 56 70 100
14
0
0
Con usuarios que manejan cantidades muy grandes de cuota, es un poco dificil calcular en
términos de megas o gigas el espacio usuado y los límites de cuotas:
#> quota -u sergio
Disk quotas for user sergio (uid 500):
Filesystem blocks quota limit grace files quota limit grace
/dev/sda3 42578888
0 50000000
34895
0
0
pág. 207
Usando la opción -s se mejora el informe:
#> quota -s -u sergon
Disk quotas for user sergon (uid 500):
Filesystem blocks quota limit grace files quota limit grace
/dev/sda3 41582M
0 48829M
34905
0
0
Como usuario individual del sistema, puedes observar tus cuotas con el mismo comandoquota,
sin argumentos.
Ahora bien, si se desea un reporte global de las cuotas de todos los usuarios o por grupos, siendo
"root" utiliza el comando repquota:
#> repquota /home
*** Report for user quotas on device /dev/sda3
Block grace time: 7days; Inode grace time: 7days
Block limits
File limits
User
used soft hard grace used soft hard grace
---------------------------------------------------------------------root -- 184280
0
0
11 0 0
sergio -- 42579852 0 50000000
34902 0 0
user1 -- 56 70 100
14 0 0
user2 -- 52
0
0
13 0 0
user3 -- 28
0
0
7 0 0
user4 -- 28
0
0
7 0 0
Con repquota es también posible utilizar la opción -s para observar los tamaños en formato
legible. Si se usa la opción -a (all) en vez del sistema de archivos "/home", el reporte será para
todos los sistemas de archivos en el equipo que soporten cuotas. Asi mismo este reporte por
defecto es por usuarios, si se requiere que repquota reporte por grupos, añade entonces la
opción -g.
Obsérvese en la segunda línea del reporte el tiempo de gracia (grace time), que es de 7 días tanto
para cuotas por bloque como para cuotas por archivos o inodos. Esto aplica para todos los
usuarios en global, como se aprecia en el listado que ninguno tiene establecido un tiempo de
gracia diferente al global.
Estableciendo el tiempo de gracia
A nivel global, un periodo de gracia para todos, utiliza la opción -t del comando edquota, como
pág. 208
en el siguiente ejemplo, recuerda que debes ser "root":
#> edquota -t
Grace period before enforcing soft limits for users:
Time units may be: days, hours, minutes, or seconds
Filesystem
Block grace period Inode grace period
/dev/sda3
7days
7days
7 días es el periodo por defecto, si lo cambias a digamos 12 horas, sería "12hours". El tiempo de
gracia puede ser distinto para el límite soft por bloques o por inodos.
Por usuario específico se realiza con la opción -T del mismo comando e indicando el usuario:
#> edquota -u user1 -T
Times to enforce softlimit for user user1 (uid 502):
Time units may be: days, hours, minutes, or seconds
Filesystem
block grace
inode grace
/dev/sda3
unset
unset
Lo único que hay que considerar es que los tiempos de gracias por usuario deben ser menores al
global. Y que este empieza a correr una vez que se ha llegado al límite soft. Cuando esto suceda,
si entras a editar de nuevo el tiempo de gracia del usuario (edquota -u user -T) se reflejara en
segundos el tiempo que le queda, pudiéndolo aumentar de nuevo si eres "root". O dejarlo en cero
y entonces el global será el que se utilice.
Fijar cuotas de manera global a todos los usuarios
En sistemas Linux con pocos usuarios, establecer las cuotas usuario por usuario no representa
ningún problema. Pero si hablamos por ejemplo de una universidad donde pudieran existir miles
de cuentas entonces si es un problema establecer cuentas individualmente.
Realmente no existe una manera "oficial" de establecer cuotas masivamente, sin embargo, no
hay problema, usaremos un pequeño script que te permitira realizarlo.
Establece la cuota que deseas globalmente en un solo usuario:
#> edquota -u user1
Disk quotas for user user1 (uid 502):
pág. 209
Filesystem
/dev/sda3
:wq
blocks
68
soft
300
hard
400
inodes soft hard
17
0
0
Veamos el reporte de cuotas con repquota:
[root@segolap ~]# repquota /home
*** Report for user quotas on device /dev/sda3
Block grace time: 7days; Inode grace time: 7days
Block limits
File limits
User
used soft hard grace used soft hard grace
---------------------------------------------------------------------user1 -- 68 300 400
17 0 0
user2 -- 352
0
0
13 0 0
user3 -- 28
0
0
7 0 0
user4 -- 28
0
0
7 0 0
Solo el usuario "user1" tiene cuotas, las columnas de "grace" tendrán valores una vez que se
llegue al límite soft o suave. Usaremos entonces la opción -p (protptype) para hacer duplicados a
partir del ya establecido.
#> edquota -p user1 user2
Con lo anterior "copias" la información de límites de cuotas del "user1" al "user2", no hay límite
de cuantos usuarios puedes colocar como argumentos asi que lo siguiente es válido:
#> edquota -p user1 user2 user3 user4
Práctico para unos cuantos usuarios pero inútil si necesitamos duplicarlo en cientos de usuarios,
asi que hagamos un comando compuesto que nos extraiga los nombres de los usuarios, se puede
usar por ejemplo gawk para realizar lo anterior:
#> gawk -F: '$3 > 499 {print $1}' /etc/passwd
user1
user2
user3
user4
pág. 210
Usamos el separador ":" de campos (-F), e indicamos como acción que en el campo 3 ($3)
busquemos todos los UID mayores a 499 y que los imprima ({print $1}). Ahora solo tenemos que
usar este comando junto con edquota -p:
#> edquota -p user1 `gawk -F: '$3 > 499 {print $1}' /etc/passwd`
(importante: nota el uso de acento grave que abarca al comando gawk, esto para que el shell
lo ejecute primero y el resultado serán los argumentos, uno o cientos de usuarios cuyo UID
es mayor a 499)
Haciendo uso de repquota de nuevo veamos que pasó:
#> repquota /home
*** Report for user quotas on device /dev/sda3
Block grace time: 7days; Inode grace time: 7days
Block limits
File limits
User
used soft hard grace used soft hard grace
---------------------------------------------------------------------user1 -- 68 300 400
17 0 0
user2 -- 352 300 400 7days 13 0 0
user3 -- 28 300 400
7 0 0
user4 -- 28 300 400
7 0 0
Primero, todos los usuarios tienen las mismas cuotas que el "user1" que fue el prototipo para los
demás y segundo se observa que el "usuario" que tiene 352 bloques utilizados al pasar el límite
suave entro al periodo de gracia automáticamente que el global es de 7 días. A partir del instante
que el límite cambió de 0 a 300, comenzó el periodo de gracia. Ahora solo podrá crear más
archivos durante 7 días o cuando llegue a 400, lo primero que ocurra, claro, asumiendo que no
borre archivos primeros para recuperar espacio.
Para fines practicos realice el siguiente ejercicio;
Daremos de alta un usuario;
# useradd usuarioquota
Le asignamos un password;
# passwd usuarioquota
Ahora a este usuario le asignaremos una cuota de gracias de 50Mb(51200) y una cuota definitiva
pág. 211
de 100Mb(102400).
Nos logueamos como usuarioquota
Una vez en el perfil copiaremos los archivos que están en la carpeta /usr/lib a un directorio en el
home del usuarioquota
$ cp -r /usr/lib ~/prueba-cuotas
Notará que llegará un momento en el que el sistema indicará que ya es imposible continuar
copiando contenido dentro de ~/prueba-cuotas debido a que se agotó el espacio disponible para
el usuario en el sistema de archivos.
Ejecute de nuevo quota y observe con detenimiento la salida. En ésta aparecerá un asterisco junto
a la cantidad mostrada en las columnas de bloques o bien inodos en los casos donde se hayan
excedido las cuotas.
Verificamos con el comando quota
$ quota
Para solucionar el problema, borramos la carpeta y después verificamos de nuevo.
UNIDAD 7.- Redes
Configuración de red.
Primero nos tenemos que identificar como root para ejecutar los comandos. Para esto colocamos
en la línea de comandos:
# su Para ver cuales son las interfaces de red que tienes disponibles ejecutamos:
# ifconfig | less
La opción de less te permite ver pagina por página las interfaces (en caso de que tengas muchas
o una ventana de comandos pequeña), este comando sólo te muestra las interfaces que están
arriba (up). Te debe aparecer algo como eth0, eth1 y lo (esta interfaz es la de loopback y es la del
propio servidor).
Si queremos mostrar todas las interfaces esten arriba (o levantadas) ejecutamos el siguiente
comando:
pág. 212
# ifconfig –a
Y nos debería mostrar algo como esto:
eth0 Link encap:Ethernet HWaddr 00:0C:29:97:XX:XX
inet addr:10.21.9.70 Bcast:10.21.11.255 Mask:255.255.252.0
inet6 addr: fe80::20c:29ff:fe97:24e3/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:491604 errors:0 dropped:0 overruns:0 frame:0
TX packets:3856 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:57073655 (54.4 MiB) TX bytes:506213 (494.3 KiB)
Interrupt:185 Base address:0x1400
eth1 Link encap:Ethernet HWaddr 00:11:25:29:XX:XX
BROADCAST MULTICAST MTU:1500 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)
Interrupt:19
lo
Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:1901 errors:0 dropped:0 overruns:0 frame:0
TX packets:1901 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:3804398 (3.6 MiB) TX bytes:3804398 (3.6 MiB)
En este caso tenemos dos interfaces eth0 y eth1, y sólo eth0 esta arriba, ya que como
podemos ver eth1 no tiene ninguna dirección IP asignada y no tiene ninguna configuración.Por
último tenemos la interfaz lo, que es la interfaz de loopback es decir nuestra propia máquina y
que podemos acceder a través de la dirección 127.0.0.1 (o cualquier rango de 127.0.0.X), y sirve
pág. 213
para comprobar que por lo menos nos responde nuestro propio ordenador o computadora.
Ahora que ya sabemos identificar nuestras tarjetas de red pasemos a lo que podemos hacer con
ellas.
Para asignar direcciones IP manualmente esto ejecutamos el siguiente comando:
# ifconfig eth0 192.168.1.100 255.255.255.0 up
Con broadcast
# ip addr add 192.168.0.10/24 dev eth0 brd +
Cambiando eth0 por el nombre de la interfaz que necesitamos. Si queremos deshabilitar una
interfaz ejecutamos:
# ifconfig eth0 down
Recuerde que si agrega direcciones con rutas lo haría de la siguiente manera:
#route add 169.155.0.0/16 dev eth0
Y la información de las rutas agregadas esta en el archivo routes ubicado en:
/etc/sysconfig/network/routes
Además hay un programa interactivo de consola que nos deja configurar la red mucho más fácil,
incluyendo dhcp, direcciones estáticas puerta de enlace (gateway) ejecutamos el siguiente
comando:
Red Hat:
# redhat-config-network
CentOS y Fedora:
#system-config-network
Te aparecerá un diálogo donde tendras que escoger la interfaz de red que quieres configurar y
luego de seleccionarla verás las distintas opciones.
pág. 214
Una vez que cambies los parámetros de tu interfaz de red siempre es bueno reiniciar el servicio de
red para que se reflejen los cambios:
# service network restart
Archivos de configuración
Si quieres manualmente cambiar los archivos de configuración de tus interfaces de red debes
editar los archivos dentro de /etc/sysconfig/network-scripts/ por ejemplo para la interfaz eth0
sería:
# vim /etc/sysconfig/network-scripts/ifcfg-eth0
Nota: No olvides hacer un backup del archivo en caso de falla antes de hacer cualquier cambio con:
# cp /etc/sysconfig/network-scripts/ifcfg-eth0 /root/ifcfg-eth0.backup
Puedes utilizar el editor que quieras (nano, emac, etc) Debes ver una configuración como la
siguiente:
DEVICE=eth0
BOOTPROTO=static
BROADCAST=192.168.1.255
HWADDR=00:0C:29:97:XX:XX
IPADDR=192.168.1.100
NETMASK=255.255.255.0
NETWORK=192.168.1.0
ONBOOT=yes
TYPE=Ethernet
Una vez realizados los cambios reiniciamos los servicios de red:
# service network restart
Puedes cambiar los parámetros según lo que necesites, por ejemplo si necesitas se configure por
DHCP deberías tener algo como:
DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
pág. 215
HWADDR=00:0c:29:97:24:e3
TYPE=Ethernet
Una vez realizados los cambios reiniciamos los servicios de red:
# service network restart
Configurando DNS
Para hacer que tu computadora u ordenador busque en un servidor DNS específico tienes que
modificar el archivo /etc/resolv.conf ejecuntado
# vim /etc/resolv.conf
Ahí puedes agregar los servidores que quieras por ejemplo con:
Nameserver 10.50.50.130
nameserver 10.50.50.131
Utilizando las direcciones IP de los servidores DNS que quieras.
Configuración del fichero resolv.conf
Cuando se configura la biblioteca de resolución para utilizar los servicios de BIND, tiene que
indicarse también qué servidores utilizar. El fichero resolv.conf contiene una lista de servidores,
que si está vacía hará considerar al sistema que el servidor está en su máquina.
Si ejecuta un servidor de nombres en su máquina local, tendrá que configurarlo por separado,
como se explicará después. Si se encuentra en una red local y puede usar un servidor de nombres
existente, mejor. Si estamos conectados a Internet por módem, lo habitual es especificar
en resolv.conf el servidor de nombres que nos diga nuestro proveedor de servicios.
La opción más importante del fichero resolv.conf es nameserver, que tiene la dirección IP del
servidor de nombres a usar. Si especifican varios servidores poniendo varias líneas nameserver,
se intentarán usar en el orden dado; por lo que debería poner en primer lugar el servidor de
nombres más rápido o cercano. Actualmente, puede ponerse un máximo de tres servidores
distintos. Si no se pone ninguno, intentará buscar un servidor de nombres en la máquina local.
Otras dos opciones, domain y search, nos permiten usar nombres cortos (sin dominio) para
máquinas que estén en nuestro dominio. Normalmente, para conectarnos a una máquina de la
misma red, no queremos poner el dominio completo, sino su nombre. Por ejemplo, gauss en lugar
de gauss.mathematics.groucho.edu.
Para esto sirve la palabra domain. Nos permite especificar un dominio predeterminado que se
pág. 216
añade a las peticiones cuando su búsqueda inicial falla. Por ejemplo, al buscar gauss y fallar el
servidor de nombres buscándolo en Internet, le añade automáticamente su dominio
predeterminado y ya sí puede resolverlo.
Esto está bien, pensaremos, pero tan pronto como nos refiramos a una máquina que esté fuera
del Departamento de Matemáticas, tendremos que volver a teclear el dominio completo. A lo
mejor queremos teclear solo quark.physics para referirnos a una máquina del Departamento de
Físicas.
Para esto podemos usar la lista de búsqueda, que puede especificarse con la opción search. En
esta lista se especifica una lista de dominios donde resolver nombres cortos. Los elementos de la
lista deben especificarse separándolos por espacios o tabuladores.
Las opciones search y domain son mutuamente excluyentes y no pueden aparecer más de una
vez. Si ninguna de las dos se pone, el sistema intentará asignar a los nombres cortos el dominio
de la máquina local, que averiguará usando la llamada al sistema getdomainname (2). Si el nodo
local no tiene dominio, se asumirá que el dominio predeterminado es la raíz.
Si decidimos poner una opción search en el fichero resolv.conf, habrá que ser cuidadosos con los
dominios que añadimos a la lista. Las bibliotecas de resolución anteriores a BIND 4.9 solían
construir una lista de búsqueda predeterminada para el dominio cuando no se proporciona otra
lista. Esta lista predeterminada se hacía con el dominio del nodo, más todos los dominios padre
hasta llegar a la raíz. Esto daba lugar a búsquedas innecesarias a los servidores de nombres
externos.
Asumamos que estamos en la Cervecera Virtual y queremos conectarnos al
sistema foot.groucho.edu. Por un error tecleamos el nombre foo, que no existe. El servidor de la
universidad nos responderá que no existe el nodo. Con la búsqueda antigua, intentará buscar ese
nombre en los dominios vbrew.com y com. Este último es problemático porque causa una
búsqueda innecesaria y además podría existir. Al final nos habremos intentado conectar a una
máquina totalmente ajena.
En algunos casos, esto es un potencial problema de seguridad. De hecho las listas de búsqueda
deben limitarse a dominios de la organización local o algo similar. La lista en el Departamento de
Matemáticas debe limitarse a los dominios maths.groucho.edu y groucho.edu.
Como lo anterior puede resultar confuso, sea el siguiente ejemplo de fichero resolv.conf para la
Cervecera Virtual:
# /etc/resolv.conf
# Nuestro dominio
domain
vbrew.com
pág. 217
#
# Nuestro servidor principal va a ser vlager:
name server 172.16.1.1
Cuando se trate de traducir el nombre vale, el sistema empezará por buscar directamente vale y
si falla, probará con vale.vbrew.com.
Iptables
Red Hat Enterprise Linux contiene herramientas avanzadas para el filtrado de paquetes de red —
el proceso dentro del kernel de controlar los paquetes de red al entrar, mientras se mueven y
cuando salen de la red. Los kernels anteriores al 2.4 confiaban en ipchains para el filtrado de
paquetes y usaban listas de reglas aplicadas a los paquetes en cada paso del proceso de filtrado.
La introducción de kernel 2.4 trajo consigo iptables (también llamado netfilter), lo cual es similar
a ipchains pero expande enormemente el ámbito y el control disponible para el filtrado de
paquetes de red.
Este capítulo se centra en las bases del filtrado esencial de paquetes, define las diferencias
entre ipchains e iptables, explica las diferentes opciones disponibles con comandos iptables y
muestra cómo se pueden preservar las reglas de filtrado durante reinicios del sistema.
Filtrado de paquetes
El kernel de Linux tiene incorporado la característica interna de filtrar paquetes, permitiendo
aceptar algunos de ellos en el sistema mientras que intercepta y para a otros. El netfilter del kernel
tiene tres tablas o listas de reglas incorporadas. Son las siguientes:
filter — La tabla por defecto para el manejo de paquetes de red.
nat — Usada para alterar paquetes que crean una nueva conexión y utilizada para
la Traducción de direcciones de red (Network Address Translation, NAT).
mangle — Usada por tipos específicos de alteración de paquetes.
Cada una de estas tablas tiene un grupo de cadenas incorporadas que corresponden a las acciones
llevadas a cabo por el filtro de la red.
Las cadenas internas para la tabla filtro son las siguientes:
INPUT — Aplica a los paquetes recibidos a través de una interfaz de red.
OUTPUT — Esta cadena sirve para paquetes enviados por medio de la misma interfaz de red
que recibió los paquetes.
pág. 218
FORWARD — Esta cadena sirve para paquetes recibidos en una interfaz de red y enviados
en otra.
Las cadenas internas para la tabla nat son las siguientes:
PREROUTING — Altera los paquetes de red cuando estos llegan.
POSTROUTING — Esta cadena altera paquetes antes de que sean enviados por medio de una
interfaz de red.
POSTROUTING — Altera los paquetes de red cuando estos son enviados.
PREROUTING — Esta cadena altera paquetes recibidos por medio de una interfaz de red cuando
llegan.
OUTPUT — Esta cadena altera paquetes generados localmente antes de que sean dirigidos
por medio de una interfaz de red.
POSTROUTING — Esta cadena altera paquetes antes de que sean enviados por medio de una
interfaz de red.
Las cadenas internas para la tabla mangle son las siguientes:
PREROUTING — Esta cadena altera paquetes recibidos por medio de una interfaz de red
antes de que sean dirigidos.
POSTROUTING — Altera los paquetes de red cuando estos son enviados.
Cada paquete de red recibido o enviado desde un sistema Linux está sujeto a al menos una tabla.
Sin embargo, un paquete puede estar sometido a múltiples reglas dentro de cada tabla antes de
emerger al final de la cadena. La estructura y propósito de estas reglas puede variar, pero
normalmente buscan identificar un paquete que viene de o se dirige hacia una dirección IP en
particular, o un conjunto de direcciones, cuando utiliza un determinado protocolo y servicio de
red.
Independientemente de su destino, cuando un paquete cumple una regla en particular en una de
las tablas, se les aplica un objetivo (target) o acción a ellos. Si la regla especifica un
objetivo ACCEPT para un paquete que coincida, el paquete se salta el resto de las verificaciones
de la regla y se permite que continúe hacia su destino. Si una regla especifica un objetivo DROP,
a ese paquete se le niega el acceso al sistema y no se envía nada de vuelta al servidor que envió
el paquete. Si una regla especifica un objetivo QUEUE, el paquete se pasa al espacio del usuario.
Si una regla especifica el objetivo opcional REJECT, el paquete es descartado, pero se envía un
paquete de error al que envió el paquete.
pág. 219
Cada cadena tiene una política por defecto de ACCEPT, DROP, REJECT, o QUEUE. Si ninguna de
estas reglas en la cadena se aplica al paquete, entonces el paquete es tratado de acuerdo a la
política por defecto.
El comando iptables configura estas tablas, así como también configura nuevas tablas si es
necesario.
Diferencias entre iptables e ipchains
A primera vista, ipchains e iptables parecen ser bastante similares. Ambos métodos de filtrado de
paquetes usan cadenas de reglas operando dentro del kernel de Linux para decidir qué hacer con
los paquetes que cumplen determinadas reglas. Sin embargo, iptables proporciona un método
mucho más extensible de filtrado de paquetes, proporcionando al administrador un nivel de
control mucho más refinado sin tener que aumentar la complejidad del sistema entero.
Más concretamente, los usuarios que se encuentren cómodos con ipchains deberían tener
cuidado con las siguientes diferencias significativas entre ipchains e iptables antes de
utilizar iptables:
Bajo iptables, cada paquete filtrado se procesa únicamente usando las reglas de una cadena
solamente, en lugar de hacerse con múltiples. Por ejemplo, un paquete FORWARD que llega
al sistema usando ipchains tendrá que pasar por las cadenas INPUT, FORWARD, y OUTPUT
para llegar a su destino. Sin embargo, iptables sólo envía paquetes a la cadena INPUT si su
destino es el sistema local y tan sólo los envía a la cadena OUTPUT si el sistema local es quien
genera los paquetes. Por esta razón, es importante que coloque la regla designada para
capturar un paquete particular dentro de la regla que en verdad maneja el paquete.
El objetivo DENY ha sido cambiado a DROP. En ipchains, los paquetes que coincidan una
regla en una cadena podrían ser dirigidos al objetivo DENY. Este objetivo debe ser cambiado
a DROP bajo iptables.
El orden es importante cuando se estén colocando opciones en una regla. Anteriormente,
con ipchains, el orden de las opciones de una regla no importaba. El comando iptables usa
una sintaxis más estricta. En comandos iptables, el protocol (ICMP, TCP o UDP) debe ser
especificado antes del puerto fuente o destino.
Cuando especificamos las interfaces de red que vamos a usar en una regla, deberemos
utilizar sólo interfaces de entrada (opción -i) con cadenas INPUT o FORWARD y las de salida
(opción -o) con cadenas FORWARD o OUTPUT. Esto es necesario debido al hecho de que las
cadenas OUTPUT no se utilizan más con las interfaces de entrada, y las cadenas INPUT no
son vistas por los paquetes que se mueven hacia las interfaces de salida.
pág. 220
Opciones usadas en comandos iptables
Las reglas para el filtrado de paquetes se ponen en funcionamiento ejecutando el
comando iptables. Con frecuencia se utilizan los aspectos siguientes del paquete como el criterio:
Tipo de paquete — Dicta qué tipo de paquetes filtra el comando.
Fuente/Destino del paquete — Especifica cuáles paquetes filtra el comando basándose en el
origen o destino del paquete.
Objetivo — Indica qué acción es tomada en paquetes que cumplen los criterios mencionados
anteriormente.
Las opciones usadas con las reglas iptables dadas deben estar agrupadas lógicamente, basándose
en el propósito y en las condiciones de la regla general, para que la regla sea válida. El resto de
esta sección explica las opciones usadas comúnmente para el comando iptables.
Estructura de las opciones iptables
Muchos comandos iptables tienen la siguiente estructura:
iptables [-t <table-name>] <command> <chain-name> <parameter-1> \
<option-1> <parameter-n> <option-n>
La opción <table-name> permite al usuario seleccionar una tabla diferente a la tabla
predeterminada filter a usar con el comando. La opción <command> indica una acción específica
a realizar, tal como anexar o eliminar la regla especificada por la opción <chain-name>. Luego de
la opción <chain-name> se encuentran un par de parámetros y opciones que definen qué pasará
cuando un paquete coincide con la regla.
Cuando miramos la estructura de un comando iptables, es importante recordar que, al contrario
que la mayoría de los comandos, la longitud y complejidad de un comandoiptables puede cambiar
en función de su propósito. Un comando para borrar una regla de una cadena puede ser muy
corto, mientras que un comando diseñado para filtrar paquetes de una subred particular usando
un conjunto de parámetros específicos y opciones puede ser mucho más largo. Al crear
comandos iptables puede ser de ayuda reconocer que algunos parámetros y opciones pueden
crear la necesidad de utilizar otros parámetros y opciones para especificar más aún la petición de
la opción anterior. Para construir una regla válida, esto deberá continuar hasta que todos los
parámetros y opciones que requieran otro conjunto de opciones hayan sido satisfechos.
pág. 221
Escriba iptables -h para ver una lista detallada de la estructura de los comandos iptables.
Opciones de comandos
Las opciones de comandos le dicen a iptables que realice una acción específica. Solamente una
opción de comando se permite por comando iptables. Excepto el comando de ayuda, todos los
comandos se escriben en mayúsculas.
Los comandos de iptables son los siguientes:
-A — Añade la regla iptables al final de la cadena especificada. Este es el comando utilizado
para simplemente añadir una regla cuando el orden de las reglas en la cadena no importa.
-C — Verifica una regla en particular antes de añadirla en la cadena especificada por el
usuario. Este comando puede ser de ayuda para construir reglas iptables complejas
pidiéndole que introduzca parámetros y opciones adicionales.
-D — Borra una regla de una cadena en particular por número (como el 5 para la quinta regla
de una cadena). Puede también teclear la regla entera e iptables borrará la regla en la
cadena que corresponda.
-E — Renombra una cadena definida por el usuario. Esto no afecta la estructura de la tabla.
-F — Libera la cadena seleccionada, que borra cada regla de la cadena. Si no se especifica
ninguna cadena, este comando libera cada regla de cada cadena.
-h — Proporciona una lista de estructuras de comandos, así como también un resumen
rápido de parámetros de comandos y opciones.
-I — Inserta una regla en una cadena en un punto especificado por un valor entero definido
por el usuario. Si no se especifica ningún número, iptables colocará el comando en el tope
de la cadena.
-L — Lista todas las reglas de la cadena especificada tras el comando. Para ver una lista de
todas las reglas en todas las cadenas en la tabla por defecto filter, no especifique ninguna
cadena o tabla. De lo contrario, la sintaxis siguiente deberá utilizarse para listar las reglas en
una cadena específica en una tabla en particular:
iptables -L <chain-name> -t <table-name>
-N — Crea una nueva cadena con un nombre especificado por el usuario.
-P — Configura la política por defecto para una cadena en particular, de tal forma que,
cuando los paquetes atraviesen la cadena completa sin cumplir ninguna regla, serán
enviados a un objetivo en particular, como puedan ser ACCEPT o DROP.
pág. 222
-R — Reemplaza una regla en una cadena particular. El número de la regla debe ser
especificado después del nombre de la cadena. La primera regla en una cadena corresponde
a la regla número uno.
-X — Borra una cadena especificada por el usuario. No se permite borrar ninguna de las
cadenas predefinidas para cualquier tabla.
-Z — Pone ceros en los contadores de byte y de paquete en todas las cadenas de una tabla
en particular.
Opciones de parámetros de iptables
Una vez que se especifiquen ciertos comandos iptables, incluyendo aquellos para añadir, anexar,
eliminar, insertar o reemplazar reglas dentro de una cadena, se requieren parámetros para
construir una regla de filtrado de paquetes.
-c — Resetea los contadores de una regla en particular. Este parámetro acepta las
opciones PKTS y BYTES para especificar qué contador hay que resetear.
-d — Configura el nombre de la máquina destino, dirección IP o red de un paquete que
coincide con la regla. Cuando se coincida una red, se soportan los siguientes formatos de
direcciones IP o máscaras de red:
N.N.N.N/M.M.M.M — Donde N.N.N.N es el rango de direcciones IP y M.M.M.M es la
máscara de la red.
N.N.N.N/M — Donde N.N.N.N es el rango de direcciones IP y M es la máscara de bit.
-f — Aplica esta regla sólo a los paquetes fragmentados.
Usando la opción ! después de este parámetro, únicamente se harán coincidir los paquetes
no fragmentados.
-i — Configura la interfaz de red entrante, tal como eth0 o ppp0. Con iptables, este
parámetro opcional puede ser usado solamente con las cadenas INPUT y FORWARD cuando
es usado con la tabla filter y la cadena PREROUTING con las tablas nat y mangle.
Este parámetro también soporta las siguientes opciones especiales:
El carácter de exclamación ! — Invierte la directriz, es decir, se excluye de esta regla
cualquier interfaz especificada.
El caráter de suma + — Un caracter tipo comodín utilizado para coincidir todas las interfaces
con una cadena de caracteres especificada. Por ejemplo, el parámetro -i eth+aplicará esta
regla a cualquier interfaz Ethernet pero excluirá cualquier otra interfaz, tal como, ppp0.
Si el parámetro -i se utiliza sin especificar ninguna interfaz, todas las interfaces estarán afectadas
por la regla.
pág. 223
-j — Salta a un objetivo particular cuando un paquete coincide con una regla particular. Los
objetivos válidos a usar después de la opción -j incluyen las opciones estándar
(ACCEPT, DROP, QUEUE y RETURN) así como también las opciones extendidas que están
disponibles a través de los módulos cargados por defecto con el paquete RPM de Red Hat
Enterprise Linux iptables, como LOG, MARK y REJECT, entre otros. Consulte la página del
manual de iptables para más información sobre esto y otros objetivos.
Puede también dirigir un paquete coincidiendo esta regla a una cadena definida por el
usuario fuera de la cadena actual, para aplicar otras reglas al paquete.
Si no especifica ningún objetivo, el paquete pasa la regla sin llevar a cabo ninguna acción.
A pesar de todo, el contador para esta regla se sigue incrementando en uno.
-o — Configura la interfaz de red de salida para una regla y puede ser usada solamente con
las cadenas OUTPUT y FORWARD en la tabla de filtro y la cadena POSTROUTING en las
tablas nat y mangle. Estos parámetros de opciones son los mismos que aquellos de la
interfaz de entrada (-i).
-p — Configura el protocolo IP para la regla, el cual puede ser icmp, tcp, udp, o all, para
coincidir todos los protocolos soportados. Además, se puede usar cualquier protocolo
listado en /etc/protocols. Si esta opción es omitida cuando se esté creando una regla, la
opción all es la opción por defecto.
-s — Configura la fuente para un paquete particular usando la misma sintaxis que el
parámetro (-d).
Opciones de coincidencia para iptables
Diferentes protocolos de red proporcionan opciones especializadas las cuales se pueden
configurar para coincidir un paquete particular usando ese protocolo. Sin embargo, primero se
debe especificar el protocolo en el comando iptables. Por ejemplo, -p tcp <protocolname> (donde <protocol-name> es el protocolo objetivo), hace disponibles las opciones para ese
protocolo especificado.
Protocolo TCP
Estas opciones de identificación están disponibles en el protocolo TCP (opción -p tcp):
--dport — Configura el puerto de destino para el paquete. Use bien sea un nombre de
servicio (tal como www o smtp), número de puerto, o el rango de números de puertos para
configurar esta opción. Para hojear los nombres y alias de los servicios de red y los números
que ellos usan, visualice el archivo /etc/services. La opción --destination-portes sinónimo
con --dport.
pág. 224
Para especificar un rango de números de puertos, separe los dos números con dos puntos
(:), tal como -p tcp --dport 3000:3200. El rango más grande aceptable es0:65535.
Use un caracter de exclamación (!) después de la opción --dport para coincidir todos los
paquetes que no utilizan el servicio de red o puerto.
--sport — Configura el puerto fuente del paquete usando las mismas opciones que --dport.
La opción --source-port es sinónimo con --sport.
--syn — Provoca que todos los paquetes designados de TCP, comúnmente
llamados paquetes SYN, cumplan esta regla. Cualquier paquete que esté llevando un
payload de datos no será tocado. Si se sitúa un punto de exclamación (!) como bandera tras
la opción --syn se provoca que todos los paquetes no-SYN sean seleccionados.
--tcp-flags — Permite a los paquetes TCP con bits específicos o banderas, ser coincididos con
una regla. La opción --tcp-flags acepta dos parámetros. El primer parámetro es la máscara,
la cual configura banderas a ser examinadas en el paquete. El segundo parámetro se refiere
a la bandera que se debe configurar para poder coincidir.
Las banderas posibles son:
ACK
FIN
PSH
RST
SYN
URG
ALL
NONE
Por ejemplo, una regla iptables que contenga -p tcp --tcp-flags ACK,FIN,SYN SYN tan sólo
seleccionará los paquetes TCP que tengan la bandera SYN activo y las banderas ACK y FIN sin
activar.
Usando el caracter de exclamación (!) después de --tcp-flags reversa el efecto de la opción de
coincidencia.
--tcp-option — Intenta seleccionar con opciones específicas de TCP que pueden estar activas
en un paquete en particular. Esta opción se puede revertir con el punto de exclamación (!).
Protocolo UDP
Estas opciones de selección están disponibles para el protocolo UDP (-p udp):
pág. 225
--dport — Especifica el puerto destino del paquete UDP, usando el nombre del servicio,
número de puerto, o rango de números de puertos. La opción de coincidencia --destinationport es sinónimo con --dport.
--sport — Configura el puerto fuente del paquete UDP, usando el nombre de puerto, número
de puerto o rango de números de puertos. La opción --source-port es sinónimo con --sport.
Protocolo ICMP
Las siguientes opciones de coincidencia están disponibles para el Protocolo de mensajes de
Internet (ICMP) (-p icmp):
--icmp-type — Selecciona el nombre o el número del tipo ICMP que concuerde con la regla.
Se puede obtener una lista de nombres válidos ICMP tecleando el comandoiptables -p icmp
-h.
Módulos con opciones de coincidencias adicionales
Opciones adicionales de coincidencia están disponibles a través de los módulos por el
comando iptables. Para usar un módulo de opciones de coincidencia, cargue el módulo por
nombre usando la opción -m, tal como -m <module-name> (reemplazando <module-name> con
el nombre del módulo).
Un gran número de módulos están disponibles por defecto. Hasta es posible crear sus módulos
para proporcionar funcionalidades de opciones de coincidencia adicionales.
Lo siguiente, es una lista parcial de los módulos usados más comúnmente:
limit module — Permite colocar un límite en cuántos paquetes son coincididos a una regla
particular. Esto es especialmente beneficioso cuando se usa en conjunto con el
objetivo LOG, pues puede prevenir que una inundación de paquetes coincidentes
sobrecarguen el registro del sistema con mensajes repetitivos o usen los recursos del
sistema.
El módulo limit habilita las opciones siguientes:
--limit — Configura el número de coincidencias en un intervalo de tiempo, especificado con
un número y un modificador de tiempo ordenados en el formato<número>/<tiempo>. Por
ejemplo, si usamos --limit 5/hour sólo dejaremos que una regla sea efectiva cinco veces a la
hora.
Si no se utiliza ningún número ni modificador de tiempo, se asume el siguiente valor por
defecto: 3/hour.
--limit-burst — Configura un límite en el número de paquetes capaces de cumplir una regla
en un determinado tiempo. Esta opción deberá ser usada junto con la opción--limit, y acepta
un número para configurar el intervalo de tiempo (threshold).
pág. 226
Si no se especifica ningún número, tan sólo cinco paquetes serán capaces inicialmente de
cumplir la regla.
módulo state — Habilita la coincidencia de estado.
El módulo state tiene las siguientes opciones:
--state — coincide un paquete con los siguientes estados de conexión:
ESTABLISHED El paquete seleccionado se asocia con otros paquetes en una conexión
establecida.
INVALID El paquete seleccionado no puede ser asociado a una conexión conocida.
NEW El paquete seleccionado o bien está creando una nueva conexión o bien forma parte
de una conexión de dos caminos que antes no había sido vista.
RELATED El paquete seleccionado está iniciando una nueva conexión en algún punto de la
conexión existente.
Estos estados de conexión se pueden utilizar en combinación con otros separándolos mediante
comas como en -m state --state INVALID, NEW.
módulo mac — Habilita la coincidencia de direcciones MAC de hardware.
El módulo mac activa las opciones siguientes:
--mac-source — Coincide una dirección MAC a la tarjeta de red que envió el paquete. Para
excluir una dirección MAC de la regla, coloque un símbolo de exclamación (!) después de la
opción --mac-source.
Para visualizar otras opciones disponibles a través de los módulos, consulte la página del manual
de iptables.
Opciones del objetivo
Una vez que un paquete ha coincidido con una regla, la regla puede dirigir el paquete a un número
de objetivos diferentes que deciden su suerte y, posiblemente, toman acciones adicionales. Cada
cadena tiene un objetivo por defecto, el cual es usado si ninguna de las reglas en esa cadena
coinciden con un paquete o si ninguna de las reglas que coinciden con el paquete especifica un
objetivo.
Los siguientes son los objetivos estándar:
<user-defined-chain> — Reemplace <user-defined-chain> con el nombre de una cadena
definida por el usuario dentro de la tabla. Este objetivo pasa el paquete a la cadena objetivo.
ACCEPT — Permite que el paquete se mueva hacia su destino (o hacia otra cadena, si no ha
sido configurado ningún destino para seguir a esta cadena).
pág. 227
DROP — Deja caer el paquete sin responder al solicitante. El sistema que envia el paquete
no es notificado de esta falla.
QUEUE — El paquete se pone en una cola para ser manejado por una aplicación en el espacio
de usuario.
RETURN — Para la verificación del paquete contra las reglas de la cadena actual. Si el paquete con
un destino RETURN cumple una regla de una cadena llamada desde otra cadena, el paquete es
devuelto a la primera cadena para retomar la verificación de la regla allí donde se dejó. Si la
regla RETURN se utiliza en una cadena predefinida, y el paquete no puede moverse hacia la
cadena anterior, el objetivo por defecto de la cadena actual decide qué acción llevar a cabo.
Además de estos objetivos standard, se pueden usar otros más con extensiones
llamadas módulos de objetivos (target modules).
Existen varios módulos extendidos de objetivos, la mayoría de los cuales tan sólo se aplican a
tablas o situaciones específicas. Un par de estos módulos, de los más populares e incluidos por
defecto en Linux son:
LOG — Registra todos los paquetes que coinciden esta regla. Puesto que los paquetes son
registrados por el kernel, el archivo /etc/syslog.conf determina dónde estas entradas de
registro serán escritas. Por defecto, son colocadas en el archivo /var/log/messages.
Se pueden usar varias opciones adicionales tras el objetivo LOG para especificar la manera
en la que tendrá lugar el registro:
--log-level — Configura el nivel de prioridad del registro de eventos. Una lista de los niveles
de prioridad se puede encontrar en la página del manual de syslog.conf.
--log-ip-options Cualquier opción en la cabecera de un paquete IP se guarda en el registro.
--log-prefix — Coloca una cadena de hasta 29 caracteres antes de la línea de registro cuando
es escrita. Esto es muy útil para la escritura de filtros de syslog para usarlos en conjunto con
el registro de paquetes.
--log-tcp-options — Cualquier opción colocada en la cabecera de un paquete TCP es
registrada.
--log-tcp-sequence Escribe el número de secuencia TCP del paquete en el registro del
sistema.
Recuerde que la administración de Logs es vital en este tipo de administración, por esta razón se
encuentra el archivo logrotate, que sirve para hacer una rotación de logs, el arhivo de
configuración se encuentra en /etc/logrotate.conf .
pág. 228
Los logs o ficheros de registro están pensados para guardar la información de las actividades del
sistema. Estos ficheros pueden crecer hasta llenar la partición donde se encuentran y bloquear el
sistema, pero tienen muchísimos usos y son algo imprescindible, ya que con la experiencia nos
aportan una inmensa cantidad de información.
Opciones de listado
El comando predeterminado para listar, iptables -L, proporciona una vista muy básica de los filtros
por defecto de las cadenas actuales de la tabla. Las opciones adicionales proporcionan más
información:
-v — Muestra la salida por pantalla con detalles, como el número de paquetes y bytes que
cada cadena ha visto, el número de paquetes y bytes que cada regla ha encontrado y qué
interfaces se aplican a una regla en particular.
-x Expande los números en sus valores exactos. En un sistema ocupado, el número de
paquetes y bytes vistos por una cadena en concreto o por una regla puede estar abreviado
usando K (miles), M (millones), y G (billones) detrás del número. Esta opción fuerza a que se
muestre el número completo.
-n Muestra las direcciones IP y los números de puertos en formato numérico, en lugar de
utilizar el nombre del servidor y la red tal y como se hace por defecto.
--line-numbers — Proporciona una lista de cada cadena junto con su orden numérico en la
cadena. Esta opción puede ser útil cuando esté intentando borrar una regla específica en
una cadena o localizar dónde insertar una regla en una cadena.
-t — Especifica un nombre de tabla.
Guardar reglas iptables
Las reglas creadas con el comando iptables son almacenadas en memoria. Si el sistema es
reiniciado antes de guardar el conjunto de reglas iptables, se perderán todas las reglas. Para que
las reglas de filtrado de red persistan luego de un reinicio del sistema, estas necesitan ser
guardadas. Para hacerlo, conéctese como root y escriba:
#/sbin/service iptables save
Esto ejecuta el script de inicio iptables, el cual ejecuta el programa /sbin/iptables-save y escribe
la configuración actual de iptables a /etc/sysconfig/iptables. El a rchivo /etc/sysconfig/iptables
existente es guardado como /etc/sysconfig/iptables.save.
pág. 229
La próxima vez que se inicie el sistema, el script de inicio de iptables volverá a aplicar las reglas
guardadas en /etc/sysconfig/iptables usando el comando /sbin/iptables-restore.
Aun cuando siempre es una buena idea probar una regla de iptables antes de confirmar los
cambios al archivo /etc/sysconfig/iptables, es posible copiar reglas iptables en este archivo
desde otra versión del sistema de este archivo. Esto proporciona una forma rápida de distribuir
conjuntos de reglas iptables a muchas máquinas.
Scripts de control de iptables
Hay dos métodos básicos para controlar iptables:
Herramienta de configuración de nivel de seguridad (system-config-securitylevel) — Una
interfaz gráfica para crear, activar y guardar reglas básicas de cortafuegos.
/sbin/service iptables <opcion> — Un comando ejecutado por el usuario root capaz de
activar, desactivar y llevar a cabo otras funciones de iptables a través de su script de inicio.
Reemplace <opcion> en el comando con alguna de las directivas siguientes:
start — Si se tiene un cortafuegos o firewall (es decir, /etc/sysconfig/iptables existe), todos
los iptables en ejecución son detenidos completamente y luego arrancados usando el
comando /sbin/iptables-restore. La directriz start sólo funcionará si no se carga el módulo
del kernel ipchains.
stop — Si el cortafuegos está en ejecución, se descartan las reglas del cortafuegos que se
encuentran en memoria y todos los módulos iptables y ayudantes son descargados.
Si se cambia la directiva IPTABLES_SAVE_ON_STOP dentro del archivo de
configuración /etc/sysconfig/iptables-config de su valor por defecto a yes, se guardan las
reglas actuales a /etc/sysconfig/iptables y cualquier regla existente se moverá al
archivo /etc/sysconfig/iptables.save.
restart — Si el cortafuegos está en ejecución, las reglas del mismo que se encuentran en
memoria se descartan y se vuelva a iniciar el cortafuegos si está configurado
en/etc/sysconfig/iptables. La directriz restart sólo funcionará si no está cargado el módulo
del kernel ipchains.
Si
la
directiva IPTABLES_SAVE_ON_RESTART dentro
del
archivo
de
configuración /etc/sysconfig/iptables-config se cambia de su valor por defecto a yes, las
reglas actuales son guardadas a /etc/sysconfig/iptables y cualquier regla existente se
moverán al archivo /etc/sysconfig/iptables.save.
pág. 230
status — Imprime el estado del cortafuegos una lista de todas las reglas activas al indicador
de comandos. Si no se cargan o configuran reglas del cortafuegos, también indica este
hecho.
Una lista de las reglas activas, conteniendo direcciones IP dentro de listas de reglas a menos
que el valor por defecto para IPTABLES_STATUS_NUMERIC sea cambiado ano dentro del
archivo de configuración /etc/sysconfig/iptables-config.
panic — Descarta todas las reglas del cortafuegos. La política de todas las tablas
configuradas está establecida a DROP.
save — Guarda las reglas del cortafuegos a /etc/sysconfig/iptables usando iptables-save.
Archivo de configuración de scripts de control de iptables
El comportamiento de los scripts de inicio de iptables es controlado por el archivo de
configuración /etc/sysconfig/iptables-config. A continuación se presenta una lista de las
directivas contenidas dentro de este archivo:
IPTABLES_MODULES —
Especifica
una
lista
separada
por
espacios
de
módulos iptables adicionales a cargar cuando se activa un cortafuegos. Esto puede incluir
seguimiento de conexiones y ayudantes NAT.
IPTABLES_MODULES_UNLOAD — Limpia los módulos al iniciar o detenerse. Esta directiva
acepta los valores siguientes:
yes — El valor por defecto. Esta regla se debe configurar para que alcance un estado correcto
para el inicio o parada del cortafuegos.
no — Esta opción solamente debería ser configurada si hay problemas para limpiar los
módulos de filtrado de paquetes de red.
IPTABLES_SAVE_ON_STOP —
Guarda
las
reglas
del
cortafuegos
actuales
a /etc/sysconfig/iptables cuando se detiene el cortafuegos. Esta directiva acepta los valores
siguientes:
yes — Guarda las reglas existentes a /etc/sysconfig/iptables cuande se detiene el
cortafuegos, moviendo la versión anterior al archivo/etc/sysconfig/iptables.save.
no — El valor por defecto. No guarda las reglas existentes cuando se detiene el cortafuegos.
IPTABLES_SAVE_ON_RESTART — Guarda las reglas actuales del cortafuegos cuando este se
reinicia. Esta directiva acepta los valores siguientes:
pág. 231
yes — Guarda las reglas existentes a /etc/sysconfig/iptables cuando se reinicia el
cortafuegos, moviendo la versión anterior al archivo/etc/sysconfig/iptables.save.
no — El valor por defecto. No guarda las reglas existentes cuando se reinicia el cortafuegos.
IPTABLES_SAVE_COUNTER — Guarda y restaura todos los paquetes y contadores de bytes
en todas las cadenas y reglas. Esta directiva acepta los valores siguientes:
yes — Guarda los valores del contador.
no — El valor por defecto. No guarda los valores del contador.
IPTABLES_STATUS_NUMERIC — Muestra direcciones IP en una salida de estado en vez de
dominios y nombres de host. Esta directiva acepta los valores siguientes:
yes — El valor por defecto. Solamente devuelve direcciones IP dentro de una salida de
estado.
no — Devuelve dominios o nombres de host en la salida de estado.
Protocolo SSH
SSH™ (o Secure SHell) es un protocolo que facilita las comunicaciones seguras entre dos sistemas
usando una arquitectura cliente/servidor y que permite a los usuarios conectarse a un host
remotamente. A diferencia de otros protocolos de comunicación remota tales como FTP o Telnet,
SSH encripta la sesión de conexión, haciendo imposible que alguien pueda obtener contraseñas
no encriptadas.
SSH está diseñado para reemplazar los métodos más viejos y menos seguros para registrarse
remotamente en otro sistema a través de la shell de comando, tales como telnet o rsh. Un
programa relacionado, el scp, reemplaza otros programas diseñados para copiar archivos entre
hosts como rcp. Ya que estas aplicaciones antiguas no encriptan contraseñas entre el cliente y el
servidor, evite usarlas mientras le sea posible. El uso de métodos seguros para registrarse
remotamente a otros sistemas reduce los riesgos de seguridad tanto para el sistema cliente como
para el sistema remoto.
Seguridad e acceso a Linux
SSH trabaja de forma similar a como se hace con telnet. La diferencia principal es que SSH usa
técnicas de cifrado que hacen que la información que viaja por el medio de comunicación vaya de
manera no legible, evitando que terceras personas puedan descubrir el usuario y contraseña de
la conexión ni lo que se escribe durante toda la sesión; aunque es posible atacar este tipo de
sistemas por medio de ataques de REPLAY y manipular así la información entre destinos.
pág. 232
Historia del SSH
Al principio sólo existían los r-commands, que eran los basados en el programa rlogin, el cual
funciona de una forma similar a telnet.
La primera versión del protocolo y el programa eran libres y los creó un finlandés llamado Tatu
Ylönen, pero su licencia fue cambiando y terminó apareciendo la compañía SSH Communications
Security, que lo ofrecía gratuitamente para uso doméstico y académico, pero exigía el pago a otras
empresas. En el año 1997 (dos años después de que se creara la primera versión) se propuso
como borrador en la IETF.
A principios de 1999 se empezó a escribir una versión que se convertiría en la implementación
libre por excelencia, la de OpenBSD, llamada OpenSSH.
Versiones de SSH
Existen 2 versiones de SSH, la versión 1 de SSH hace uso de muchos algoritmos de cifrado
patentados (sin embargo, algunas de estas patentes han expirado) y es vulnerable a un agujero
de seguridad que potencialmente permite a un intruso insertar datos en la corriente de
comunicación. La suite OpenSSH bajo Red Hat Enterprise Linux utiliza por defecto la versión 2 de
SSH, la cual tiene un algoritmo de intercambio de claves mejorado que no es vulnerable al agujero
de seguridad en la versión 1. Sin embargo, la suite OpenSSH también soporta las conexiones de la
versión 1.
Características de SSH
El protocolo SSH proporciona los siguientes tipos de protección:
Después de la conexión inicial, el cliente puede verificar que se está conectando al mismo
servidor al que se conectó anteriormente.
El cliente transmite su información de autenticación al servidor usando una encriptación
robusta de 128 bits.
Todos los datos enviados y recibidos durante la sesión se transfieren por medio de
encriptación de 128 bits, lo cual los hacen extremamente difícil de descifrar y leer.
El cliente tiene la posibilidad de reenviar aplicaciones X11 desde el servidor. Esta técnica,
llamada reenvío por X11, proporciona un medio seguro para usar aplicaciones gráficas sobre
una red.
Ya que el protocolo SSH encripta todo lo que envía y recibe, se puede usar para asegurar
protocolos inseguros. El servidor SSH puede convertirse en un conducto para convertir en seguros
los protocolos inseguros mediante el uso de una técnica llamada reenvío por puerto, como por
pág. 233
ejemplo POP, incrementando la seguridad del sistema en general y de los datos.
Red Hat Enterprise Linux contiene el paquete general de OpenSSH (openssh) así como también
los paquetes del servidor OpenSSH (openssh-server) y del cliente (openssh-clients). Observe que
los paquetes OpenSSH requieren el paquete OpenSSL (openssl). OpenSSL instala varias bibliotecas
criptográficas importantes, permitiendo que OpenSSH pueda proporcionar comunicaciones
encriptadas.
Instalacion y Configuracion:
Lo primero es instalar el servicio de ssh, esto lo realizaremos con el siguiente comando:
# yum –y install openssh-server openssh-client
Terminara una vez que nos mande la pantalla con el mensaje de instalación complete
Una vez realizado esto realizaremos una conexión de prueba, para esto necesitaremos descargar
un cliente de ssh de Windows, para lo cual nos dirigiremos a google y descargaremos la aplicación
llamada putty
pág. 234
Una vez descargado lo ejecutaremos:
Pondremos la ip de nuestro servidor:
pág. 235
Le daremos en open y cuando la conexión sea por primera vez nos mandara una alerta de
seguridad, y le daremos que “Si”
Validaremos con un usuario y un password valido, dentro del server:
pág. 236
Una vez realizado esto, estaremos en la consola como si estuviéramos en la terminal física,
pudiendo realizar cualquier tarea desde el cliente.
Con exit podremos cerrar la sesión cuando ya no sea necesaria.
¿Por qué usar SSH?
Los usuario nefarios tienen a su disposición una variedad de herramientas que les permiten
interceptar y redirigir el tráfico de la red para ganar acceso al sistema. En términos generales,
estas amenazas se pueden catalogar del siguiente modo:
Intercepción de la comunicación entre dos sistemas — En este escenario, existe un tercero
en algún lugar de la red entre entidades en comunicación que hace una copia de la
información que pasa entre ellas. La parte interceptora puede interceptar y conservar la
información, o puede modificar la información y luego enviarla al recipiente al cual estaba
destinada.
Este ataque se puede montar a través del uso de un paquete sniffer — una utilidad de red
muy común.
pág. 237
Personificación de un determinado host — Con esta estrategia, un sistema interceptor finge
ser el recipiente a quien está destinado un mensaje. Si funciona la estrategia, el sistema del
usuario no se da cuenta del engaño y continúa la comunicación con el host incorrecto.
Esto se produce con técnicas como el envenenamiento del DNS o spoofing de IP (engaño
de direcciones IP).
Ambas técnicas interceptan información potencialmente confidencial y si esta intercepción se
realiza con propósitos hostiles, el resultado puede ser catastrófico.
Si se utiliza SSH para inicios de sesión de shell remota y para copiar archivos, se pueden disminuir
estas amenazas a la seguridad notablemente. Esto es porque el cliente SSH y el servidor usan
firmas digitales para verificar su identidad. Adicionalmente, toda la comunicación entre los
sistemas cliente y servidor es encriptada. No servirán de nada los intentos de falsificar la identidad
de cualquiera de los dos lados de la comunicación ya que cada paquete está cifrado por medio de
una llave conocida sólo por el sistema local y el remoto.
Secuencia de eventos de una conexión SSH
La siguiente serie de eventos lo ayudan a proteger la integridad de la comunicación SSH entre dos
host.
Se lleva a cabo un 'handshake' (apretón de manos) encriptado para que el cliente pueda
verificar que se está comunicando con el servidor correcto.
La capa de transporte de la conexión entre el cliente y la máquina remota es encriptada
mediante un código simétrico.
El cliente se autentica ante el servidor.
El cliente remoto interactúa con la máquina remota sobre la conexión encriptada.
SSH-Agent permite recordar mientras dure la sesión, cada una de las claves privadas del usuario,
de modo que él se encargue de realizar la autenticación.
En cualquier ambiente informático, donde se requiera trabajar con múltiples servidores, es
necesario contar con una comunicación segura como SSH. Para conectarse a un servidor remoto,
basta con teclear el comando seguido del usuario y host destino, y de la contraseña del usuario
remoto en cuestión. Este proceso de login en máquinas remotas puede ser molesto en los casos
en que sea necesario realizar conexiones cada poco período de tiempo, debido a que hay que
ingresar la contraseña cada vez.
De igual manera, cuando se desean utilizar discos remotos, puede ser beneficioso (sobre todo
pág. 238
para los usuarios) que dichos discos sean montados automáticamente al momento de login, y que
puedan ser utilizados transparentemente por los usuarios. Con este fin fue creado el ssh-agent.
Capa de transporte
El papel principal de la capa de transporte es facilitar una comunicación segura entre los dos hosts
durante la autenticación yla subsecuente comunicación. La capa de transporte lleva esto a cabo
manejando la encriptación y decodificación de datos y proporcionando protección de integridad
de los paquetes de datos mientras son enviados y recibidos. Además, la capa de transporte
proporciona compresión de datos, lo que acelera la transmisión de información.
Al contactar un cliente a un servidor por medio del protocolo SSH, se negocian varios puntos
importantes para que ambos sistemas puedan construir la capa de transporte correctamente.
Durante el intercambio se producen los siguientes pasos:
Intercambio de claves
Se determina el algoritmo de encriptación de la clave pública
Se determina el algoritmo de la encriptación simétrica
Se determina el algoritmo autenticación de mensajes
Se determina el algoritmo de hash que hay que usar
Durante la primera fase, el cliente y el servidor negocian qué algoritmos criptográficos se van a
usar. Las implementaciones actuales proporcionan las siguientes opciones:
Para criptografía de clave pública: RSA, Diffie-Hellman, DSA (Digital Signature Algorithm)
o Fortezza.
Para cifrado simétrico: RC2, RC4, IDEA (International Data Encryption Algorithm), DES (Data
Encryption Standard), Triple DES y AES (Advanced Encryption Standard).
Para este cifrado se utiliza la misma llave para encriptar y para desencriptar.
Con funciones hash: MD5 o de la familia SHA.
pág. 239
El servidor se identifica ante el cliente con una llave de host única durante el intercambio de
llaves. Obviamente si este cliente nunca se había comunicado antes con este determinado
servidor, la llave del servidor le resultará desconocida al cliente y no lo conectará. OpenSSH evita
este problema permitiendo que el cliente acepte la llave del host del servidor después que el
usuario es notificado y verifica la aceptación de la nueva llave del host. Para las conexiones
posteriores, la llave del host del servidor se puede verificar con la versión guardada en el cliente,
proporcionando la confianza de que el cliente se está realmente comunicando con el servidor
deseado. Si en el futuro, la llave del host ya no coincide, el usuario debe eliminar la versión
guardada antes de que una conexión pueda ocurrir.
SSH fue ideado para funcionar con casi cualquier tipo de algoritmo de clave pública o formato de
codificación. Después del intercambio de claves inicial se crea un valor hash usado para el
intercambio y un valor compartido secreto, los dos sistemas empiezan inmediatamente a calcular
claves y algoritmos nuevos para proteger la autenticación y los datos que se enviarán a través de
la conexión en el futuro.
Después que una cierta cantidad de datos haya sido transmitida con un determinado algoritmo y
clave (la cantidad exacta depende de la implementación de SSH), ocurre otro intercambio de
claves, el cual genera otro conjunto de valores de hash y un nuevo valor secreto compartido. De
esta manera aunque un agresor lograse determinar los valores de hash y de secreto compartido,
esta información sólo será válida por un período de tiempo limitado.
Autenticación en SSH
Cuando la capa de transporte haya construido un túnel seguro para transmitir información entre
los dos sistemas, el servidor le dirá al cliente de los diferentes métodos de autenticación
soportados, tales como el uso de firmas privadas codificadas con claves o la inserción de una
contraseña. El cliente entonces intentará autenticarse ante el servidor mediante el uso de
cualquiera de los métodos soportados.
Los servidores y clientes SSH se pueden configurar para que permitan varios tipos de
autenticación, lo cual le concede a cada lado la cantidad óptima de control. Luego el servidor
podrá decidir qué métodos de encriptación soportará basado en su pauta de seguridad, y el
cliente puede elegir el orden en que intentará utilizar los métodos de autenticación entre las
opciones a disposición. Gracias a la naturaleza segura de la capa de transporte de SSH, hasta
pág. 240
métodos de autenticación que parecen inseguros, como la autenticación basada en contraseñas,
son en realidad seguros para usar.
Cuando se conecta a un servidor ssh con su cliente ssh , se compara la clave pública del servidor
a las claves almacenadas en un archivo en el equipo cliente , esta conexión se logra mediante el
archivo known_hosts.
Canales en SSH
Luego de una autenticación exitosa sobre la capa de transporte SSH, se abren múltiples canales a
través de la técnica llamada multiplexar. Cada uno de estos canales manejan la conexión para
diferentes sesiones de terminal y para sesiones de reenvió X11.
Ambos clientes y servidores pueden crear un canal nuevo. Luego se le asigna un número diferente
a cada canal en cada punta de la conexión. Cuando el cliente intenta abrir un nuevo canal, los
clientes envían el número del canal junto con la petición. Esta información es almacenada por el
servidor y usada para dirigir la comunicación a ese canal. Esto es hecho para que diferentes tipos
de sesión no afecten una a la otra y así cuando una sesión termine, su canal pueda ser cerrado sin
interrumpir la conexión SSH primaria.
Los canales también soportan el control de flujo, el cual les permite enviar y recibir datos
ordenadamente. De esta manera, los datos no se envían a través del canal sino hasta que el host
haya recibido un mensaje avisando que el canal está abierto y puede recibirlos.
El cliente y el servidor negocian las características de cada canal automáticamente, dependiendo
del tipo de servicio que el cliente solicita y la forma en que el usuario está conectado a la red. Esto
otorga una gran flexibilidad en el manejo de diferentes tipos de conexiones remotas sin tener que
cambiar la infraestructura básica del protocolo.
Servidores FTP
Red Hat Enterprise Linux se entrega con dos servidores FTP diferentes:
Acelerador de Contenidos Red Hat — Un servidor Web basado en el kernel que ofrece un
servidor web y servicios FTP de alto rendimiento. Puesto que la velocidad es su objetivo
principal de diseño, su funcionalidad es limitada y solamente se ejecuta como FTP anónimo.
vsftpd — un demonio FTP rápido y seguro, preferido para Red Hat Enterprise Linux. El resto
de este capítulo se enfoca en vsftpd.
pág. 241
Vsftpd
El demonio FTP vsftpd (o Very Secure FTP Daemon) está diseñado desde la base para ser rápido,
estable y lo más importante, seguro. Su habilidad para manejar grandes números de conexiones
de forma eficiente y segura es lo que hace que vsftpd sea el único FTP independiente distribuido
con Red Hat Enterprise Linux.
El modelo de seguridad utilizado por vsftpd tiene tres aspectos principales:
Clara separación de procesos privilegiados y sin privilegios — Procesos separados manejan
tareas diferentes y cada uno de estos procesos se ejecuta con los privilegios mínimos
requeridos para la tarea.
Las tareas que requieren altos privilegios son manejadas por procesos con los mínimos
privilegios necesarios — Influenciando las compatibilidades encontradas en la biblioteca
libcap, las tareas que usualmente requieren privilegios de súper usuario se pueden ejecutar
de forma más segura desde un proceso menos privilegiado.
La mayoría de los procesos se ejecutan enjaulados en un ambiente chroot — Siempre que
sea posible, se cambia la raíz de los procesos al directorio compartido; este directorio se
considera luego como la jaula chroot. Por ejemplo, si el directorio /var/ftp/ es el directorio
compartido principal, vsftpd reasigna /var/ftp/ al nuevo directorio raíz, conocido como /.
Esto previene actividades maliciosas de cualquier hacker potencial en algún directorio que
no estén por debajo del nuevo directorio root.
El uso de estas prácticas de seguridad tiene el efecto siguiente en cómo vsftpd trata con las
peticiones:
El proceso padre se ejecuta con el mínimo de privilegios requerido — El proceso padre
calcula dinámicamente el nivel de privilegios requerido para minimizar el nivel de riesgos.
Los procesos hijo manejan la interacción directa con los clientes FTP y se ejecutan casi sin
ningún privilegio.
Todas las operaciones que requieren altos privilegios son manejadas por un pequeño
proceso padre — Similar a Servidor Apache HTTP, vsftpd lanza procesos hijos sin privilegios
para manejar las conexiones entrantes. Esto permite al proceso padre privilegiado, ser tan
pequeño como sea posible y manejar relativamente pocas tareas.
El proceso padre no confía en ninguna de las peticiones desde procesos hijos sin
privilegios — Las comunicaciones con procesos hijos se reciben sobre un socket y la validez
de cualquier información desde un proceso hijo es verificada antes de proceder.
pág. 242
La mayor parte de la interacción con clientes FTP la manejan procesos hijo sin privilegios en
una jaula chroot. — Debido a que estos procesos hijo no tienen privilegios y solamente
tienen acceso al directorio que está siendo compartido, cualquier proceso fallido solamente
permitirá al atacante acceder a los archivos compartidos.
Archivos instalados con vsftpd
El RPM vsftpd instala el demonio (/usr/sbin/vsftpd), su archivo de configuración y otros archivos
relacionados, así como también directorios FTP en el sistema. La siguiente es una lista de los
archivos y directorios considerados más a menudo cuando se configura vsftpd:
/etc/rc.d/init.d/vsftpd — El script de inicialización (initscript) utilizado por el
comando /sbin/service para iniciar, detener o volver a cargar vsftpd.
/etc/pam.d/vsftpd — El archivo de configuración de los Pluggable Authentication Modules
(PAM) para vsftpd. Este archivo define los requerimientos que debe cumplir un usuario para
conectarse a un servidor FTP.
/etc/vsftpd/vsftpd.conf — El archivo de configuración para vsftpd.
/etc/vsftpd.ftpusers — Una lista de los usuarios que no tienen permitido conectarse
a vsftpd. Por defecto esta lista incluye a los usuarios root, bin y daemon, entre otros.
/etc/vsftpd.user_list — Este archivo se puede configurar para negar o permitir el acceso a
los usuarios listados, dependiendo de si la directriz userlist_deny está configurada a YES (por
defecto) o a NO en /etc/vsftpd/vsftpd.conf. Si se utiliza /etc/vsftpd.user_list para permitir
acceso a los usuarios, los nombres de usuarios listados no deben aparecer
en /etc/vsftpd.ftpusers.
El directorio /var/ftp/ — El directorio que contiene los archivos servidos por vsftpd. También
contiene el directorio /var/ftp/pub/ para los usuarios anónimos. Ambos directorios están
disponibles para la lectura de todos, pero sólo el superusuario o root puede escribir en el.
pág. 243
Iniciar y detener vsftpd
El RPM vsftpd instala el script /etc/rc.d/init.d/vsftpd, al cual se puede acceder usando el
comando /sbin/service.
Para iniciar el servidor, escriba como usuario root, lo siguiente:
# /sbin/service vsftpd start
Para detener el servidor, como root escriba:
# /sbin/service vsftpd stop
La opción restart es un atajo para detener y volver a iniciar vsftpd. Esta es la forma más efectiva
para que los cambios de configuración tomen efecto luego de modificar el archivo de
configuración para vsftpd.
Para reiniciar el servidor, escriba como root:
# /sbin/service vsftpd restart
La opción condrestart (reinicio condicional) solamente arranca vsftpd si está ejecutándose en ese
momento. Esta opción es muy útil para scripts, puesto que no arranca el demonio si este no se
está ejecutando.
Para reiniciar el servidor de forma condicional, escriba como usuario root:
# /sbin/service vsftpd condrestart
Por defecto, el servicio vsftpd no se inicia automáticamente al momento del arranque. Para
configurar el servicio vsftpd para que se inicie al momento del arranque, utilice una utilidad
initscript, tal como /sbin/chkconfig, /sbin/ntsysv o el programa Herramienta de configuración de
servicios.
pág. 244
Intalacion y Configuracion de FTP.
Para comenzar primero instalaremos el servicio de ftp con el siguiente comando:
# yum –y install vsftpd ftp
La instalación estará completa cuando nos mande el mensaje de complete
Posterior a esto, nos dirigimos al archivo de configuración de ftp que está en la ruta
# vi /etc/vsftpd/vsftpd.conf
Verificaremos en el archivo que este activa la regla de permitir usuarios anónimos
anonymous_enable=YES
Para activarlo solo le quitamos el símbolo “#” para activarlo
Y la regla de enjaulamiento de usuarios locales:
chroot_local_user=YES
De igual manera lo activamos de ser necesario
Después, la regla de habilitar usuarios locales:
Local_enable=YES
Y por último la regla de escritura en server usando FTP:
write_enable=YES
Y guardamos los cambios.
pág. 245
Despues reiniciamos el servidor de Ftp:
# service vsftpd restart
Ahora nos cambiamos a la carpeta de ftp que da por defecto para los usuarios anónimos
# cd /var/ftp
Y Creamos una carpeta
# mkdir /var/ftp/ejemplo
Si se tiene un firewall instalado se deshabilita
# system-config-firewall
Ahora deshabilitamos SELINUX, para que los clientes puedan utilizar el servicio
# vi /etc/sysconfig/selinux
Reiniciamos el servicio de FTP
# service vsftpd restart
pág. 246
Una vez realizado esto modificaremos el archivo de host para indicar la dirección de nuestro
servidor ftp
# vi /etc/hosts
Ejecutaremos el siguiente comando para iniciar el servicio en todos los niveles
# chkconfig vsftpd on
Una vez realizado esto agregaremos la ip a las tablas para establecer los puertos de conexión con
los siguientes comandos:
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 20 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 21 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 30300:30309 -j ACCEPT
Guadamos los cambios en las tablas:
# service iptables save
Reiniciamos el servicio:
#service iptables restart
Otro paso importante es verificar que la carpeta local no está lista para ser validad por ftp:
Esto lo revisaremos con el siguiente comando
# getsebool –a | grep ftp
Esto nos desplegara una lista en la cual podremos ver que la opción ftp_home_dir estará en off,
pág. 247
esto quiere decir que cualquier usuario anónimo o asignado no podrá navegar en la carpeta para
ftp, por tal la activaremos con el siguiente comando:
# setsebool –P ftp_home_dir on
Esto podrá tardar algunos minutos, una vez realizado esto podremos verificar con el comando
anterior y nos deberá mostrar algo parecido a esto:
Ahora realizamos una prueba de conexión por FTP:
Este lo realizaremos utilizando un usuario anónimo por ejemplo:
USR: ftp
Passwd: ftp
Esto lo realizaremos desde el mismo servidor con el comando siguiente:
# ftp dirección del server
Nos deberá pedir el usuario y el password y colocaremos los antes mencionados:
pág. 248
Y después tendremos acceso a este:
Y si listamos el contenido podremos ver la carpeta antes creada, lo que indica que estamos dentro
del server:
pág. 249
Otra manera de verificar que hemos conseguido el acceso es hacerlo desde el navegador de
nuestro equipo de la siguiente forma:
Abriremos el navegador de internet de nuestro equipo y pondremos en la url la dirección de la
siguiente forma:
ftp://direccion del server
Y al presionar enter podremos ver el contenido antes mencionado
pág. 250
Ahora que ya hemos logrado la conexión con un usuario anónimos, realizaremos la configuración
para realizar una conexión más segura con un usuario asignado y que pida autenticación, para
esto procedemos a realizar lo siguiente:
Nos cambiamos a la carpeta de configuración de ftp y ahí crearemos un usuario
# cd /etc/vsftpd
Agregamos el usuario con el siguiente comando
# adduser adminftp
Y le asignamos una contraseña
# passwd adminftp
Después podremos realizar una prueba con autenticación de la misma manera que el el caso
anterior por línea de comando
pág. 251
Ponemos el password asignado
Y si listamos veremos que está vacía a diferencia de la prueba anterior
pág. 252
Para verificar la conexión por ftp con autenticación podremos realizarlo de manera gráfica
también de la siguiente forma:
En la Url ahora podremos validarnos pero de la siguiente manera
ftp://adminftp@direccion del servidor
Lo cual nos mandara una interface de la siguiente manera:
Validaremos con los datos que tenemos
pág. 253
Lo cual nos dará acceso y veremos que esta vacío pues en esta no tenemos archivo alguno.
De esta manera ya podríamos utilizar clientes ftp para poder subir o descargar archivos al
servidor, como FileZilla y muchos otros que están en el mercado.
Para subir o descargar archivos del servidor podríamos realizar una conexión desde el explorador
de Windows:
pág. 254
pág. 255
Y de esta forma esta implementado un servidor FTP.
Puertos múltiples, modos múltiples
A diferencia de la mayoría de los protocolos utilizados en Internet, FTP requiere de múltiples
puertos de red para funcionar correctamente. Cuando una aplicación cliente FTP inicia una
conexión a un servidor FTP, abre el puerto 21 en el servidor — conocido como el puerto de
comandos. Se utiliza este puerto para arrojar todos los comandos al servidor. Cualquier petición
de datos desde el servidor se devuelve al cliente a través del puerto de datos. El número de puerto
para las conexiones de datos y la forma en la que las conexiones son inicializadas varía
dependiendo de si el cliente solicita los datos en modo activo o en modo pasivo.
A continuación se describen estos modos:
Modo activo
El modo activo es el método original utilizado por el protocolo FTP para la transferencia de datos
a la aplicación cliente. Cuando el cliente FTP inicia una transferencia de datos, el servidor abre
una conexión desde el puerto 20 en el servidor para la dirección IP y un puerto aleatorio sin
privilegios (mayor que 1024) especificado por el cliente. Este arreglo implica que la máquina
cliente debe poder aceptar conexiones en cualquier puerto superior al 1024. Con el crecimiento
de las redes inseguras, tales como Internet, es muy común el uso de cortafuegos para proteger
pág. 256
las máquinas cliente. Debido a que estos cortafuegos en el lado del cliente normalmente rechazan
las conexiones entrantes desde servidores FTP en modo activo, se creó el modo pasivo.
Modo pasivo
La aplicación FTP cliente es la que inicia el modo pasivo, de la misma forma que el modo activo.
El cliente FTP indica que desea acceder a los datos en modo pasivo y el servidor proporciona la
dirección IP y el puerto aleatorio, sin privilegios (mayor que 1024) en el servidor. Luego, el cliente
se conecta al puerto en el servidor y descarga la información requerida.
Mientras que el modo pasivo resuelve el problema de la interferencia del cortafuegos en el lado
del cliente con las conexiones de datos, también puede complicar la administración del
cortafuegos del lado del servidor. Una de las formas de limitar el número de puertos abiertos en
el servidor y de simplificar la tarea de crear reglas para el cortafuegos del lado del servidor, es
limitando el rango de puertos sin privilegios ofrecidos para las conexiones pasivas.
pág. 257
CONCLUSIONES
Hoy en día los sistemas operativo sean hecho parte importante en nuestra vida como también
hay una gran diversidad de sistemas operativos hoy en día como Windows, Apple, y Linux es un
sistema operativo muy popular es propiamente el núcleo de un sistema operativo es decir el
conjunto de programas que controla los aspectos más básicos del funcionamiento pero Linux
tiene una amplia distribución de sistemas operativos como centOS, Fedora, Debian, Mandriva
entre otros más, pero sin el sistema operativo de la computadora solo sería un más que un
montón de metal pero con el sistema operativo él tiene una responsabilidad se asegura de que
los programas y usuarios que estén funcionando al mismo tiempo no interfieran entre ellos
tambien conocimos su historia como fue que surgió quien es mejor sistema operativo Linux y sus
distribuciones como es la estructura de Linux con ella permitir al software conocer la ubicación
de directorios y archivos instalados pero con lo comandos la terminal es la interfaz gráfica que
permite que el usuario se comunique con el kernel de Linux se pude entrar de modo gráfico hay
se puede ver los directorios crear cambiar archivos siendo el superusuario (root ) o un usuario
normal o tambien crear nuevos usuarios o instalar software que es necesario utiliza repositorios
tambien para intalar se puede utilizar el comando yum
pág. 258
CIBERGRAFIA
http://www.authorstream.com/Presentation/alandramirez-1854509-centos/
http://www.centosni.net/comandos-basicos-en-gnulinux-centos/
http://www.fing.edu.uy/inco/cursos/sistoper/recursosLaboratorio/tutorial0.pdf
http://www.debian.org/
http://asorufps.wikispaces.com/CENTOS
http://www.debian.org/doc/manuals/project-history/ch-intro.es.html
http://www.debian.org/doc/manuals/project-history/ch-detailed.es.html
pág. 259

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Download linux administrator - Skanda Tecnology Advisors