echo “5902 stream tcp nowait root /usr/sbin/qm qm vncproxy 102 password” >> /etc/inetd.conf
 
/etc/init.d/openbsd-inetd restart

Donde 5902 es el puerto de VNC,
102 es el número de máquina virtual
y password la contraseña VNC de acceso

vía: Dar acceso VNC a una máquina virtual Proxmox sin acceder al panel | xavifernandez.com.

No ha sido posible crear este objetos por el siguiente motivo:

El script de inicialización ha fallado

Normalmente pasa cuando actualizamos la versión del sistema o instalamos uno de nuevo.

La mejor opción para estos casos es abrirnos una consola y lanzarlo desde consola.

Para listar los plasmoid instalados:

plasmapkg -l

Para lanzar un plasmoid:

plasmoidviewer nombre-plasmoid

De esta forma podemos ver qué dependencia necesitamos o qué error nos está reportando. Sin ir más lejos, en openSuse 12.1, el plasmoid veromix no funciona a pesar de instalar varias dependencias que solicita el desarrollador. Al lanzarlo desde consola obtengo:

plasmoidviewer veromix-plasmoid
Traceback (most recent call last):
  File "/usr/share/kde4/apps/plasma_scriptengine_python/pyappletscript.py", line 59, in init
    self.module = __import__(self.pluginName+'.'+relpath)
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/fasiko/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/main.py", line 57, in <module>
    from VeroMix import VeroMix
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/fasiko/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/VeroMix.py", line 27, in <module>
    from SortedLayout import SortedLayout
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/SortedLayout.py", line 20, in <module>
    from SinkInputUI import InputSinkUI
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/SinkInputUI.py", line 27, in <module>
    from SinkUI import *
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/SinkUI.py", line 26, in <module>
    from Channel import Channel
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/Channel.py", line 27, in <module>
    from MuteButton  import MuteButton
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/MuteButton.py", line 23, in <module>
    from Utils import *
  File "/usr/share/kde4/apps/plasma_scriptengine_python/plasma_importer.py", line 107, in load_module
    exec code in mod.__dict__
  File "/home/usuario/.kde4/share/apps/plasma/plasmoids/veromix-plasmoid/contents/code/Utils.py", line 20, in <module>
    from xdg import BaseDirectory
ImportError: No module named xdg

Podemos ver que nos informa que no encuentra el módulo xdg por lo que al buscarlo, veo que hay un paquete llamado python-xdg el cual no está instalado. Tras instalarlo y lanzarlo de nuevo, funciona perfectamente por lo que ya sólo nos queda reiniciar la sesión.

• Añadir una partición al disco virtual, primero tenemos que formatearla con fdisk y marcarla como 8e (Linux LVM). Después añadiremos la partición al disco virtual:

  vgextend disco_virtual /dev/hdc1

• Aumentar el tamaño de una partición virtual, primero aumentaremos el tamaño de la partición:

  lvextend -L+120G /dev/mapper/disco_virtual-home

  y luego aumentaremos el tamaño del filesystem:

  umount /dev/mapper/disco_virtual-home resize2fs /dev/mapper/disco_virtual-home mount /dev/mapper/disco_virtual-home /home

• Reducir el tamaño de una partición virtual, primero reduciremos el tamaño del filesystem:

  umount /dev/mapper/disco_virtual-home resize2fs /dev/mapper/disco_virtual-home 80G mount /dev/mapper/disco_virtual-home /home

  y luego reduciremos el tamaño de la partición:

  lvreduce -L-120G /dev/mapper/disco_virtual-home

• Quitar una partición del disco virtual, primero moveremos los datos que contiene a otras particiones con el comando:

  pvmove /dev/hdc1

  y luego quitaremos la partición:

  vgreduce disco_virtual /dev/hdc1

  Ya podemos quitar físicamente la unidad.

vía: LVM (volumenes logicos) en Linux | Estréllate y Arde.

Con algo más de 4 años de vida, jQuery se ha convertido en la librería JavaScript más utilizada actualmente, y es que, además, es gratuita, de código abierto (bajo licencia MIT y GPL v2) e increíblemente ligera. Entre sus usuarios podemos encontrar a Google, Microsoft, IBM, Amazon, Twitter, WordPress, Mozilla o Drupal.

Para poder utilizar esta librería lo primero que tendremos que hacer será incluir su código en nuestro proyecto. Podemos descargar el script desde su página web, subirlo a nuestro servidor, y ejecutarlo con la etiqueta script:

<script type="text/javascript" src="jquery.js"></script>

También podemos cargarla directamente desde el CDN que mantiene Google:

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>

el de Microsoft:

<script type="text/javascript" src="http://ajax.microsoft.com/ajax/jquery/jquery-1.4.2.min.js"></script>

o el del propio jQuery

<script type="text/javascript" src="http://code.jquery.com/jquery-1.4.2.min.js"></script>

Independientemente de la opción elegida, ya estaremos listos para comenzar a trabajar con la librería. Sin embargo, y aunque no es estrictamente necesario, os aconsejaría tener unos conocimientos básicos de JavaScript primero, conocimientos que podéis obtener con nuestro tutorial de JavaScript. Y ahora, manos a la obra.

El corazón de jQuery es la función sobrecargada del mismo nombre, jQuery, que ofrece distinta funcionalidad dependiendo de los parámetros utilizados. Además, como JavaScript también toma conceptos del paradigma funcional, y las funciones no son más que otro tipo de objeto, la función jQuery cuenta a su vez con distintas propiedades y métodos. La intención de esta decisión de diseño es la de evitar llenar el espacio de nombres global con montones de nombres inútiles esperando a colisionar.

Si queremos escribir menos y que nuestros archivos sean más pequeños, y si no utilizamos ninguna otra librería que pueda causar algún conflicto con este símbolo, también podemos utilizar el alias $ en sustitución de jQuery.

