Amazon EC2 is among the more potent items in Amazon’s web services arsenal. You’ve probably heard of many of the other services such as S3 for storage and FPS for payments. EC2 is all about the “elastic compute cloud.” In layman’s terms, it’s a server. In slightly less layman’s terms, EC2 lets you easily run and manage many instances (like servers) and given the proper software and configurations, have a scalable platform for your web application, outsource resource-intensive tasks to EC2 or for whatever you would use a server farm.

There are three different sizes of EC2 instances you can summon and they’re all probably more powerful than the server currently running your blog. Unless you’re offloading video processing or something intense to EC2, the default small instance with its 1.7GB of RAM and 160GB disk should be more than fine. It’s just nice to know that if for any reason I need a farm of machines each with 15GB of RAM, I can get that easily.

EC2 has been around for a while but has gained interest in the last few weeks as Amazon released an elastic IP feature. One of the larger EC2 issues deals with data persistence on instances. There are many limitations with EC2 that make it difficult to use unless you carefully build around the EC2 architecture and don’t just assume that you can move your app to EC2 flawlessly. If an instance crashes and you run it again, you’ll loose data and when the instance comes back up it will have a new IP, adding another hurdle with DNS issues. Fortunately, the elastic IP feature lets you assign a static IP address to your instances.

As the title of this article implies, this article is meant to be a beginner’s look into tinkering with EC2. Just because you will be able to host a page on EC2 at the end of this article does not mean you should start using it as your only server. Many considerations need to be made when using EC2 to get around the data persistence issue. If your startup is looking to use EC2 as a scalable platform, fortunately there are many services that have already built stable systems on top of EC2, ready for your consumption: WeoCeo, Scalr and RightScale. Enough talk, shall we jump right in?

Note: Most of the information below (and more) is available in the EC2 API doc if you enjoy reading those things.

Getting Started

In order to interact with any EC2 instances, you’ll need to install Amazon’s command line tools and download your X.509 certificate from Amazon. Let’s start with the certificate. Login to your Amazon account and visit the AWS Access Identifiers page. In the X.509 certificate section near the bottom, click Create New. You’ll be greeted with a page allowing you to download both the private key file and X.509 certificate. Both of these are very important, download them to your desktop so you don’t lose them.

Next up, grab the EC2 command line tools. Extract them and you should be left with a folder named something like ec2-api-tools-1.3-19403. We’ll move those to a directory where we will also store the private and public keys.

The commands below assume you are working on an OS X machine in the Terminal.

mkdir ~/.ec2
cd ~/Desktop
mv *.pem ~/.ec2
cd ~/Desktop/ec2-api-tools-1.3-19403/  #depends on ec2 tools folder name
mv * ~/.ec2

This is what your .ec2 folder should have now.

Next up, we’ll set some paths in your bash profile so the OS knows where the EC2 tools are located.

sudo vi ~/.bash_profile

Add these lines, replacing “YOURKEYNAME” with the actual file name of your private and public keys, then save.

export EC2_HOME=~/.ec2
export PATH=$PATH:$EC2_HOME/bin
export EC2_PRIVATE_KEY=pk-YOURKEYNAME.pem
export EC2_CERT=cert-YOURKEYNAME.pem
export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Home/

To get the changes noticed by the OS immediately, run source.

source ~/.bash_profile

Now we can actually use those helpful EC2 command line tools.

AMIs, Keypairs and Instances, Oh My!

Before proceeding, you’ll need to grok the concept of AMIs. They are Amazon Machine Images and whenever you create an EC2 instance, an AMI is quickly loaded on the machine. They’re essentially images of the OS. If you terminate an instance and bring it up again, your machine will only have the data initially included in the image. That’s why lots of work goes into making (“bundling”) a good image you will always use that has the configurations and software you need so you don’t have to do much whenever you load the image. This article won’t delve into creating your own AMIs but fortunately there are many great, public AMIs available for use.

To SSH into the instance we’ll create from an AMI we find, we’ll need to create a keypair. This is a different key from the one provided to us by Amazon. That was for using the EC2 tools and interacting with the instances in terms of creation and management. To actually SSH into an instance, a separate keypair is required as there are no passwords by default.

cd ~/.ec2 #we pretty much always need to be here
ec2-add-keypair pstam-keypair

That will print out the private key, which you’ll need to copy and paste into a file manually.

vi ~/.ec2/id_rsa-pstam-keypair
#now paste the private key and save
sudo chmod 600 id_rsa-pstam-keypair

Now we can find which AMI we want to toss on our yet-to-be-created EC2 instance.

