En nuestra mente nunca estuvo presente que Linvix se convirtiera en una revista de alcance mundial, la idea comenzó como una forma de hacer llegar a las personas que visitan nuestro Joven Club conocimientos sobre software libre.

Los dos números anteriores han tenido un impacto positivo en las personas que nos visitan a diario, así como en toda la comunidad internacional, pues hemos recibido muchos correo felicitándonos, dando sugerencias, criterios etc… sobre la anterior publicación.

Linvix pretende salir con una frecuencia bimensual, tratando de llevar siempre artículos que faciliten el uso del software libre y así eliminar ese mito de que linux es difícil.

En este número hemos comenzado con nuevas secciones, “Servidores”, “La Distro”, “El Escritorio” y otras más para compartir con ustedes, traemos también un interesante artículo sobre Italc para aquellos que tienen la hermosa tarea de enseñar a través de la computadora, así como dos artículos de servidores. En la sección “La Distro” hablaremos sobre como darle uso a las viejas computadoras obteniendo resultados asombrosos, en fin, este número viene bien cargado de cosas interesantes, solo les deseamos que disfruten la revista y una ves más los invitamos a que la hagan suya, recuerden que estamos abiertos a nuevos colaboradores, solo deben enviar un correo a linvix@gmail.com

El equipo de Linvix.

NOTA: Por problemas de conexión no hemos podido publicar el número en el Blog, de momento está disponible la descarga desde:

1. Mirror Cuba

2. Mirror WordPress

Hola, despues de tanto navegar, por fin encontre la receta, aqui les va:

1. Necesitamos instalar los siguientes paquetes:

sudo apt-get install libnss-ldap libpam-ldap nscd

Nos saldrá una ventana de configuración, dende:

* Establecemos el servidor LDAP. aquí ponemos la dirección ip del server que corre el servicio LDAP de la forma:

ldap://192.168.0.1 y presionamos Enter

* Posteriormente entramos el (Distinguished name of the search base), en mi caso dc=vn,dc=pri,dc=jovenclub,dc=cu
* Establecemos la versión de LDAP, (3).
* En la opción (Make local root Database admin) le decimos NO
* En la opción (Does the LDAP database require login?) le decimos NO

2. Ahora necesitamos configurar los pam.d

* Editamos el fichero /etc/pam.d/common-account y nos aseguramos de que tenga la siguiente configuración:

account required pam_unix.so
account sufficient pam_ldap.so

NOTA: En mi experiencia, el orden de las opciones creo es importante. En caso de exitir alguna de las opciones que debemos adicionar, las comentamos y las ordenamos segun aparece en este tutorial.

* Editamos el fichero /etc/pam.d/common-auth y nos aseguramos de que quede de la siguiente forma:

auth sufficient pam_unix.so
auth sufficient pam_ldap.so try_first_pass
auth required pam_unix_auth.so

* Editamos /etc/pam.d/common-password y nos aseguramos que quede de la siguiente forma:

password required pam_unix.so nullok obscure min=4 max=8 md5
password sufficient pam_unix.so use_authtok md5 shadow
password sufficient pam_ldap.so use_authtok

* Editamos /etc/pam.d/common-session y nos aseguramos que quede de la siguiente forma:

session required pam_mkhomedir.so skel=/etc/skel/ umask=0022
session required pam_unix.so
session optional pam_ldap.so

Ya tenemos todos los ficheros pam.d necesarios para la autenticacion contra el dominio.

3. Ahora Modificar el Nsswitch que se encuentra en /etc/nsswitch.conf y nos aseguramos que quede de la siguiente forma:

passwd: compat ldap
group: compat ldap
shadow: compat ldap

hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4
networks: files

protocols: db files
services: db files
ethers: db files
rpc: db files

netgroup: nis

En Ubuntu 8.04 solo hay que añador ldap en las tres primeras opciones, lo dema viene por defecto.

4. Por ultimos reiniciamos nscd /etc/init.d/nscd restart y a disfrutar de la autenticación contra el pdc