SELECTORES JQUERY

El primer paso a la hora de trabajar con jQuery es seleccionar los elementos del árbol de documento sobre los que queremos trabajar. Para ello se utiliza la funciónjQuery, pasando como argumento a la función una cadena con un selector, la mayoría de los cuales utilizan una sintaxis similar a la de CSS 3 (ver Tutorial rápido de CSS). El engine que utiliza jQuery para seleccionar elementos se llama Sizzle, y puede descargarse y utilizarse de forma aislada.

Los distintos selectores que podemos utilizar son los siguientes:

Selectores básicos

Selector universal: selecciona todos los elementos de la página (CSS 2)

jquery("*")

Selector de tipo o etiqueta: selecciona todos los elementos con el tipo de etiqueta indicado (CSS 1)

jQuery("div")

Selector de clase: selecciona todos los elementos con la clase indicada (atributo class) (CSS 1)

jQuery("div.entrada")

Selector de identificador: selecciona el elemento con el identificador (atributo id) indicado (CSS 1)

jQuery("div#cabecera")

Grupos de selectores: se puede combinar el resultado de varios selectores distintos separándolos con comas (CSS 1)

jquery("p,div,a")

Selectores de atributos

Selector de atributo: selecciona elementos que tengan un cierto atributo (CSS 2)

jquery("a[rel]")

También se puede seleccionar aquellos que tengan un cierto valor para un atributo (CSS 2)

jquery("a[rel='nofollow']")

O que tengan un valor distinto del indicado (jQuery)

jQuery("a[rel!='nofollow']")

Aquellos cuyo valor empieza por una cierta cadena (CSS 3)

jquery("a[href^='http://mundogeek.net/']")

Los que terminan con una cierta cadena (CSS 3)

jquery("a[href$='.com']")

Y los que contienen una cierta cadena (CSS 3)

jquery("a[href*='geek']")

Por último, podemos hacer combinaciones de todo lo anterior (CSS 2)

jquery("a[rel='nofollow'][href]")

Selectores de widgets

Pseudo clase botón: selecciona todos los botones (jQuery)

jquery(":button")

Pseudo clase checkbox: selecciona todos los checkboxes (jQuery)

jquery(":checkbox")

Pseudo clase archivo: selecciona todos los widgets de tipo archivo (jQuery)

jquery(":file")

Pseudo clase cabeceras: selecciona todas las cabeceras (jQuery)

jquery(":header")

Pseudo clase imagen: selecciona todas las imágenes (jQuery)

jquery(":image")

Pseudo clase input: selecciona todos los widgets de tipo input (jQuery)

jquery(":input")

Pseudo clase contraseña: selecciona todos los elementos password (jQuery)

jquery(":password")

Pseudo clase radiobutton: selecciona todos los elementos radiobutton (jQuery)

jquery(":radio")

Pseudo clase reset: selecciona todos los elementos reset (jQuery)

jquery(":reset")

Pseudo clase seleccionado: selecciona las opciones seleccionadas en un select (jQuery)

jquery(":select")

Pseudo clase submit: selecciona todos los elementos submit (jQuery)

jquery(":submit")

Pseudo clase texto: selecciona todos las cajas de texto (jQuery)

jquery(":text")

Pseudo clase marcado: selecciona todos los radiobuttons y checkboxes marcados (CSS 3)

jquery(":checked")

Pseudo clase activo: selecciona todos los elementos que estén activos (CSS 3)

jquery("input:enabled")

Pseudo clase inactivo: selecciona todos los elementos que no estén activos (CSS 3)

jquery("input:disabled")

Pseudo clase ocultos: selecciona todos los elementos ocultos (jQuery)

jquery(":hidden")

Pseudo clase visible: selecciona todos los elementos visibles (jQuery)

jquery(":visible")

Selectores de jerarquía

Selector de descendientes: selecciona elementos que desciendan de otro elemento (CSS 1)

jquery("div.entrada h2")

Selector de hijos: selecciona elementos que sean hijos directos de otro elemento (CSS 2)

jquery("div.entrada > h2")

Pseudo clase hijo: selecciona el enésimo hijo de un elemento (CSS 3)

jquery("tr:nth-child(1)")

Pseudo clase primer hijo: selecciona el primero hijo de un elemento (CSS 2)

jquery("tr:first-child")

Pseudo clase último hijo: selecciona el último hijo de un elemento (CSS 3)

jquery("tr:last-child")

Pseudo clase hijo único: selecciona los elementos que sean hijos únicos de otros elementos (CSS 3)

jquery("div:only-child")

Pseudo clase índice: selecciona el elemento con el índice indicado de un grupo de elementos (jQuery)

jquery("td:eq(0)")

Pseudo clase primero: selecciona el primer elemento de un grupo de elementos. Equivale a eq(0) (jQuery)

jquery("td:first)")

Pseudo clase último: selecciona el último elemento de un grupo de elementos (jQuery)

jquery("td:last)")

Pseudo clase mayor que: selecciona todos los elementos con un índice mayor que el indicado en un grupo de elementos (jQuery)

jquery("td:gt(0)")

Pseudo clase menor que: selecciona todos los elementos con un índice menor que el indicado en un grupo de elementos (jQuery)

jquery("td:lt(3)")

Pseudo clase par: selecciona los elementos pares de un grupo de elementos (jQuery)

jquery("td:even")

Pseudo clase impar: selecciona los elementos impares de un grupo de elementos (jQuery)

jquery("td:odd")

Selector de hermanos: selecciona todos los hermanos que se encuentren precedidos de otro elemento (CSS 3)

jquery("div.entrada ~ p")

Selector de próximo adyacente: similar al anterior, pero sólo selecciona el adyacente directo (CSS 2)

jquery("div.entrada + p")

Pseudo clase padre: selecciona los padres de otros elementos (jQuery)

jquery("h2:parent")