cd ~/.ec2
ec2-describe-images -a

Using the -a option will list all of the AMIs you have access to, and there are a lot. Alternatively you can list just the images Amazon has:

ec2-describe-images -o amazon

I found an AMI that I’ll try out.

ami.yyang.info/gentoo-nginx-php-mysql-06feb2008.manifest.xml

It’s a Gentoo Linux install with PHP, MySQL and nginx. When looking at AMIs, you need to find the AMI ID. In this case, it’s ami-6138dd08.

ec2-run-instances ami-6138dd08 -k pstam-keypair

The instance is now being loaded with the AMI I selected and booting up. It should output some text with “RESERVATION” and “INSTANCE” rows. On the instance row, it will say something like pending pstam-keypair until it has fully booted up. When an instance is ready to go, its URL and internal address will be supplied with the ec2din command below.

ec2-describe-instances

If you try to access the URL in a browser, nothing will happen just yet as the firewall blocks all ports by default. You’ll have to open up the ones you need. We’ll do port 80 for HTTP and 22 for SSH. If the AMI you are running doesn’t have a web server installed, accessing the EC2 URL in a browser won’t bring up anything regardless.

ec2-authorize default -p 22
ec2-authorize default -p 80

If you want to undo any port authorizations you’ve made, you can use ec2-revoke. Now if you access your EC2 URL in a browser you’ll get something like a default Apache page, or in the case of the AMI I’m using, a phpinfo() page.

The next step to actually using your new EC2 instance is SSHing into it to get full root access. Run the line below and replace the EC2 URL with the one provided to you by the ec2-describe-images command earlier.

ssh -i id_rsa-pstam-keypair root@ec2-XXX-XXX-XXX-XXX.z-2.compute-1.amazonaws.com

If you run into the problem I did, this won’t work and you’ll be asked for an EC2 instance password that doesn’t exist. I found out this was because I initially created the id_rsa-pstam-keypair file as the root user but ran the ssh command as a regular user which was not able to access that keypair. That was easily fixed with sudo chown Paul id_rsa-pstam-keypair but you won’t have this issue if you followed this guide.

Otherwise, you should be logged into your EC2 instance as root over SSH. Now that we’re in, we can tinker with the system however we like and even see what kind of hardware we’re running on, setup FTP and drop a web app into /var/www/localhost/htdocs or whatever. Having full root access in any OS you wish is one of the boons of using Amazon EC2.

Static IP Time

If you plan on running your instance for good, you’ll want a static IP. Let’s get one for you.

ec2-allocate-address

Now we just need to tie that IP address to the instance ID of the instance you wish to give a static IP. You can grab the instance ID (not to be confused with the ami-* AMI ID) by running ec2-describe-instances.

In the line below, replace XXX.XXX.XXX.XXX with the IP address you were given above and replace i-yourinstance with your actual instance ID.

ec2-associate-address -i i-yourinstance XXX.XXX.XXX.XXX

Give it a few minutes and your instance will be accessible through that new IP in addition to the longer EC2 URL we were previously using. Please note that if you terminate the instance, the IP does not remain tied to the instance, to the best of my knowledge. Terminating an instance seems to be a nuclear option compared to simply rebooting an instance via regular unix commands over SSH.

Now that the instance has an IP you can setup a domain name with it if you want. The easiest way I’ve found of doing this is through a DNS service like EveryDNS. Just provide your domain name registrar with EveryDNS’s domain name servers, create an EveryDNS account, add your domain and create an A record with your newly associated EC2 instance IP address.

The TTL on EveryDNS seems to be fixed at 3600 so it might take a while for propagation, especially if you’re used to pushing down TTL to 300 when doing DNS work.

Terminating Your EC2 Instance

Killing your instance for good can be done, like every other action, through an EC2 command line tool. This time, it’s the appropriately named ec2-terminate-instances (ec2kill). Just provide it with the instance ID of your instance (get it from running ec2din).

ec2-terminate-instances i-yourinstance

It should return with a “shutting-down” status but you’ll definitely want to check back in a few minutes with ec2-describe-instances to make sure it shutdown successfully and comes up as “terminated”. There are a few cases where instances will hang on shutdown and you will continue to be charged for instance hours.

The Next Step

Now that you’ve successfully launched your first Amazon EC2 instance, you’re ready to begin exploring the endless EC2 possibilities. I’m still learning about taking the next step but overall, EC2 really isn’t something to mess with unless you have quite a bit of sysadmin and development experience. Actually using EC2 as an elastic compute cloud usually involves setting up an instance as a load balancer and giving that instance access to an array of active EC2 instances which it can hand work to. Other hurdles include providing multiple instances access to the same database, using Amazon S3 as a persistent filesystem and employing highly redundant backup systems given the relatively volatile nature of instances.