Hola!!!

Siempre me pregntaba como un grupo de programadores juntaban todo el codigo mientras desarrollaban una aplicacion.

Bueno, ayer un colega y yo comenzamos a realizar un proyecto en Django y nos pruntamos como hacerlo, investigamos un poco por la red y rapido encontramos a CVS. Esto nos permitiría implementar un sistema de control de versiones: mantiener el registro de todo el trabajo y los cambios en los ficheros (código fuente principalmente) que forman el proyecto (de programa) y permite que distintos desarrolladores (potencialmente situados a gran distancia) colaboren.

Basicamente se utiliza en el desarrollo de un proyecto informatico para llevar un control de los ficheros del codigo y evitar por ejemplo que el codigo que escribe un usuario sea “machacado” con el codigo de otro usuario. Ademas con un sistema de control de versiones, el programador siempre puede disponer de la ultima version del codigo lo que ayuda a continuar con el desarrollo del proyecto.

Te pondre un ejemplo de para que sirve todo esto.

Imagina dos programadores que estan trabajando en el mismo proyecto, y casualmente ambos estan modificando el mismo fichero de codigo. Cuando uno de ellos actualice ese fichero en el repositorio se queda marcado, de tal manera que cuando el otro intente subir al repositorio de codigo ya ve, que ese fichero ha sufrido una modificacion desde la ultima vez que el se actualizo, lo que le obliga, a traerse de nuevo ese fichero (con los cambios que haya realizado el primer programador), añadir los suyos y volver a subir el fichero. Sin un mecanismo de control de versiones, ese cambio se perderia, el primer desarrollador subiria el fichero y el segundo subiria su version. Esto para un fichero es controlable, pero cuando tienes miles de ficheros y miles de lineas de codigo significa un desastre total. Por eso el control de versiones es necesario.

Para instalar el servidor y el cliente cvs ejecutamos:

sudo apt-get install cvs cvsd

En un momento determinado nos pedira la ruta para el repositorio, pon por ejemplo /cvsrepo. Este es el directorio a partir del cual se ira colgando todos aquellos modulos/proyectos que administremos con el CVS.

Este directorio lo vamos a definir a partir de /var/lib/cvsd, asi que realmente el path completo seria:

/var/lib/cvsd/cvsrepo

Ejecutamos las siguientes secuencias de comandos:

$ sudo cvsd-buildroot /var/lib/cvsd

Si la carpeta cvsrepo no existe, la creamos

$ cd /var/lib/cvsd
$ sudo mkdir cvsrepo

Le damos permisos sobre la carpeta al usuario cvsd

$ sudo chown -R cvsd:cvsd cvsrepo

Inicializamos el repositorio

$ sudo cvs -d /var/lib/cvsd/cvsrepo init

creamos un usuario cvs y le damos una password.

$ sudo cvsd-passwd /var/lib/cvsd/cvsrepo <username>

por ejemplo:

sudo cvsd-passwd /var/lib/cvsd/cvsrepo papo

Ahora editamos el fichero:

sudo vi /var/lib/cvsd/cvsrepo/CVSROOT/config

Cambiamos “#SystemAuto=no” a “#SystemAuto=yes”

Ya tenemos todo funcionando. Para comprobar que accedemos:

cvs -d :pserver:username@localhost:/cvsrepo login
cvs -d :pserver:username@localhost:/cvsrepo checkout .

Por ejemplo:

cvs -d :pserver:papo@localhost:/cvsrepo login

Seria adecuado exportar la variable CVSROOT del siguiente modo:

export CVSROOT=:pserver:papo@localhost:/cvsrepo

o el valor que fuera, de esta manera ya no necesitariamos especificarla cada vez que fueramos a usar un comando “cvs”.

Ahora podriamos logarnos con:

cvs login

y por ejemplo colocarnos en la carpeta (dentro) de un proyecto que quisieramos subir al CVS y ejecutar:

cvs import -m “ficheros iniciales” MiProyecto HEAD MAIN

Con esto importamos el proyecto a CVS