Pseudo clase vacío: selecciona los elementos que no tengan ningún hijo, incluyendo texto plano (CSS 3)

jquery(":empty")

Otros selectores

Pseudo clase animado: selecciona todos los elementos que están en proceso de animación en este momento (jQuery)

jquery(":animated")

Pseudo clase contiene: selecciona todos los elementos que contengan el texto indicado, directamente o en uno de los hijos (jQuery)

jquery("div:contains('Mundo geek')")

Pseudo clase tiene: selecciona todos los elementos que contengan al menos un elemento que responda al selector indicado (jQuery)

jquery("div:has(h2)")

Pseudo clase negación: selecciona todos los elementos que no cumplan con el selector dado (CSS 3)

jquery("div:not(.entrada)")

GESTIONANDO UNA COLECCIÓN JQUERY
Al llamar a la función jQuery con un selector como argumento, el valor devuelto será otro objeto jQuery representando la colección de elementos DOM seleccionados. Tanto es así, que podremos obtener uno de los elementos utilizando el operador [], como si de un array normal se tratara

jQuery("div.entrada")[0]

y también tenemos acceso a una propiedad length con el número de elementos que contiene la colección

jQuery("div.entrada").length

Otras cosas que podemos hacer con este objeto son añadir elementos a la colección

jQuery("div.entrada").add("div.comentario")

eliminar elementos

jQuery("div.entrada").not("div.destacada")

filtrar elementos con un selector o basándonos en el valor devuelto por una función

jQuery("div.entrada").filter(":has(h2)")

quedarnos con los elementos que contengan otro cierto elemento

jQuery("div.entrada").has("h2")

obtener un sólo elemento, por su índice

jQuery("div.entrada").eq(3)

obtener el primer elemento de la colección

jQuery("div.entrada").first()

obtener el último elemento de la colección

jQuery("div.entrada").last()

crear una sub colección a partir de la original

jQuery("div.entrada").slice(0,5);
jQuery("div.entrada").slice(3);

obtener los descendientes directos

jQuery("div.entrada").children()  
jQuery("div.entrada").children("p")

obtener los descendientes directos, incluyendo el texto plano

jQuery("div.entrada").contents()

obtener los hijos que cumplan con un determinado selector

jQuery("div.entrada").find("p")

obtener el hermano siguiente

jQuery("div.entrada").next()

obtener los hermanos siguientes

jQuery("div.entrada").nextAll()

obtener el hermano anterior

jQuery("div.entrada").prev()

obtener los hermanos anteriores

jQuery("div.entrada").prevAll()

obtener todos los hermanos

jQuery("div.entrada").siblings()

obtener el padre de cada elemento

jQuery("div.entrada").parent()

obtener todos los ancestros de cada elemento

jQuery("div.entrada").parents()

crear una copia de la colección

jQuery("div.entrada").clone()

o buscar la posición que ocupa un elemento en la colección (si existe)

jQuery("*").index("div.entrada")

MODIFICAR LA PÁGINA CON JQUERY

Veamos ahora cómo utilizar jQuery para modificar nuestra página web. Podemos, por ejemplo, modificar el valor de un atributo

jQuery("a#principal").attr("href", "http://mundogeek.net/")

añadir una nueva clase a uno o varios elementos

jQuery("div.entrada:first").addClass("primera")

añadir una propiedad CSS a uno o varios elementos

jQuery("div.entrada").css("border", "1px solid red")

añadir contenido a un elemento

jQuery("div.entrada:first").before("<strong>Destacada</strong>");
jQuery("div.entrada:first").prepend("<strong>Destacada</strong>");
jQuery("div.entrada:first").after("<strong>Destacada</strong>");
jQuery("div.entrada:first").append("<strong>Destacada</strong>");

modificar el contenido de un elemento

jQuery("p").html("<strong>Sustituido</strong>")

eliminar un elemento de la página

jQuery("div.entrada:first").remove()

ocultar un elemento

jQuery("p").hide()

o volver a mostrar un elemento

jQuery("p").show()

EVENTOS EN JQUERY

Existen distintas funciones para asignar una función que maneje un evento lanzado por un widget. Para el evento click, al hacer clic sobre un elemento:

jQuery(":button#pulsame").click(function () {
  alert("Has hecho clic");
});

evento submit, cuando se pulsa sobre el botón de enviar de un formulario:

jQuery("#formulario").submit(function() {  
  alert("Enviando");
});

evento dblclick, al hacer doble clic sobre un elemento:

jQuery("p:first").dblclick(function () {  
  alert("Has hecho doble clic");  
});

evento hover, cuando al pasar el ratón por encima de un elemento. Podemos utilizarjQuery(this) para referirnos a este elemento:

jQuery("p:first").hover(function () {  
  jQuery(this).css("border", "1px solid red");  
});

evento mouseenter, cuando el cursor entra en un elemento

jQuery("p:first").mouseenter(function () {  
  jQuery(this).css("border", "1px solid red");  
});

evento mouseout, cuando el cursor sale de un elemento

jQuery("p:first").mouseenter(function () {  
  jQuery(this).css("border", "1px solid red");  
});  
 
jQuery("p:first").mouseout(function () {  
  jQuery(this).css("border", "0");  
});

evento change, cuando se modifica un elemento:

jQuery(":text#nombre").change(function () {  
  alert("Cambiado");  
});

evento load, cuando se termina de cargar el elemento:

jQuery(window).load(function () {  
  alert("Página cargada");  
});

evento ready, cuando se termina de cargar el DOM, para no tener que esperar a cargar las imágenes, por ejemplo, de forma que el usuario pueda utilizar nuestra funcionalidad JavaScript cuanto antes:

jQuery(document).ready(function () {  
  alert("DOM cargado");  
});

esto último, al ser esto algo muy común, se puede resumir pasando una función a la función jQuery, directamente:

jQuery(function () {  
  alert("DOM cargado");  
});