dscacheutil -flushcache

• En Mac OSX Tiger:

lookupd -flushcache

• En Microsoft Windows 2000/XP/Vista:

ipconfig /flushdns

• En Linux:

reiniciar el demonio nscd `/etc/rc.d/init.d/nscd restart`

Gracias Asier Marqués

#!/bin/bash
iptables -F
iptables -X
iptables -Z

# abrimos trafico a la red interna

iptables -A INPUT -s 127.0.0.0/8 -j ACCEPT
iptables -A OUTPUT -s 127.0.0.0/8 -j ACCEPT
iptables -A INPUT -s 10.120.0.0/16 -j ACCEPT
iptables -A INPUT -s 10.120.0.0/16 -j ACCEPT

iptables -A OUTPUT -d ! 10.120.0.0/16 -j DROP

The Wikipedia entry for grep states:

grep is a command line utility originally written for use with the Unix operating system.

The name comes from a command in the Unix text editor ed that takes the form:

g/re/p

This means “search globally for matches to the regular expression re, and print lines where they are found”.

Simple como deben ser las utilidades …

1. Introducción

Esta guía está basada en un ejemplo que usa dos discos duros IDE. Significa que probablemente tendrá que cambiar el disco, los nombres y los tamaños de las particiones según su configuración y sus propias necesidades.

Requisitos iniciales

Si va a hacer una instalación desde cero, hará falta usar un CD del cual pueda arrancar que soporte LVM2, tal como el CD de Instalación Gentoo. Puede encontrar el CD de Instalación para la plataforma x86 en nuestros servidores espejo bajo /releases/x86/current/installcd. Tal vez estén soportadas otras plataformas también.

Si instala LVM2 en un sistema existente con espacio de sobra en disco duro, habrá que activar el módulo LVM2 (dm-mod). Este módulo está disponible en las fuentes gentoo-sources. La compilación del núcleo y el hacer funcionar a LVM2 serán cubiertos más adelante en esta misma guía.

¡No todos los núcleos 2.4 de Gentoo soportan LVM2!

Las particiones

Nuestro sistema de ejemplo tiene dos discos duros IDE y serán particionados de la siguiente manera:

• /dev/hda1 — /boot
• /dev/hda2 — partición de intercambio (swap)
• /dev/hda3 — /
• /dev/hda4 — Será usado por LVM2
• /dev/hdb1 — Será usado por LVM2

OK, hora de comenzar …

2. Instalación

Siga el manual con los siguientes cambios en el capítulo 4.

Preparando los discos:

Use fdisk como dice el Manual, pero use el esquema de particiones antes mencionado como ejemplo. Acuérdese que este es sólo un ejemplo, adáptelo según sus necesidades.

Cree una pequeña partición física para /boot (hda1). En este ejemplo, /boot no será gestionado por LVM2. Esta partición contendrá el gestor de arranque y el/los núcleo(s). 64MB deben ser suficientes para varias generaciones de núcleos.

Cree una partición de intercambio (hda2).

Cree una partición raíz / (hda3). Si le interesa intentar colocar su partición raíz bajo control de LVM (cosa que no recomendamos), vea la sección de recursos al final de esta guía para un enlace a un mini-howto acerca de cómo hacer esto. La partición raíz no requiere ser grande si decide mantener los directorios /opt /usr /home /var y /tmp en un grupo de volúmenes (vg) LVM2. En este caso, 1GB debería ser suficient

Asumiendo que las particiones /boot, de intercambio y raíz no usan el disco físico completo, cree una cuarta partición y asígnele el tipo 8e (Linux LVM). Si tiene más de un disco físico que quiera usar con LVM, cree una partición en cada uno y asígneles el mismo tipo (8e).

Cree los sistemas de archivos en /dev/hda1 y
/dev/hda3, además cree y active la partición de
intercambio en /dev/hda2 tal como se describe en el
manual.

Cargue el módulo LVM2 dm-mod.

# modprobe dm-mod

Antes de realizar la exploración y activación del LVM, querrá editar
el archivo /etc/lvm/lvm.conf para excluir algunos
dispositivos. LVM realizará de forma predeterminada la exploración de
todos los dispositivos, incluso de su lector de CD-ROM, lo cual puede
generar mensajes de error. En el siguiente ejemplo, la línea que
permite la exploración de todos los dispositivos es reemplazada por
una que rechaza todos los dispositivos con excepción de nuestros dos
discos duros IDE.