Ahora podemos usar algun cliente CVS para descargar el proyecto desde el repositorio, yo estoy usando Cervisia que se integra muy bien a Quanta.

Espero que esto les sea de ayuda.

Llevava mucho tiempo intentando encontrar alguna aplicación que funcionara como Babylon en Linux, hasta que finalemente encontre ktranslator que aunque es para KDE funciona perfectamente en Gnome.

1. Instalar ktranslator   apt-get install ktranslator

2. Bajar desde ftp://ftp.ac-grenoble.fr/ge/languages/babylon_dict/  dos archivos: english.dic.gz y EngtoSpa.dic.gz (son los archivos de babylon)

3. Descomprimes los dos archivos obteniendo base y Spanish.dic; renombras (muy importante) base a english.dic y Spanish.dic a EngtoSpa.dic

4. Arrancas ktranslator y en Preferences, Dictionaries le das a Add (añadir) y seleccionas EngtoSpa.dic (en la ruta donde lo hayas descomprimido y renombrado) especificando en el desplegable plug-in to use: Babylon

Listo con esto ya podemos hacer nuestras traducciones usando la tecla Ctrol + Doble Clic

Espero lo disfruten

Cuendo comenzamos en el mundo del Software Libre, teníamos escasos conocimeintos de Linux, recuerdo que en aquellos tiempo nos dirigíamos a los foro para resolver dudas, un amigo me dijo que una de las cosas más bonitas que tenia linux era … que generaba una gran comunidad de ayuda entre usuarios de todo el mundo…, hoy somos parte  de esa comunidad mundial,  de una forma u otra colaboramos con el desarrollo del Software Libre, por eso un grupo de amantes del Software Libre nos hemos unido para transmitir a todos los apacionados del Sistema Operativo del Pinguino nuestros conocimientos, así nace LINVIX, una revista que como principal propósito tiene Dibulgar y Promover el uso del Software Libre en nuestro municipio, Viñales, Pinar del Rio, Cuba.

LA revista aún está en face de desarrollo, queremos compartir la Portada del éste primer número y conocer sus opiniones.

Equipo de Linvix

Hola

El pasado dia 7 de enero publique como hacer una especie de Perfil Mandatorio en Linux, para garantizar un perfil adecuado en cada inicio de sesión, pero al final me di cuenta que impidiendo el acceso de escritura en el direcctorio personal del usuario, algunas aplicaciones no funcionarian correctamente, así que buesqué otra solución.

Esta segunda opción es un poco mas sencilla.

1. Debemos crear un usuario a traves de Gnome (en mi caso), iniciamos sesión con dicho usuario, ajustamos la configuración de su perfil(Tapiz, configuración de Navegadores, Temas, etc…)

2. Hacemos una copia compactada del perfil.

$ tar -cvzf perfil_usuario.tar.gz /home/usuario

3. Copiamos el fichero compactado para /root

cp perfil_usuario.tar.gz /root

4. Creamos un scrip que se encargará de descompactar en cada inicio de sesión el perfil compactado para el directorio /tmp y crear un enlace simbolico hacia el /home

#!/bin/bash
# script sencillo para generar carpetas temporales
cd /tmp
#descompactamos el perfil
tar -xvzf /root/perfil_usuario.tar.gz
#Crea enlace simbolico en /home/usuario
ln -s /tmp/home/usuario /home/usuario
exit 0

Lo guardamos como usuario.sh en el directorio /root

5. Ahora debemos asegurarnos que al iniciar la maquina se ejecute el script, para ello vamos al fichero /etc/rc.local y añadimos al final lo siguiente:

/root/usuario.sh

Weno, hasta aqui todo lo que necesitamos hacer, cada ves que la maquina se reinicia el directorio /tmp se limpia y se pierde el perfil del usuario, cuando la maquina inicia, se ejecuta el script, se descompacta el perfil para /tmp y se crea un enlace simbolico hacia el /home con todos los permisos y configuraciones del usuario.

Hasta la próxima

Hola.