ANIMACIONES CON JQUERY

jQuery viene con unas pocas animaciones útiles y vistosas por defecto, aunque para sacarle todo el partido probablemente tendremos que recurrir a plugins.

Para hacer un fundido a opaco:

jQuery(function () {  
  jQuery("p").hide();  
  jQuery("p").delay(200).fadeIn();  
});

En el ejemplo anterior se utiliza delay para hacer pasar un par de segundos y que se vea más claramente el efecto. A esta función se le puede pasar un valor numérico con el número de milisegundos a esperar, o una cadena, como “slow” (lento) o”fast” (rápido).

para hacer un fundido a transparente:

jQuery(":button").click(function () {  
  jQuery("p").fadeOut();  
});

También podemos cambiar la opacidad de un elemento a cualquier valor intermedio

jQuery(":button").click(function () {  
  jQuery("p").fadeTo("slow", 0.5);  
});

mostrar los elementos con una animación de deslizamiento de arriba a abajo:

jQuery(function () {  
  jQuery("p").hide().delay(200).slideDown();  
});

ocultarlos deslizándolos hacia arriba:

jQuery(function () {  
  jQuery("p").delay(200).slideUp();  
});

mostrarlos u ocultarlos, dependiendo de si se estaban mostrando o no:

jQuery(":button").click(function () {  
  jQuery("p").delay(200).slideToggle();  
});

Por último, para cualquier otro tipo de animación con propiedades CSS cuyos valores sean numéricos, utilizaríamos:

jQuery(":button").click(function () {  
  jQuery("p").animate({opacity:0.50,width:100}, 'slow');  
});

JQUERY Y AJAX

La forma más sencilla de enviar una petición HTTP de forma asíncrona y mostrar el resultado en la página actual es utilizar la función load. Esta se ejecuta sobre el elemento al que se va a añadir la respuesta, y se le pasa como argumento una cadena con el archivo a cargar. Esta cadena puede contener también un selector con el que seleccionar qué elementos queremos mostrar de la respuesta.

jQuery(":button").click(function () {  
  $("#citas").load("citas.html li");  
});

también se pueden enviar parámetros al documento (se utiliza GET a menos que los datos se manden en forma de objeto):

jQuery(":button#login").click(function () {  
  $("#mensaje").load("login.php", {nombre: "zootropo", pass: "contraseña"});  
});

e indicar una función a ejecutar cuando se termine de llevar a cabo la petición

jQuery(":button#login").click(function () {  
  jQuery("#mensaje").load("login.php", {nombre: "zootropo", pass: "contraseña"}, function(responseText, textStatus, XMLHttpRequest) {  
    alert("cargado");  
    });  
});

También se pueden utilizar los métodos get y post del objeto jQuery, en cuyo caso se nos devolverá unos ciertos datos con los que nosotros mismos tendremos que trabajar para generar la respuesta y mostrarla en nuestro documento actual:

jQuery.get("login.php", {nombre: "zootropo", pass:"contraseña"},  
  function(data, textStatus, XMLHttpRequest){  
    jQuery("#mensaje").html("Han devuelto: " + data);  
  });  
 
jQuery.post("login.php", {nombre: "zootropo", pass:"contraseña"},  
  function(data, textStatus, XMLHttpRequest){  
    jQuery("#mensaje").html("Han devuelto: " + data);  
  });

Si la respuesta del servidor va a estar en formato JSON (JavaScript Object Notation), muy utilizado actualmente, podemos utilizar el método jQuery.getJSON(), al que se le pasa la URL de la petición y, opcionalmente, cualquier parámetro que se necesite, además de una función de callback que ejecutar cuando se termine con la petición. Este método se encargará de parsear la estructura del objeto JSON devuelta utilizando jQuery.parseJSON(), objeto que estará disponible como primer parámetro de la función de callback.

$.getJSON('tareas.php', function(data, textStatus){  
          $.each(data, function(i, tarea){  
            $("<li></li>").html(tarea.nombre + " - " + tarea.hora).appendTo("ul#tareas");  
          });  
        });

El código de este tareas.php podría tener este aspecto:

< ?php  
header('Content-type: text/javascript');  
 
$bbdd = new mysqli('servidor.com', 'usuario', 'pass', 'tareas');  
 
$query = 'SELECT * FROM tareas';  
$tareas = array();  
if($resultado = $bbdd->query($query))  
  while($tarea = $resultado->fetch_object())  
    $tareas[] = $tarea;  
 
$bbdd->close();  
 
echo json_encode($tareas);  
?>

vía: http://mundogeek.net/archivos/2010/04/21/tutorial-rapido-de-jquery/

• Apache Worker

Incluido desde Apache 2.0. Utiliza menos memoria y tiene un mejor rendimiento. Se lanzan múltiples procesos y cada uno de estos pueden correr múltiples threads.

• Apache Prefork

Es el MPM por defecto en Apache 1.3 y Apache 2.0. Es el instalado por defecto si hacemos uso de mod_php, ya que algunos módulos de PHP no son “thread safe”. Tiene un rendimiento ligeramente peor que Worker y más consumo de memoria, pero se considera más seguro y estable. En este MPM se lanzan múltiples procesos y se ejecuta un thread por proceso.

Lo lógico sería utilizar Worker, pero vamos a basarnos en el típico ejemplo LAMP que incluye el soporte mod_php, aunque esto no sea lo más óptimo. Por dicha razón vamos a ver como deberíamos ajustar la configuración para un Prefork.

El principal parámetro hardware de nuestros frontales Apache será la memoria RAM. Aquí está todo claro, a más memoria RAM, más procesos se podrán lanzar y más peticiones se podrán atender. Por lo tanto, en primer lugar debemos saber el número de procesos que nuestra máquina puede llegar a soportar. Para ello podemos hacer uso de esta fórmula:

MaxClients = (RAM - tamaño_del_resto_de_procesos)/(tamaño_de_procesos_apache)

Para conocer el tamaño de los procesos de Apache podemos ejecutar un ps:

ps -ylC httpd --sort:rss

Es recomendable que los procesos de Apache ya hayan atentido algunas peticiones, de forma que podamos observar no solo el valor mínimo de memoria de los procesos, si no el máximo que alcanzan una vez atendidas las peticiones.

Entonces, pongamos el siguiente ejemplo:

• El mayor tamaño que alcanza un proceso de Apache son 98 megas
• El resto de procesos ocupan 250 megas.
• Tenemos 32 gigas de ram

MaxClients = (32768 - 250) / 98

Por lo tanto, el número máximo de procesos Apache que se pueden arrancar son 331. Hay que tener en cuenta que esto sería un límite teórico antes de empezar a swapear. Para no estar rozando el límite recomiendo poner algo menos, 310. Con esto definimos claramente cuantos procesos podrán lanzarse para atender a las peticiones y será en función de la RAM que tengamos. Si reducimos el tamaño de los procesos de Apache podremos también aumentar el número de procesos que se pueden lanzar. Para ello, lo mejor es desactivar todos los módulos que no se vayan a utilizar.

En caso de recibir más peticiones de las que pueda atender las encolará y evitaremos que comience a swapear tirando la máquina abajo. Esta cola está definida por el parámetro ListenBacklog que tiene como valor por defecto 511. Como bien dice el manual de Apache, no se recomienda cambiar este valor a no ser que estemos sufriendo un ataque de flood SYN.

Además, tenemos que configurar los siguientes valores:

• StartServers

Indica el número de procesos que arranca al iniciar el servicio. Este valor no se debe poner demasiado elevado o ralentizará mucho la puesta en marcha del servicio. Como modificar este valor no da ninguna mejora de rendimiento, lo dejamos en el valor por defecto 5.

• MinSpareServers

Son el número de procesos IDLE que deben existir como mínimo en el servidor. Según vayan recibiendo peticiones Apache lanzará nuevos procesos para mantener este número mínimo. De esta forma los nuevos usuarios que se conecten a la web no tendrán que esperar a que Apache lance un proceso para ellos, si no que siempre se garantizará un mínimo, mejorando la respuesta del servicio. Aún así no es recomendado poner un valor exageradamente grande. Con 30 es suficiente.

• MaxSpareServers

Es el número máximo de procesos IDLE que existirán en el servidor. Si este número se supera, Apache empezará a cerrar procesos. Poner un valor que sea el doble de MinSpareServers suele dar buenos resultados, siempre y cuando MinSpareServers no tenga un valor absurdamente grande. 60 será suficiente.

• MaxRequestsPerChild

Con el fin de evitar posibles posibles fugas de memoria en la programación, se suele establecer el número de peticiones máximas que atenderá un proceso antes de morir. Poner un valor pequeño reducirá el rendimiento, ya que Apache tendrá que estár continuamente matando y lanzando nuevos procesos. Un valor recomendado por defecto es 100000, el cual es correcto.

Por lo tanto, el tuning quedaría de la siguiente manera:

StartServer 5
MinSpareServer 30
MaxSpareServer 60
MaxClients 310
MaxRequestsPerChild 10000

Además es recomendable bajar los timeous para evitar tener procesos sin hacer nada.

Timeout 30

Timeout esperará 30 segundos antes de cerrar una petición. Esperará para tres cosas (copy/paste del manual):

1- La cantidad de tiempo que tarda en recibir una petición GET.

2- La cantidad de tiempo entre la recepción de paquetes TCP packets en una petición POST o PUT.

3- La cantidad de tiempo entre ACKs en transmisiones de paquetes TCP en las respuestas.

Por defecto el valor es 300, el cual bajo mi experiencia es realmente exágerado.

KeepAliveTimeout 5

Muchos clientes no ven con buenos ojos la bajada del KeepAliveTimeout, pero tiene una buena razón. En prefork, una petición se queda asociada a un proceso durante todo el KeepAlive, por lo que tener un valor muy alto terminará por agotar las conexiones en algunos picos de carga. En algunos casos incluso es posible aumentar el rendimiento deshabilitando por completo el KeepAlive, pero eso ya dependerá de la página y la programación de la misma. El valor por defecto es 15.

Con estos consejos tendrás una configuración mucho mejor que la de defecto y completamente ajustada a tu máquina. Si ves que el número máximo de clientes es muy poco y no puedes atender todas las peticiones, no lo aumentes a lo loco, mete más máquinas en el balanceador o aumenta la RAM. Lo más importante como ya he indicado es poner valores realistas. En sistemas con mucha carga evitar la swap es la diferencia entre poder acceder a la máquina por SSH o tener que ir al centro de datos a dar un botonazo.

Además es importante tunear los frontales teniendo en cuenta el backend. Si tu MySQL no puede gestionar por memoria más de 200 conexiones, es una estupidez poner en apache 310. Todo tiene que estar equilibrado.

vía: http://miguelangelnieto.net/?action=view&url=tuning-de-apache-con-cabeza

Algo realmente útil para cuando necesitamos que sólo haya una ejecución del mismo script (por ejemplo, para copias de seguridad automáticas llamadas mediante cron).

Lógicamente, se incluye al principio del script.

if pidof -x $(basename $0) > /dev/null; then
  for p in $(pidof -x $(basename $0)); do
    if [ $p -ne $$ ]; then
      echo "El script $0 ya se está ejecutando. Saliendo..."
      exit
    fi
  done
fi

OpenSSH permite esto desde su versión 4.3, y es tan sencillo que en la página man de ssh se describe en apenas 5 párrafos (sección SSH-BASED VIRTUAL PRIVATE NETWORKS). La parte no tan sencilla es la de gestionar las rutas.