(Evitar explorar todos los dispositivos salvo nuestros discos duros)

# nano -w /etc/lvm/lvm.conf

(Busque la siguiente línea)

filter = [ "a/.*/" ]



(Reemplácela con la siguiente para explorar /dev/hda y /dev/hdb y

rechazar cualquier otra cosa)

filter = [ "a|/dev/hd[ab]|", "r/.*/" ]

(Guarde el archivo y salga de nano)

# vgscan

Reading all physical volumes.  This may take a while...

No volume groups found



(Haga disponible otros grupos de volúmenes previamente configurados)

# vgchange -a y

Prepare las particiones.

# pvcreate /dev/hda4 /dev/hdb1  No physical volume label read from /dev/hda4

Physical volume "/dev/hda4" successfully created

No physical volume label read from /dev/hdb1

Physical volume "/dev/hdb1" successfully created

Configure un grupo de volúmenes. Este es el resultado de combinar
varias unidades físicas en un único dispositivo lógico.

En nuestro ejemplo, /dev/hda1, /dev/hda2 y
/dev/hda3 son las particiones /boot, de
intercambio y raíz, por lo que necesitamos
combinar /dev/hda4 y /dev/hdb1. Esto se
puede hacer con un solo comando, pero como es un ejemplo didáctico,
crearemos un grupo de volúmenes y luego lo aumentaremos.

(Cree un grupo de volúmenes llamado vg)# vgcreate vg /dev/hda4

/etc/lvm/backup: fsync failed: Invalid argument (Ignore esta advertencia)

Volume group "vg" successfully created(Aumente el tamaño de un grupo de volúmenes existente)

# vgextend vg /dev/hdb1

/etc/lvm/backup: fsync failed: Invalid argument

(Ignore esta advertencia nuevamente y más adelante también)

Volume group "vg" successfully extended

Cree los volúmenes lógicos. Estos son el equivalente a una partición
creada con fdisk en un ambiente sin LVM2. En nuestro ejemplo,
crearemos las siguientes particiones:

Como usaremos LVM2, no nos preocuparemos mucho acerca de los tamaños
de las particiones, ya que las podemos aumentadar a voluntad.

# lvcreate -L10G -nusr  vg  Logical volume "usr" created (Los mensajes adicionales  similares no los mostramos)

# lvcreate -L5G  -nhome vg

# lvcreate -L5G  -nopt  vg

# lvcreate -L10G -nvar  vg

# lvcreate -L2G  -ntmp  vg

(Como ejemplo, aumentemos un volumen lógico en 5 Gbytes)

# lvextend -L+5G /dev/vg/home

Cree los sistemas de archivos en los volúmenes lógicos de la misma
forma que lo haría en una partición regular. Usamos ext3 en los
volúmenes lógicos, pero cualquier sistema de archivos escogido
servirá:

# mke2fs -j /dev/vg/usr# mke2fs -j /dev/vg/home# mke2fs -j /dev/vg/opt

# mke2fs -j /dev/vg/var

# mke2fs -j /dev/vg/tmp

Monte sus particiones como dice el Manual y monte los volúmenes
lógicos LVM2 como si fuesen particiones. Reemplace el

/dev/hdxx de costumbre con
/dev/vg/nombre_del_volumen_lógico.

(Asegúrese de montar primero su partición raíz, tal comoaparece en el Manual)

# mkdir /mnt/gentoo/usr

# mount /dev/vg/usr /mnt/gentoo/usr# mkdir /mnt/gentoo/home

# mount /dev/vg/home /mnt/gentoo/home

# mkdir /mnt/gentoo/opt

# mount /dev/vg/opt /mnt/gentoo/opt

# mkdir /mnt/gentoo/var

# mount /dev/vg/var /mnt/gentoo/var

# mkdir /mnt/gentoo/tmp

# mount /dev/vg/tmp /mnt/gentoo/tmp

Al configurar su núcleo, asegúrese que soporte LVM2 (ya que no todos
de la serie 2.4 lo hacen). Seleccione el módulo LVM2 de la siguiente
manera:

Multi-device support (RAID and LVM)  --->  [*] Multiple devices driver support (RAID and LVM)

< >  RAID support

(Note que LVM no está seleccionado a propósito, esto era para LVM1)

< >  Logical volume manager (LVM) support

<M>  Device-mapper support

< >   Mirror (RAID-1) support