En este artículo explicaré como crear un perfil mandatorio en una maquina linux, en este caso el perfil no se descarga del servidor ni tampoc funciona como en los Window$, pero por lo menos se logra mantener un escritorio limpio y organizado en un laboratorio donde acceden numerosas personas cada dia.

Utilizaremos los archivos temporales del sistema operativo, asi nos aseguramos que cuando se reinicie la maquina se borren todos loa archivos que el usuario a dejado.

Primero debemos un script que cree una carpeta llamada usuario en el directorio /tmp del sistema

#!/bin/bash
# script sencillo para generar carpetas temporales
# Crea carpeta temporal llamada usuario
mkdir /tmp/usuario
# Crea sub carpetas dentro de usuario
mkdir /tmp/usuario/documentos
mkdir /tmp/usuario/videos
mkdir /tmp/usuario/canciones
#Crea enlace simbolico en /home/usuario
ln -s /tmp/usuario /home/estudiante/Escritorio/usuario

La última línea crea un enlace simbolico al Escritorio del estudiante, que sera donde unico tendrá permisos de escritura.

El script que lo podemos guardar con el nombre perfil, y lo podemos guardar en /usr/bin

Ahora para que este script se inicie cada vez que arranque la sesion del usuario estudiante usando gnome debemos de ir a :

Sistema –> Preferencias —>Sesiones

en la pestaña Programas de Inicio hacemos clix en el boton Añadir, luego donde dice Orden pongo la ruta completa donde guarde mi script en este caso:

/usr/bin/perfil

Luego abro terminal le doy permisos de ejecucion al script
$chmod +x /usr/bin/perfil

Ahora como root le doy permisos de solo lectura a /home/estudiante (para evitar que el usuario pueda escribir, guardar y/o modificar archivos en /home/estudiante)

Como se han dado cuenta estoy forzando a que se guarden los documentos en /tmp/usuario

Es cuestion de poner un aviso y decir que pueden guardar sus documentos en la carpeta usuario.

Listo cada vez que se reinicia el sistema se borran todos los archivos que estan dentro de /tmp/usuario y la carpeta usuario se vuelve a crear cada vez que se reinicia el sistema.

Es solo un pequeno ejemplo de lo que se puede hacer. Espero que sea de utilidad.

Linvix

En esta guie explicare como logre instalar Tcos para clientes ligeros usando como servidor una maquina con Ubuntu 8.04.

1. Lo primero que debemos hacer es importa la clave GPG de TCOS

# wget http://www.tcosproject.org/mariodebian-pub.key
# apt-key add mariodebian-pub.key

2. Despues debemos agregar al sources.list el siguiente repo:

deb http://www.tcosproject.org/ hardy main

NOTA: En mi caso uso Hardy (8.04)

3. Actualizamos con:

# apt-get update

4. Posteriormente instalamos Tcos

# apt-get install tcos

Nos pedirá instalar otras aplicaciones, le decimos que “Sí” y esperamos que bajen los paquetes y se instalen.

5. Creamos el directorio /tftpboot

# mkdir /tftpboot

6. Luego se corre el siguiente comando:

# dpkg-reconfigure initramfs-tools-tcos

Estos dos últimos comandos deben correrse ya que tcos nunca creará directorios no-standard por su cuenta. Bien, ya casi  estamos listos, necesitamos verificar mediante synaptic (por ejemplo) que las siguientes aplicaciones estén instaladas:

1. x11vnc
2. freenx
3. alsa-base alsa-utils
4. pulseaudio pulseaudio-utils libflashsupport
5. paman pavucontrol pavumeter
6. ltspfs-client
7. ltspfs-server
8. tcos-server-utils
9. tcosmonitor (Remote management support)
10. tcosconfig (GUI Wizard to build images)
11. dhcp3-server | dhcp-server
12. atftpd
13. openbsd-inetd
14. syslinux
15. xfs
16. tcos-etherboot
17. discover | discover2

7. TCOS Config