Además, como digo, esta configuración es adecuada para una red improvisada y no como solución definitiva porque, como indica la propia página de manual, la sobrecarga por el protocolo SSH es muy alta:

Since an SSH-based setup entails a fair amount of overhead, it may be
more suited to temporary setups, such as for wireless VPNs. More
permanent VPNs are better provided by tools such as ipsecctl(8) and
isakmpd(8).

Vamos a trabajar con el escenario mostrado en el siguiente esquema:

Tenemos dos oficinas de una misma empresa conectadas internamente y a Internet con el típico router/switch ADSL que tiene una única IP pública y que hace NAT para compartirla. Ahora queremos interconectarlas, de forma que todos los nodos de una oficina accedan a los de la otra y viceversa.

En la primera de ellas se usa la subred 192.168.10.0/24 para la red local, y en la segunda, la subred 172.16.20.0/24. En la configuración del NAT del router ADSL de la segunda oficina abrimos el puerto 22 de SSH y lo redirigimos hacia el nodo servidorssh172 (172.16.20.2), que está ejecutando el sshd de OpenSSH. La IP pública de la segunda oficina debería ser fija o tal vez se podría usar un servicio de DNS dinámico. El nodo clientessh192 (192.168.10.2) de la primera red establecerá una conexión OpenSSH con el nodo servidorssh172 (172.16.20.2) de la segunda red usando la IP pública de la segunda oficina.

Establecemos la conexión SSH especificando la opción “-w 0:1“, con la que estamos solicitando que se cree un túnel entre el interface virtual tun0 del cliente SSH y el interfaz virtual tun1 del servidor SSH (interfaces TUN/TAP):

[clientessh192]$ ssh -w 0:1 root@ip-publica-red172

Sólo los sistemas operativos que soporten este tipo de interfaces virtuales podrán crear VPNs con OpenSSH. Por ejemplo, usando el OpenSSH de Cywin en Windows nos encontraremos con el siguiente error:

ssh -w 0:1 root@ip-publica-red172
Tunnel interfaces are not supported on this platform
Tunnel device open failed.
Could not request tunnel forwarding.

Como en general sólo el usuario root puede crear interfaces TUN, necesitaremos que el usuario que lanza el ssh en el cliente sea root y que se conecte al servidor también como root. Además, en el servidor, el demonio sshdtiene que tener habilitada la opción PermitTunnel en el fichero /etc/ssh/sshd_config.

Si la conexión se ha establecido correctamente, encontraremos un nuevo interfaz en cada extremo (a partir de ahora suponemos que ambos extremos de la conexión SSH son Linux; en otros sistemas operativos que soporten esta característica los comandos serían diferentes):

[clientessh192]$ ifconfig tun0
tun0      Link encap:UNSPEC  HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00
          POINTOPOINT NOARP 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:500
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)
 
[servidorssh172]$ ifconfig tun1
tun1      Link encap:UNSPEC  HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00
          POINTOPOINT NOARP 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:500
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

A los que les podemos asignar una IP de la misma subred (10.0.0.0/30), puesto que están virtualmente conectadas:

[clientessh192]$ ifconfig tun0 10.0.0.1 netmask 255.255.255.252
[servidorssh172]$ ifconfig tun1 10.0.0.2 netmask 255.255.255.252

y ya podemos verificar que tenemos conectividad entre las máquinas:

[clientessh192]$ ping 10.0.0.2
PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
64 bytes from 10.0.0.2: icmp_seq=1 ttl=64 time=86.3 ms
64 bytes from 10.0.0.2: icmp_seq=2 ttl=64 time=98.1 ms
64 bytes from 10.0.0.2: icmp_seq=3 ttl=64 time=61.2 ms
 
[servidorssh172]$ ping 10.0.0.1
PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=96.2 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=88.3 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=81.6 ms

Ahora introducimos rutas en cada uno de estos nodos para que sepan llegar a la otra red:

[clientessh192]$ route add -net 172.16.20.0 netmask 255.255.255.0 gateway 10.0.0.2
 
[servidorssh172]$ route add -net 192.168.10.0 netmask 255.255.255.0 gateway 10.0.0.1

Si el escenario no fuera exactamente el mostrado inicialmente, sino que clientessh192 tuviera conectividad directa con servidorssh172 y no hubiera una IP pública involucrada, con estas rutas podríamos tener un problema, y es que estas rutas podrían cortar inmediatamente el SSH que mantiene el túnel. Éste es un problema real cuando, por ejemplo, tenemos una red aislada dentro de una empresa cuyos nodos pueden salir hacia fuera usando NAT, pero que no es posible entrar a ella desde fuera. Podemos hacer fácilmente un SSH saliente pero no podemos establecer conexiones entrantes, algo que queremos solucionar improvisadamente con una VPN por OpenSSH. Las rutas romperán la conexión SSH.

Usando los sistemas de nuestro ejemplo inicial: Supongamos que clientessh192 puede establecer conexión directa con servidorssh172 habiendo sólo un router que hace NAT entre ambos. Esto funciona porque en clientessh192 hay una ruta específica hacia 172.16.20/24 o porque su ruta por defecto ya va hacia el router que hace NAT. En el momento en que pongamos la ruta propuesta, el SSH se cortará instantáneamente y el túnel se perderá (de hecho, la conexión se queda colgada, porque los paquetes los enviamos por el túnel SSH, pero a su vez los paquetes de SSH también los mandamos por el túnel, causando un tremendo lío). En cambio, la ruta en servidorssh172 no causaría problemas, porque en 172.16.20.0/24 no saben nada de la red 192.168.10.0/24, ya que está NATeada.

En estos casos, una solución que he encontrado es hacer rutas más específicas (con máscaras más pequeñas) que no incluyan a los nodos involucrados en el SSH. Por ejemplo, si el rango de nodos a los que queremos acceder es 172.16.10.35-75, podríamos poner estas rutas en clientessh192 que no afectan a cómo se llega a 172.16.20.2:

[clientessh192]$ route add -net 172.16.20.32 netmask 255.255.255.224 gateway 10.0.0.2
 
[clientessh192]$ route add -net 172.16.20.64 netmask 255.255.255.224 gateway 10.0.0.2

El peor de los casos sería tener que llegar a IPs muy cercanas a las de servidorssh172, como 172.16.20.1, 172.16.20.3 o 172.16.20.4. En tal caso, tendríamos que poner rutas con máscaras muy grandes (/30, /31) y rutas directas a hosts. Las siguientes rutas permitirían llegar a .1, .3, .4 y .5:

[clientessh192]$ route add -host 172.16.20.1 gateway 10.0.0.2
 
[clientessh192]$ route add -host 172.16.20.3 gateway 10.0.0.2
 
[clientessh192]$ route add -net 172.16.20.4 netmask 255.255.255.254 gateway 10.0.0.2

Pero si las rutas no crean otras complicaciones, como en el caso expuesto inicialmente, desde este momento, los paquetes IP de clientessh192 y de servidorssh172 podrían llegar a los nodos de la otra red, pero aquellos nodos no sabrían enviar sus paquetes de vuelta, puesto que no tienen una ruta para ello. Por tanto, en todos los nodos de la red 192.168.10.0/24 habría que poner esta ruta:

• Sistemas Linux:

route add -net 172.16.20.0 netmask 255.255.255.0 gateway 192.168.10.2

• Sistemas Windows:

C:>route add 172.16.20.0 mask 255.255.255.0 192.168.10.2

En todos los nodos de la red 172.16.20.0/24 habría que poner esta ruta:

• Sistemas Linux:

route add -net 192.168.10.0 netmask 255.255.255.0 gateway 172.16.20.2

• Sistemas Windows:

C:>route add 192.168.10.0 mask 255.255.255.0 172.16.20.2

En Linux podemos verificar las rutas introducidas con “netstat -rn“, en Windows con “route print“.

Pero además, tenemos que configurar que tanto el cliente como el servidor de SSH permitan que los paquetes IP vayan de unos interfaces a otros (IP Forwarding). Si queremos hacerlo sólo temporalmente (que es lo adecuado si estamos montando esta red para una necesidad puntual), ejecutaremos en ambos sistemas:

echo 1 > /proc/sys/net/ipv4/ip_forward

Si quisiéramos que esta configuración sobreviviera a reinicios de la máquina, editaríamos /etc/sysctl.conf y pondríamos:

net.ipv4.ip_forward = 1

Podemos pedirle al kernel que relea este fichero haciendo “sysctl -p“.

Además, es posible que las reglas de iptables impidan el tráfico. Podemos ajustarlas a medida o, si conocemos los riesgos de seguridad que asumimos, podemos eliminar cualquier restricción ejecutando en ambos extremos:

iptables -F

A partir de este punto, todos los nodos de cada una de las redes será capaz de comunicarse libremente con todos los nodos de la otra red. Podemos verificar esto, por ejemplo, con el comando traceroute de Linux o el tracert de Windows:

• Sistema Windows en la red 192.168.10.0/24 llegando al nodo sistema101.red172.net (172.16.20.101) de la red 172.16.20.0/24:

C:>tracert sistema101.red172.net
 
Tracing route to sistema101.red172.net [172.16.20.101]
over a maximum of 30 hops:
 
  1    <1 ms    <1 ms    <1 ms  clientessh192.red192.net [192.168.10.2]
  2    93 ms    81 ms    82 ms  10.0.0.2
  3    83 ms    80 ms    81 ms  sistema101.red172.net [172.16.20.101]
 
Trace complete.

• Sistema Linux en la red 172.16.20.0/24 llegando al nodo sistema35.red192.net (192.169.10.35) de la red 192.168.10.0/24:

traceroute sistema35.red192.net
traceroute to sistema35.red192.net (192.169.10.35), 30 hops max, 38 byte packets
 1  servidorssh172.red172.net (172.16.20.2)  0.358 ms  0.295 ms  0.201 ms
 2  10.0.0.1 (10.0.0.1)  80.756 ms  80.443 ms  81.502 ms
 3  sistema35.red192.net (192.169.10.35)  79.250 ms  81.179 ms  81.858 ms

Para finalizar, una curiosidad: El vetusto VPN HOWTO muestra cómo crear una VPN mediante SSH y PPP.

via VPN con OpenSSH

Limitar el espacio de una carpeta sin usar cuotas en Samba.

Hace poco me consultaron si se podía limitar el espacio de una carpeta Samba (samba share) sin tener control de usuarios es decir hay una carpeta por usuario que esta a su vez es ‘mapeada’ a su estación de trabajo (que corre windows) pero todos los usuarios usan el mismo usuario y el mismo password para acceder cada una de sus carpetas. La pregunta me dejo cabezón, yo nunca trabaje con Samba pero se que debe de haber forma de hacer esto. Por ahora me dispuse a crear un script que le ayudara.

El script lee un archivo de texto separado por comas el cual tiene dos columnas una para el nombre del usuario y la cantidad de Megabytes que se le va a asignar a cada usuario. Usando el comando dd el script crear archivos que son formateados como EXT3 y seguidamente los monta. El archivo de texto plano luce así:

cat /tmp/usuarios.txt
maria.perez,5
arnaldo.hernandez,5
gustavo.flores,10
jesus.boss,5
marta.hernandez,5
wilkneman.pascoski,5
tatiana.siu,5
alexandra.delarosa,5

Aparte de crear, formatear y montar estos archivos el script también crea la configuración base que se le va a anexar a al smb.conf con el siguiente formato para cada usuario:

[alexandra.delarosa]
comment = alexandra.delarosa with 5MB
path = /mnt/smb_discs/alexandra.delarosa
read only = no
browseable = yes
guest ok = yes
 