Device Drivers  ---> Multi-device support (RAID and LVM)  --->

[*] Multiple devices driver support (RAID and LVM)

< >   RAID support

<M>   Device mapper support

El módulo compilado se llama dm-mod.ko

Luego de construir su núcleo e instalar sus módulos, agregue la
siguiente línea a su /etc/modules.autoload.d/kernel-{KV},
donde {KV} representa la versión del núcleo (bien sea 2.4 ó 2.6) para
que el módulo LVM2 sea cargado al arrancar la máquina:

# nano -w /etc/modules.autoload.d/kernel-2.6(Agregue la siguiente línea)

dm-mod

Ahora instale el paquete lvm2.

# emerge lvm2

Edite /etc/lvm/lvm.conf tal como se
describe previamente. El archivo que
editó antes es parte de su entorno de instalación y desaparecerá luego
del siguiente reinicio del sistema. Esta vez, edite el archivo
verdadero dentro de su nueva instalación de Gentoo.

Al editar su archivo /etc/fstab, siga el Manual y agregue
sus volúmenes como lo requiera. Una vez más, algunas líneas como
ejemplo:

/dev/hda1     /boot   ext3    noauto,noatime 1 2/dev/hda2     none    swap    sw             0 0

/dev/hda3     /       ext3    noatime        0 1

# Volúmenes lógicos

/dev/vg/usr   /usr    ext3    noatime        0 2

/dev/vg/home  /home   ext3    noatime        0 2

/dev/vg/opt   /opt    ext3    noatime        0 2

/dev/vg/var   /var    ext3    noatime        0 2

/dev/vg/tmp   /tmp    ext3    noatime        0 2

Al llegar al final de la parte de instalación del Manual, no se olvide
desmontar todos los volúmenes lógicos también y para finalizar, ejecute
el siguiente comando antes de reiniciar:

# vgchange -a n

Reinicie su máquina y todas las particiones deberán estar montadas y
visibles.

3. Continuar luego de reiniciar

Si interrumpió la instalación de Gentoo en cierto punto y quiere
continuar, primero necesita crear los nodos de los dispositivos de
vólumen:

# vgscan --mknodes

En cambio en los CDs de Instalación con herramientas no tan actuales
puede que sea necesario reactivar los volúmenes:

(Primero desactive todos los volúmenes)# vgchange -a n

(Exporte todos los volúmenes)

# vgexport -a vg

(Importe todos los volúmenes)# vgimport -a vg

(Reactive todos los volúmenes)

# vgchange -a y

Esto suele pasar en sistemas Gentoo, cuando has ido a toda mecha instalando un sistema, por aquello de las prisas y los presupuestos.

Pero claro que en el, nunca bien ponderado, handbook lo pone:

Si está pensando utilizar sysklogd o syslog-ng quizá quiera instalar posteriormente logrotate ya que esos logeadores no proporcionan ningún mecanismo de rotación para los archivos de log.

Así que:

# emerge -av logrotate

Un dato anecdótico es que tiene Copyright de Red Hat, Inc.

tratatrá ~ # logrotate -v
logrotate 3.7.1 - Copyright (C) 1995-2001 Red Hat, Inc.
This may be freely redistributed under the terms of the GNU Public License

Algunos ficheros de configuración y la ruta del mismo para información:

# cat /etc/logrotate.d/syslog-ng



/var/log/messages {
    rotate 7
    weekly
    size 50M
    sharedscripts
    postrotate
        /etc/init.d/syslog-ng reload > /dev/null 2>&1 || true
    endscript
}

/var/log/syslog {
    rotate 7
    weekly
    size 50M
    sharedscripts
    postrotate
        /etc/init.d/syslog-ng reload > /dev/null 2>&1 || true
    endscript
}

/var/log/debug {
    rotate 7
    weekly
    size 50M
    sharedscripts
    postrotate
        /etc/init.d/syslog-ng reload > /dev/null 2>&1 || true
    endscript
}

Para forzar el rotado de logs ejecuta esta instrucción:

# logrotate -f /etc/logrotate.conf

Más informacion en: http://gentoo-wiki.com/HOWTO_Setup_Logrotate

Para ello disponemos de este pequeño script que nos hará la vida más fácil.

#!/bin/bash
# vim: set sw=4 sts=4 et tw=80 :

# Author:        Ciaran McCreesh
# Purpose:       Display ebuild keywords in a graphical form
# Invocation:    eshowkw [ packagename ] (defaults to current directory if no
#                packagename is provided)

shopt -s extglob

PID_TO_KILL=$$