Bien, comenzamos corriendo la herramienta tcosconfig, que será la encargada de preparar las imágenes que luego descargarán los clientes. Hay una excelente galería de imágenes para seguir paso a paso (http://wiki.tcosproject.org/Utils/TcosConfig/es). Por lo general la plantilla tcos.conf.all activa la mayoria de las opciones necesaria. Esta herramienta gráfica nos ayuda muchísimo ya que con unos pocos clics podemos llegar a obtene en pocos minutos las imágenes del kernel de los clientes aún sin saber mucho de cuestiones técnicas.

NOTA 1:Durante e proceso de creacion de la imagen debemos observar bien el log que se genera mientras se crea la imagen, es posible que necesitemos instalar otros paquetes (como se puede observar en el Warning), debemos fijarnos bien en el log, y generar la imagen nuevamente si es necesario la instalacion de algun paquete

Warning: PulseAudio overwrite /usr/bin/esd
and cache package not found.
# gentcos -instpkg esound libesd0

Esto se soluciona tan solo con ejeutar el comando q nos muestra: # gentcos -instpkg esound libesd0

Siempre debemos leer bien el log de la creacion de la imagen para solucionar cualquier problema.

8. GDM

Hay que tocar el archivo de configuración de GDM (En caso de usar Gnome, el gestor de escritorio que viene por default en Ubuntu). Simplemente cargamos este archivo

# nano /etc/gdm/gdm.conf

y cambiamos las siguientes líneas a fin de obtener lo siguiente:

[security]
DisallowTCP=false

[xdmcp]
Enable=true

Y grabamos y salimos

Luego debemos reiniciar gdm para que tome los cambios (se nos va a ir todo el entorno gráfico!, no preocuparse)

# /etc/init.d/gdm restart

9. XDM

Editamos ahora el archivo del servidor de fuentes.

# nano /etc/X11/fs/config

Y comentamos la línea que dice:

no-listen = tcp

a fin de dejarla así:

#no-listen = tcp

Grabamos y salimos.

10. DHCP

Debemos configurar dhcp3-server para que asigne las direcciones ip a los clientes.

editatamos /etc/dhcp3/dhcpd.conf

INTERFACES=”eth0″;
#Configurando la primera subred la cual escucha en eth1 (192.168.0.0/24)(RED LOCAL JC)
authoritative;
# Si se desea que el servidor DHCP actualize automaticamente la zona DNS Utilizar ddns-update-style interim;
ddns-update-style none;
subnet 192.168.0.0 netmask 255.255.255.0 {
use-host-decl-names on;
range dynamic-bootp 192.168.0.240 192.168.0.250;
default-lease-time 1800;
max-lease-time 3600;
get-lease-hostnames   true;
option subnet-mask 255.255.255.0;
option broadcast-address 192.168.0.255;
#option routers 192.168.0.1;
option domain-name-servers 192.168.0.1;
option domain-name “vn.pri.jovenclub.cu”;
option netbios-name-servers 192.168.0.1;
option netbios-node-type 8;
option ntp-servers 192.168.0.1;
option time-offset 3600;
option tftp-server-name “server-tcos”; #Este parametro indica el nombre del servidor TCOS
next-server 192.168.0.61;              #Este parametro debe indicar la IP del servidor TCOS
filename “/tftpboot/tcos/pxelinux.0″;  #LA ruta donde esta la imagen de arranque, por defecto es esta
}

#Aqui establecemos IP por MAC a los clientes
host pc1 {
hardware ethernet 00:16:76:B3:49:8B;
fixed-address 192.168.0.50;
}
host pc2 {
hardware ethernet 00:16:76:B3:3A:67;
fixed-address  192.168.0.51;
}
host cliente {
hardware ethernet 00:19:D1:E0:9C:A5;
fixed-address 192.168.0.70;
}
host server-tcos {
hardware ethernet 00:19:D1:E0:9C:A5;
fixed-address 192.168.0.61;
}

Ahora podemos reiniciar dhcp

# /etc/init.d/dhcp3-server restart
Si el servidor Tcos y DHCP no residen enla misma maquina entonces hay que decirle a tcos donde debe de ir a buscar la informacion que necesita, en este caso el servidor tcos tiene ip 192.168.0.61 y el servidor dhcp 192.168.0.1

Debemos editar el fichero /etc/tcos/pxelinux.cfg.tpl y en la etiqueta “label tcos” anadir al final, despues de splash lo siguiente:

tftpserver=192.168.0.61 xserver=192.168.0.61 fontserver=192.168.0.61

Y debemos volver a generar la Imagen con TcosConfig como se describio en el paso 7

esto hace que el cliente ligero utilice este servidor(192.168.0.61) para cargar todos los parametros correctamente, de lo contrario se intentaran cargar desde el servidor dhcp(192.168.0.1) y el cliente ligero no lograra iniciar correctamente.

11. Reiniciamos la maquina y todo debe de salir perfecto

Sugerencias Adicionales

Si el servidor Tcos que tenemos no dispone de mucha RAM podemos instalar el entorno de escritorio Xfce4, que es mas ligero y aumentara el rendimiento. Si lo instalamos y no incia el cliente ligero, vamos Sistema –> Administracion –> Ventana de Entrada y en Remota seleccionamos Igual que la Entrada Local

Bueno. Con esta guia he realizado la instalcion en dos ocaciones en ubuntu, escucho musica, navego por la red,etc… aunque mi servidor tcos no dispone de mucha RAM me siento muy contento por el logro de poder darle vida a equipos viejos.

Agradecimientos a Mariodebia, que es el encargado del proyecto Tcos por su activa colaboracion en la lista y felicitarlo ademas por tan buen trabajo.

Bibliografia:

La pagina del proyecto Tcos es ( La documentacion esta en espanol)

http://wiki.tcosproject.org/
http://wiki.gleducar.org.ar/wiki/Instalaci%C3%B3n_tcos

Esta experiencia la viví ayer, claro que no es nada del otro mundo pero es algo que una ves intenté hacer y no pude, siempre tuve la duda, hasta que ayer se me presentó el problema.

Necesitaba publicar dos sitios hechos con Django en el mismo servidor web, pero no podía usar VirtualHosting, los sitios se tenían que ver bajo las urls:

1. http://midominio.com/sitios/sitiouno/

2. http://midominio.com/sitios/sitiodos/
Inicialmente tenia a /sitiouno/ publicado con la siguiente configuración:

<Location “/sitios/sitiouno/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “['/var/www/sitios-'] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitiouno.settings
PythonAutoReload On
</Location>

#Esta parte es el directorio de las imagenes….
<Location “/jc/vi/cave/imagenes/”>
SetHandler None
</Location>
<LocationMatch “\.(jpg|gif|png)$”>
SetHandler None
</LocationMatch>

Cuando publiqué /sitiodos/ con la misma configuración comenzaron a mezclarse los dos sitios y dar algunos errores  en el acceso de algunas urls. Comencé a leer el libro de Django y rápidamente encontré la solución, usar la directiva PythonInterpreter en cada directiva </Location> quedando el fichero de configuración de la siguiente forma:

<Location “/sitios/sitiouno/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “['/var/www/sitios/'] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitiouno.settings
PythonInterpreter sitiouno
PythonAutoReload On
</Location>
……..

……..
<Location “/sitios/sitiodos/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “['/var/www/sitios/'] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitodos.settings
PythonInterpreter sitiodos
PythonAutoReload On
</Location>
…..

……

De esta forma podemos correr varias instancias de Django bajo el mismo servidor Apache

Espero que esto sea de utilidad para todos, y como dije al principio, no es nada nuevo, pero quizas a alguien le resultó confuso la primera ves.

El At hace los mismo que el cron, pero solo se ejecuta una ves, a diferencia de cron que lo hace de forma periodica, 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 apagar – 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 /home/script now + 10 minutes (ejecutar el script ~/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).
• 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.

Fuente: http://www.buanzo.com.ar/lin/cron_y_at.html