[arnaldo.hernandez]
comment = arnaldo.hernandez with 5MB
path = /mnt/smb_discs/arnaldo.hernandez
read only = no
browseable = yes
guest ok = yes
 
[gustavo.flores]
comment = gustavo.flores with 10MB
path = /mnt/smb_discs/gustavo.flores
read only = no
browseable = yes
guest ok = yes

Luego seria cuestión de retocar el /etc/Samba/smb.conf y reiniciar el servicio, re-mapear esto Samba share a los usuarios y listo.

Aquí esta el script:

LISTAUSUARIOS=`cat /tmp/usuarios.txt|sort`
RUTA_DISCOS="/smb_disks/smb_drives"
MOUNT_SMB="/mnt/smb_discs"
TMPSAMBACONF="/tmp/samba.virt.conf"
echo > $TMPSAMBACONF
mkdir -p `echo $RUTA_DISCOS`
for X in $LISTAUSUARIOS
do echo $X | awk -F , '{print "asignando " $2 "MB a usuario "$1}'
USUARIO=`echo $X | awk -F , '{print $1}'`
PRE_ESPACIO=`echo $X | awk -F , '{print $2}'`
let ESPACIO=`echo $PRE_ESPACIO`*1024
dd if=/dev/zero of=$RUTA_DISCOS/$USUARIO.img bs=1024 count=$ESPACIO
/sbin/mke2fs -L $USUARIO -j $RUTA_DISCOS/$USUARIO.img
mkdir -p $MOUNT_SMB/$USUARIO
mount -t ext3 $RUTA_DISCOS/$USUARIO.img -o loop $MOUNT_SMB/$USUARIO
echo "[$USUARIO]
comment = `echo $USUARIO" with "$PRE_ESPACIO"MB"`
path = /mnt/smb_discs/$USUARIO
read only = no
browseable = yes
guest ok = yes
" >> $TMPSAMBACONF
done
echo "espacio usado en $RUTA_DISCOS: "
du -smh $RUTA_DISCOS/*.img
du -smh $RUTA_DISCOS/
mount -l | grep $MOUNT_SMB
echo "CHECK $TMPSAMBACONF AND ADD IT TO YOUR /etc/samba/smb.conf"

Como mencione anteriormente, yo nunca he trabajado con Samba en ambiente de producción yo practique o jugué un poco con Samba hace unos 5 años. este script no incluye configuraciones para estos Samba shares que proporcionen algo de seguridad. Si alguien tiene sugerencias pueden dejarlas en los comentarios.

vía Limitar el espacio de una carpeta sin usar cuotas en Samba. | Linux y el NSLU2.

Los archivos swap o particiones swap son archivos que residen en bajo el directorio / (Root Directory) o particiones dedicadas a expandir el espacio para la paginación de memoria (respectivamente). El sistema operativo mantiene el control sobre qué páginas están en memoria principal (RAM) y cuáles no; lleva un registro en la tabla de paginación y le da una prioridad mas alta a el espacio que reside en la RAM. Este espacio permite hacer creer a los programas que tienen más memoria que la disponible realmente.

Es el sistema operativo el encargado de mover procesos inactivos para la swap liberando espacio de esta forma espacio en RAM. Este procedimiento de intercambio se lleva a cabo en las dos direcciones dependiendo de las necesidades.

Como asigno prioridades a mis archivos o particiones swap?

En /etc/fstab podemos usar el parámetro “pri” y un numero entre 0 y 32767 justo después de sw. Entre mas alto sea el valor de pri mas alta sera su prioridad y mas rápido sera usado. Con Kernels nuevos si tenemos varias particiones swap podemos usarlas en paralelo como si fuese un RAID 0 asignándoles la misma prioridad.

Particiones swap trabajando como RAID CERO?

El parámetro pri no solo permite paralizar el acceso a swap sino también permite asignar mayor prioridad a discos mas rápidos, sectores de disco que son mas rápidos (los que están al inicio del disco son mas rápidos que los que están al final) y hacer un mejor uso de nuestros recursos como lo podemos ver en este ejemplo:

/dev/sda2    none  swap  sw,pri=4    0    0
/dev/sdb2    none  swap  sw,pri=4    0    0
/dev/sdc2    none  swap  sw,pri=4    0    0
/dev/sdd2    none  swap  sw,pri=3    0    0
/swapfile    none  swap  sw,pri=2    0    0

vía Archivos swap y paralelización de espacio swap | Linux y el NSLU2.

Manejo habitual de LVM (los comandos los proporciona el paquete lvm2 que se instala por dependencias):

• Para añadir una partición al disco virtual, primero tenemos que formatearla con fdisk y marcarla como 8e (Linux LVM). Después añadiremos la partición al disco virtual:

  vgextend disco_virtual /dev/hdc1

• Para aumentar el tamaño de una partición virtual, primero aumentaremos el tamaño de la partición:

  lvextend -L+120G /dev/mapper/disco_virtual-home

  y luego aumentaremos el tamaño del filesystem:

  umount /dev/mapper/disco_virtual-home resize2fs /dev/mapper/disco_virtual-home mount /dev/mapper/disco_virtual-home /home

• Para reducir el tamaño de una partición virtual, primero reduciremos el tamaño del filesystem:

  umount /dev/mapper/disco_virtual-home resize2fs /dev/mapper/disco_virtual-home 80G mount /dev/mapper/disco_virtual-home /home

  y luego reduciremos el tamaño de la partición:

  lvreduce -L-120G /dev/mapper/disco_virtual-home

• Para quitar una partición del disco virtual, primero moveremos los datos que contiene a otras particiones con el comando:

  pvmove /dev/hdc1

  y luego quitaremos la partición:

  vgreduce disco_virtual /dev/hdc1

  Ya podemos quitar físicamente la unidad.

vía LVM (volumenes logicos) en Linux | Estrellate y Arde.