die() {
    echo "$@" 1>&2
    kill $PID_TO_KILL
}

trap 'exit 250' 15

get_portage_dir() {
    local dir
    if  -z ${portage_dir_cache}  ; then
        for dir in "${HOME}/cvs/gentoo-x86" "/usr/portage" ; do
             -d ${dir}/profiles  && portage_dir_cache=${dir} && break
        done
    fi
     -z ${portage_dir_cache}  && portage_dir_cache=$(portageq portdir )
    export portage_dir_cache
    echo ${portage_dir_cache}
}

version_sort() {
    local items= left=0
    items=( $@ )

    while [[ ${left} -lt ${#items[@]} ]] ; do
        local lowest_idx=${left}
        local idx=$(( ${lowest_idx} + 1 ))
        while [[ ${idx} -lt ${#items[@]} ]] ; do
            version_compare "${items[${lowest_idx}]}" "${items[${idx}]}"
             $? -eq 3  && lowest_idx=${idx}
            idx=$(( ${idx} + 1 ))
        done
        local tmp=${items[${lowest_idx}]}
        items[${lowest_idx}]=${items[${left}]}
        items[${left}]=${tmp}
        left=$(( ${left} + 1 ))
    done
    echo ${items[@]}
}

version_compare() {
    local ver_a=${1} ver_b=${2} parts_a parts_b cur_idx_a=0 cur_idx_b=0
    parts_a=( $(get_all_version_components "${ver_a}" ) )
    parts_b=( $(get_all_version_components "${ver_b}" ) )

    ### compare number parts.
    local inf_loop=0
    while true ; do
        # grab the current number components
        local cur_tok_a=${parts_a[${cur_idx_a}]}
        local cur_tok_b=${parts_b[${cur_idx_b}]}

        # number?
        if  -n ${cur_tok_a}  && [[ -z ${cur_tok_a//:digit:} ]] ; then
            cur_idx_a=$(( ${cur_idx_a} + 1 ))
            [[ ${parts_a[${cur_idx_a}]} == "." ]] \
                && cur_idx_a=$(( ${cur_idx_a} + 1 ))
        else
            cur_tok_a=""
        fi

        if  -n ${cur_tok_b}  && [[ -z ${cur_tok_b//:digit:} ]] ; then
            cur_idx_b=$(( ${cur_idx_b} + 1 ))
            [[ ${parts_b[${cur_idx_b}]} == "." ]] \
                && cur_idx_b=$(( ${cur_idx_b} + 1 ))
        else
            cur_tok_b=""
        fi

        # done with number components?
         -z ${cur_tok_a}  &&  -z ${cur_tok_b}  && break

        # to avoid going into octal mode, strip any leading zeros. otherwise
        # bash will throw a hissy fit on versions like 6.3.068.
        cur_tok_a=${cur_tok_a##+(0)}
        cur_tok_b=${cur_tok_b##+(0)}

        # if a component is blank, make it zero.
         -z ${cur_tok_a}  && cur_tok_a=0
         -z ${cur_tok_b}  && cur_tok_b=0

        # compare
         ${cur_tok_a} -lt ${cur_tok_b}  && return 1
         ${cur_tok_a} -gt ${cur_tok_b}  && return 3
    done

    ### number parts equal. compare letter parts.
    local letter_a=
    letter_a=${parts_a[${cur_idx_a}]}
    if  ${#letter_a} -eq 1  && [[ -z ${letter_a/[a-z]} ]] ; then
        cur_idx_a=$(( ${cur_idx_a} + 1 ))
    else
        letter_a="@"
    fi

    local letter_b=
    letter_b=${parts_b[${cur_idx_b}]}
    if  ${#letter_b} -eq 1  && [[ -z ${letter_b/[a-z]} ]] ; then
        cur_idx_b=$(( ${cur_idx_b} + 1 ))
    else
        letter_b="@"
    fi

    # compare
     ${letter_a} < ${letter_b}  && return 1
     ${letter_a} > ${letter_b}  && return 3

    ### letter parts equal. compare suffixes in order.
    local suffix rule part r_lt r_gt
    for rule in "alpha=1" "beta=1" "pre=1" "rc=1" "p=3" "r=3" ; do
        suffix=${rule%%=*}
        r_lt=${rule##*=}
         ${r_lt} -eq 1  && r_gt=3 || r_gt=1

        local suffix_a=
        for part in ${parts_a[@]} ; do
             ${part#${suffix}} != ${part}  && \
                [[ -z ${part##${suffix}*(:digit:)} ]] && \
                suffix_a=${part#${suffix}}0
        done

        local suffix_b=
        for part in ${parts_b[@]} ; do
             ${part#${suffix}} != ${part}  && \
                [[ -z ${part##${suffix}*(:digit:)} ]] && \
                suffix_b=${part#${suffix}}0
        done

         -z ${suffix_a}  &&  -z ${suffix_b}  && continue

         -z ${suffix_a}  && return ${r_gt}
         -z ${suffix_b}  && return ${r_lt}

        # avoid octal problems
        suffix_a=${suffix_a##+(0)} ; suffix_a=${suffix_a:-0}
        suffix_b=${suffix_b##+(0)} ; suffix_b=${suffix_b:-0}

         ${suffix_a} -lt ${suffix_b}  && return 1
         ${suffix_a} -gt ${suffix_b}  && return 3
    done

    ### no differences.
    return 2
}

get_all_version_components() {
    local ver_str=${1} result result_idx=0
    result=( )

    while  -n "$ver_str"  ; do
        case "${ver_str:0:1}" in
            # number: parse whilst we have a number
            :digit:)
                result[$result_idx]="${ver_str%%[^[:digit:]]*}"
                ver_str="${ver_str##+(:digit:)}"
                result_idx=$(($result_idx + 1))
                ;;

            # separator: single character
            [-_.])
                result[$result_idx]="${ver_str:0:1}"
                ver_str="${ver_str:1}"
                result_idx=$(($result_idx + 1))
                ;;

            # letter: grab the letters plus any following numbers
            :alpha:)
                local not_match="${ver_str##+(:alpha:)*(:digit:)}"
                result[$result_idx]=${ver_str:0:$((${#ver_str} - ${#not_match}))}
                ver_str="${not_match}"
                result_idx=$(($result_idx + 1))
                ;;

            # huh?
            *)
                result[$result_idx]="${ver_str:0:1}"
                ver_str="${ver_str:1}"
                result_idx=$(($result_idx + 1))
                ;;
        esac
    done

    echo ${result[@]}
}

get_package_dir() {
    if  -z ${1}  ; then
        pwd
        return 0
    fi

    if  -d ${1}  ; then
        readlink -f ${1}
        return 0
    fi

    get_portage_dir 1>/dev/null
    if  ${1/\/} != ${1}  ; then
        local d=$(get_portage_dir )/${1}
        if  -d ${d}  ; then
            echo ${d}
            return 0
        fi
    else
        local d
        d=( $(echo $(get_portage_dir )/*-*/${1} ) )
        if [[ ${#d[@]} -gt 1 ]] ; then
            die "${1} is ambiguous"
        elif [[ -d ${d[0]} ]] ; then
            echo ${d[0]}
            return 0
        fi
    fi

    return 1
}

repeat() {
    local i
    for (( i=0 ; i < ${1} ; i=$(( ${i} + 1 )) )) ; do
        echo -n "${2}"
    done
}

get_keywords() {
    (
        inherit() { :; }
        source ${1} 2>/dev/null
        echo ${KEYWORDS}
    )
}

colorarch() {
    case "${1}" in
        amd64)
            echo -n -e "\033[0;33m${2}\033[0;0m"
            ;;
        x86)
            echo -n -e "\033[0;31m${2}\033[0;0m"
            ;;
        *)
            echo -n "${2}"
            ;;
    esac
}

colourise() {
    case "${1}" in
        \*)
            echo -n -e "\033[0;31m*\033[0;0m"
            ;;
        +)
            echo -n -e "\033[0;32m+\033[0;0m"
            ;;
        -)
            echo -n -e "\033[0;31m-\033[0;0m"
            ;;
        \~)
            echo -n -e "\033[0;33m~\033[0;0m"
            ;;
        *)
            echo -n "${1}"
            ;;
    esac
}

show_keyword_diagram() {
    echo -n -e "Keywords for \033[1;34m"
    local title=$(readlink -f $(pwd ) )
    title=${title#$(readlink -f ../.. )/*( )}
    echo -n "${title}"
    echo -e "\033[0;0m:"
    echo

    local archs= arch_length=0 arch=
    archs=( $(< $(get_portage_dir )/profiles/arch.list ) )
    for arch in "${archs[@]}" ; do
         ${#arch} -gt ${arch_length}  && arch_length=${#arch}
    done

    local versions= pkgname= version_length=0 version=
    pkgname=$(basename $(readlink -f ./ ) )
    versions=( $(for e in $(echo *.ebuild ) ; do \
             -f ${e}  && echo ${e} | sed -e 's/\.ebuild$//g' \
                    -e "s/^${pkgname}-//g" ; \
            done ) )
    versions=( $(version_sort ${versions[@]} ) )
    for version in "${versions[@]}" ; do
         ${#version} -gt ${version_length}  && version_length=${#version}
    done

    local i=0 archletter=
    for (( i = 0 ; i < ${arch_length} ; i=$(( ${i} + 1 )) )) ; do
        repeat ${version_length} " "
        echo -n " | "
        for arch in "${archs[@]}" ; do
            archletter="${arch:${i}:1}"
            echo -n "$(colorarch "${arch}" "${archletter:- }" ) "
        done
        echo
    done

    repeat ${version_length} "-"
    echo -n "-+"
    repeat ${#archs[@]} "--"
    echo

    for version in "${versions[@]}" ; do
        echo -n "${version}"
        repeat $(( ${version_length} - ${#version} )) " "
        echo -n " | "

        local keyword keywords
        keywords=( $(get_keywords "${pkgname}-${version}.ebuild" ) )
        for arch in "${archs[@]}" ; do
            local display=" "
            [[ ${keywords[@]/-\*} != ${keywords[@]} ]] && display="*"
            for keyword in "${keywords[@]}" ; do
                [[ ${arch} == "${keyword#[~-]}" ]] && \
                    display=${keyword:0:1} && \
                    break;
            done
            [[ -z ${display#[~ *-]} ]] || display="+"
            echo -n "$(colourise "${display}" ) "
        done

        echo
    done
}

main() {
    local dir=$(get_package_dir "${1}" )
     -z ${dir}  && die "Couldn't find '${1}'"
    cd ${dir}
     $(echo *.ebuild ) != "*.ebuild"  || die "No ebuilds in ${dir}"
    show_keyword_diagram
    true
}

main "$@"

En el caso de que no se encuentre en la ubicación original he hecho un micro mirror de la versión de fecha de hoy:

eshowkw

Slàinte!

Ejecutaremos unas cuantas veces yes redirigiendo su salida a /dev/null y poniendo el proceso en background para tener algo con lo que trabajar:

jgr@seiya ~ $ yes &> /dev/null & yes &> /dev/null & yes &> /dev/null &

[1] 3670

[2] 3671

[3] 3672

Si hacemos ahora un ps de los de toda la vida veremos esto (la última línea es el propio grep):

jgr@seiya ~ $ ps aux | grep yes

jgr       3670 42.8  0.0   4164   584 pts/2    R    20:12   0:19 yes

jgr       3671 41.4  0.0   4164   584 pts/2    R    20:12   0:19 yes

jgr       3672 42.8  0.0   4164   584 pts/2    R    20:12   0:19 yes

jgr       4244  0.0  0.0   6368   808 pts/2    S+   20:13   0:00 grep --colour=auto yes

Ahora con pgrep veremos sólo los pid’s de los procesos:

jgr@seiya ~ $ pgrep yes

3670

3671

3672

Y con pkill los matamos y con pgrep comprobaremos que estén realmente muertos:

jgr@seiya ~ $ pgrep yes

[1]   Terminado               yes >&/dev/null

[2]-  Terminado               yes >&/dev/null

[3]+  Terminado               yes >&/dev/null

pgrep y pkill tienen algunas opciones interesantes como por ejemplo -l para mostrar el nombre de los procesos (sólo pgrep) o -u/-U para mostrar o matar sólo los procesos del usuario especificado y alguna más que podéis ver en el man de pgrep.

Bueno y ya que estamos con ps os enseñaré un alias que suelo usar en el .bashrc para hacer más cómodo el uso de ps:

export GREP_COLOR="1;32" #verde claro

alias grep='grep --colour=auto'

alias psg="ps aux | grep -v grep | grep"

Básicamente lo que hacen estos alias es colorear las concordancias del grep y eliminar la última línea de la salida del ps que corresponde al propio grep. Aquí podéis ver un ejemplo otra vez con el proceso yes del ejemplo anterior:

Vía: http://emergeworld.blogspot.com/

1.- Añadid a vuestro .bashrc

# export MANPAGER="col -b | view -c 'set ft=man nomod nolist' -"

2.- Recargad las variables de entorno para poder usarlo en la shell actual:

# source ~/.bashrc

Ya está ya podéis usar vi para ver páginas de man

Vía: http://emergeworld.blogspot.com/

Se trata de una aplicación que se invoca picando, net-setup.

Es muy práctica y se encuentra dentro del conjunto de aplicaciones que viven en livecd-tools.