Otras veces ya hemos visto como realizar una instalación de Apache con PHP y eAccelerator, una vez instalado los ficheros ejecutables importantes son:

• apachectl: Mediante este script podremos:
  • Gestionar el arranque y parada del daemon (start/stop)
  • Comprobar la configuración (configtest):

    # /usr/local/apache22/bin/apachectl configtest
    Syntax OK

  • Recargar la configuración en caliente, sin apagar el daemon (graceful)
• httpd: Binario del daemon, con dicho fichero podemos:
  • Indicar que fichero de configuración cargar (opción -f)
  • Ver el listado de módulos que carga (opción -M):

    # /usr/local/apache22/bin/httpd -M
    Loaded Modules:
     core_module (static)
    (...)
     jrun_module (shared)

  • Al igual que con apachectl, comprobar la configuración con la opción -t:

    # /usr/local/apache22/bin/httpd -t
    Syntax OK

  • Ver el resumen de configuración de los VirtualHosts con la opción -S:

    # /usr/local/apache22/bin/httpd -S
    VirtualHost configuration:
    wildcard NameVirtualHosts and _default_ servers:
    *:80                   is a NameVirtualHost
             default server shuvak.systemadmin.es (/usr/local/apache22/conf/extra/httpd-vhosts.conf:7)
             port 80 namevhost shuvak.systemadmin.es (/usr/local/apache22/conf/extra/httpd-vhosts.conf:7)
             port 80 namevhost systemadmin.es (/usr/local/apache22/conf/extra/vhosts/systemadmin.es.conf:1)
             port 80 namevhost foro.systemadmin.es (/usr/local/apache22/conf/extra/vhosts/foro.systemadmin.es.conf:1)
    Syntax OK

Un ejemplo de configuración típica de un VirtualHost sería la siguiente:

<VirtualHost *:80>
        DocumentRoot "/var/www/systemadmin.es/htdocs"
        DirectoryIndex index.php
        ServerName systemadmin.es
        ServerAlias foro.systemadmin.es

        <Directory /var/www/systemadmin.es/htdocs>
            Options FollowSymLinks
            AllowOverride all
            Order deny,allow
            Allow from all
        </Directory>

        ErrorLog  "| /usr/local/sbin/cronolog -S /var/www/systemadmin.es/logs/current.error.log /var/www/systemadmin.es/logs/%Y/%m/%d/error.log"
        CustomLog "| /usr/local/sbin/cronolog -S /var/www/systemadmin.es/logs/current.custom.log /var/www/systemadmin.es/logs/%Y/%m/%d/custom.log" combined

</VirtualHost>

Las directivas importantes son:

• DocumentRoot: Directorio base desde el cual serviremos el contenido. Deberemos acompañarlo de la directiva Directory para establecer si se puede servir o no su contenido
• DirectoryIndex: Cuando se intente servir la raíz o cualquier directorio (sin especificar fichero), cual se debería servir. Típicamente se usa index.algo, pero podría ser cualquier fichero. Esta directiva indica que fichero servir y en que orden de prioridad. Por ejemplo:

  DirectoryIndex index.php index.html index.htm

  Primero miraría si existe un fichero index.php, en caso que no exista buscaría el siguiente (index.html) y así el listado que indiquemos. En caso que no exista ninguno, se serviría un 404

• ServerName y ServerAlias: Nombres a los que responde según el header Host. Se pueden especificar wildcards tanto pode delante (*.systemadmin.es) como por detrás (webmail.*). La diferencia entre ServerName y ServerAlias a la practica tiene poca importancia.

En cuanto a la gestión de logs, personalmente uso cronolog ya que una vez configurado cómo queremos almacenar los logs no deberemos hacer mantenimiento a no se que queramos eliminar los antiguos. Para ello suelo emplear un simple script que haga limpieza:

#!/bin/bash
for i in $(find /var/www/ -maxdepth 2 -iname logs);
do

        #eliminacion de los mas antiguos de 10 dias
        find $i -mtime +10 -type f -exec rm {} \;

        #eliminacion de directios vacios
        find $i -empty -type d -exec rmdir {} \; 2>/dev/null

        #compresión de logs ya rotados
        find $i -type f -iname \*\.log -mtime +2 -exec gzip {} \;

done

Deberemos adaptar el find del for para que encuentre los directorios raíz dónde tenemos los logs.

Para conocer el estado del Apache existe el modulo mod_status, que nos indica que esta haciendo dicho daemon. Generalmente se instala en /server-staus con acceso limitado por IP de origen.

En el scoreboard veremos los estado del los apachitos (procesos apache) y podremos ver si existe algún problema con algún VirtualHost. Típicamente podremos ver:

• Se nos llena el scoreboard de W: Cuando un slot esta en estado W significa que esta contestando, pero si vemos que se nos acumulan W posiblemente esta contestando muy lentamente por algún motivo o bien simplemente se queda colgado. Generalmente indica problemas en la base de datos.Si habilitamos la opción

  ExtendedStatus On

  Tendremos un listado de todas las peticiones y su estado, para cuanto tiempo lleva un slot en el estado actual deberemos fijarnos en la columna SS. Por lo tanto, las peticiones en estado W que tenga el SS alto son las primeras que deberemos investigar. Evidentemente, si servimos contenido estático (un mp3) es lógico que tarde en ser entregado y por lo tanto que su SS sea alto.

• Se nos llena el scoreboard de K: Tendremos que ver si nos interesa reducir el tiempo de KeepAlive de las conexiones. Por defecto lo tenemos a 5 segundos, pero lo podemos dejar en 1 o 2 segundos según la aplicación.

En otra ocasión ya hablamos de en que debemos fijarnos para entender el problema que tenga un entorno LAMP

Otra cosa a tener en cuenta es la diferencia entre ServerLimit y MaxClients: ServerLimit es el límite fijo que no puede ser modificado mediante una recarga de configuración (graceful) mientras que MaxClients es el límite actual.

Actualmente mod_status no muestra los slots de Apache que quedan deshabilitados por la directiva MaxClients, por lo que nos puede dar pie a error al suponerlos libres. En su momento hice un patch para evitar esto y será incluido en la próxima release de Apache (2.4), actualmente ya se encuentra disponible en la versión beta desde la versión 2.3.11.

Nuestra fuente: Systemadmin

$twitpic = new TwitPic($api_key, $consumer_key, $consumer_secret, $oauth_token, $oauth_secret);
try {
  /*
  * Retrieves all images where the user is facetagged
  */
  $user = $twitpic->faces->show(array('user'=>'meltingice'));
  print_r($user->images);

  $media = $twitpic->media->show(array('id'=>1234));
  echo $media->message;

  $user = $twitpic->users->show(array('username'=>'meltingice'), array('process'=>false, 'format'=>'xml'));
  echo $user; // raw XML response data

  /*
  * Uploads an image to TwitPic
  */
  $resp = $twitpic->upload(array('media'=>'path/to/file.jpg', 'message'=>'This is an example'));
  print_r($resp);

  /*
  * Uploads an image to TwitPic AND posts a tweet
  * to Twitter.
  *
  * NOTE: this still uses v2 of the TwitPic API. This means that the code makes 2 separate
  * requests: one to TwitPic for the image, and one to Twitter for the tweet. Because of this,
  * understand this call may take a bit longer than simply uploading the image.
  */
  $resp = $twitpic->uploadAndPost(array('media'=>'path/to/file.jpg', 'message'=>'Another example'));
  print_r($resp);

} catch (TwitPicAPIException $e) {
  echo $e->getMessage();
}

TwitPic API for PHP

Nuestra fuente: Sentidoweb

Os paso un script que sube el fichero a Google Docs dentro de una carpeta y acto seguido lo exporta a otro formato, en este caso subo un PPT y lo convierto en PDF (me hubiese encantado que fuera a HTML pero no acepta esa opción).

// Datos de login a la API de Google
$clientlogin_url = "https://www.google.com/accounts/ClientLogin";
$clientlogin_post = array(
    "accountType" => "GOOGLE",
    "Email" => "miemail@gmail.com",
    "Passwd" => "mipassword",
    "service" => "writely",
    "source" => "WPDOCS"
);

// Inicializamos el CURL
$curl = curl_init($clientlogin_url);

// Obtenemos el string de autenticación
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $clientlogin_post);
curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($curl);
preg_match("/Auth=([a-z0-9_\-]+)/i", $response, $matches);
$auth = $matches[1];

// Cabeceras de autenticación
$headers = array(
    "Authorization: GoogleLogin auth=" . $auth,
    "GData-Version: 3.0",
);

// Recuperamos los ficheros y carpetas que tenemos en Google Docs para no crear dos veces la misma carpeta
curl_setopt($curl, CURLOPT_URL, "http://docs.google.com/feeds/default/private/full?showfolders=true");
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POST, false);
$listado = curl_exec($curl);
$nombre_carpeta = 'WPDOCS';

// Si no se ha creado la carpeta, la creamos
if (strpos($listado, '<title>'.$nombre_carpeta.'</title>') === FALSE) {
  // Make the request
  $h = array_merge($headers,array('Content-Type: application/atom+xml'));
  $xml = '<?xml version="1.0" encoding="UTF-8"?><entry xmlns="http://www.w3.org/2005/Atom"><category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/docs/2007#folder"/><title>'.$nombre_carpeta.'</title></entry>';
  curl_setopt($curl, CURLOPT_URL, "http://docs.google.com/feeds/default/private/full");
  curl_setopt($curl, CURLOPT_HTTPHEADER, $h);
  curl_setopt($curl, CURLOPT_POSTFIELDS, $xml);
  curl_setopt($curl, CURLOPT_POST, true);

  $response = curl_exec($curl);
  $response = simplexml_load_string($response);
  $id_folder = $response->id;
} else {
  // Recuperamos la ID de la carpeta creada anteriormente
  preg_match("#<title>$nombre_carpeta</title><content type='application/atom\+xml;type=feed' src='([^']+)'#", $listado, $m);
  $id_folder = $m[1];
}

// Subimos el PPT
$h = array_merge($headers,array('Content-Type: application/vnd.ms-powerpoint', 'Slug: fichero'));
$filepath='/path/fichero.ppt';
$data=((fread(fopen($filepath, "rb"), filesize($filepath))));
curl_setopt($curl, CURLOPT_URL, "http://docs.google.com/feeds/default/private/full");
curl_setopt($curl, CURLOPT_HTTPHEADER, $h);
curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
curl_setopt($curl, CURLOPT_POST, true);
$response = curl_exec($curl);
$response = simplexml_load_string($response);
$id_doc = $response->id;

// Limpiamos los IDs de los ficheros devueltos por Google, solo nos interesa del %3A para adelante
preg_match('/%3A(.+)/', $id_doc, $m);
$id_doc = $m[1];
preg_match('/%3A(.+)/', $id_folder, $m);
$id_folder = $m[1];

// Lo movemos a la carpeta
$h = array_merge($headers,array('Content-Type: application/atom+xml'));
$data = '<?xml version=\'1.0\' encoding=\'UTF-8\'?><entry xmlns="http://www.w3.org/2005/Atom"><id>https://docs.google.com/feeds/default/private/full/document%3A'.$id_doc.'</id></entry>';
curl_setopt($curl, CURLOPT_URL, "http://docs.google.com/feeds/default/private/full/folder%3A".$id_folder);
curl_setopt($curl, CURLOPT_HTTPHEADER, $h);
curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
curl_setopt($curl, CURLOPT_POST, true);
$response = curl_exec($curl);

//header('Content-type: text/xml');
//echo $response;
// Parse the response

// Exportamos a HTML
curl_setopt($curl, CURLOPT_URL, "http://docs.google.com/feeds/download/presentations/Export?docID=$id_doc&exportFormat=pdf");
curl_setopt($curl, CURLOPT_HTTPHEADER, $h);
curl_setopt($curl, CURLOPT_POST, false);
header('Content-type: application/pdf');
echo curl_exec($curl);

curl_close($curl);

Nuestra fuente: Sentidoweb

#!/bin/bash
wget http://ejemplo.com/scripts/ejemplo.php
rm ejemplo.php

Pero no hace falta tenerlo en el servidor web para poder ejecutarlo, por ejemplo:

<?php
        echo "hola desde PHP\n";
?>

Si usamos el comando php desde linea de comandos y le pasamos el script lo estaremos ejecutando:

# php ejemplo1.php
hola desde PHP

Si en el script además le añadimos el shebang con el path completo al binario dephp:

#!/usr/local/bin/php
<?php
        echo "hola desde PHP\n";
?>

Podremos simplemente darle permisos de ejecución y ejecutarlo:

# chmod +x ejemplo2.php
# ./ejemplo2.php
hola desde PHP

Nuestra fuente: systemadmin.es

El resto es fácil, acceso mediante CURL y listo:

    define('GOOGLE_API_KEY', '[insert your key here]');
    define('GOOGLE_ENDPOINT', 'https://www.googleapis.com/urlshortener/v1');

    function shortenUrl($longUrl)
    {
        // initialize the cURL connection
        $ch = curl_init(
            sprintf('%s/url?key=%s', GOOGLE_ENDPOINT, GOOGLE_API_KEY)
        );

        // tell cURL to return the data rather than outputting it
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        // create the data to be encoded into JSON
        $requestData = array(
            'longUrl' => $longUrl
        );

        // change the request type to POST
        curl_setopt($ch, CURLOPT_POST, true);

        // set the form content type for JSON data
        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-type: application/json'));

        // set the post body to encoded JSON data
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($requestData));

        // perform the request
        $result = curl_exec($ch);
        curl_close($ch);

        // decode and return the JSON response
        return json_decode($result, true);
    }

    $response = shortenUrl('http://phpriot.com');

    echo sprintf(
        '%s was shortened to %s',
        $response['longUrl'],
        $response['id']
    );

Nuestra fuente: Sentidoweb

Para deshabilitar PHP deberemos usar la directiva php_admin_flag con la opciónengine a off dentro del Directory que indiquemos:

	<Directory "/var/systemadmin.es/htdocs/images">
		php_admin_flag engine off
	</Directory>

De esta forma, aunque un usuario sea capaz de subir código en la carpeta de imágenes por algún fallo en el control, el código PHP nunca se ejecutará y en su lugar se servirá como texto plan e inofensivo.

Nuestra fuente: Systemadmin.es

Durante toda su carrera ha trabajado en código abierto desde empresas tan consagradas como IBM, Bell Globis y Yahoo.

Desde Septiembre de 2002 hasta noviembre del año pasado, Rasmus fue parte de Yahoo, en dónde no sólo generó servicios web y aportes gracias su amplia experiencia como autor de PHP, como ingenierio de infraestructura y arquitectura, también dictó muchas conferencias y trabajó en la oferta web 2.0 de la empresa.

Para aquellos seguidores de Rasmus en Twitter que se enteraron de su salida vía este servicio, muchos no se sorprendieron luego de varios comentarios que evidenciaban su malestar en la empresa: “Haciendo reviews focales de Yahoo. Espera, ¿no había renunciado? Esta era una de las cosas que más odiaba hacer cuando me pagaban para hacerlo”.

Las versiones de PHP

El nacimiento del lenguaje de programación PHP se ha desarrollado y comercializado a través Zend, y todo bajo la supervisión de Lerdorf. La idea original partió cuando Rasmus sintió la necesidad de conocer cuantas visitas únicas recibía su sitio y creo un interprete de CGI sencillo, en el que solo usó lenguaje Perl.

PHP esta sobre Java en cuanto a popularidad para la creación de aplicaciones web. Para el fundador de Netscape, Marc Andreessen su característica se basa en la simplicidad y lo describe como un producto especialmente sencillo para los nuevos desarrolladores en relación a Java, que se ha transformado en algo mucho más complejo a la hora de trabajar.

Durante 1997 la segunda versión de PHP dejó como resultado a más de 50 mil dominios en Internet. De la mano de otros autores fue la aparición de PHP 3.0, que nació gracias a los desarrolladores Andi Gutmans y Zeev Suraski, su función principal era la ampliación del núcleo.

La versión PHP4 fue lanzada en 2000 basada en el núcleo “Zend Engine“. Desde ese entonces PHP es parte de millones de sitios, con más del 20% de los dominios en internet. Su última versión PHP5 vio la luz en 2004 y su última actualización fue a finales del 2009. La gracia de esta renovación es la capacidad de soportar la programación orientadas a objetos. Pero se espera que pronto se anuncie la fecha del lanzamiento de PHP6.

La experiencia de los desarrolladores

Para José Tomás Albornoz (@elJOjo), PHP es el lenguaje de programación más amigable y ligero para trabajar en la creación de sitios web. Desde que Jojo comenzó a trabajar en PHP a los 12 años, basto un par de pruebas a través de la descarga de algunos códigos, para que él los modificara por su cuenta.

PHP no sólo sirve para trabajar en sitios web, también para programar bots, como lo son @donsaludador y @dondespedidor. Otro ejemplo que nos comentó Albornoz fue el servicio de bittr en Chile, te permite usar Twitter a través de mensajes de textos (SMS) o mensajes multimedia (MMS) mediante cualquier compañía móvil con tarifas.

Por otro lado, Fernando Lagos (@Zerial), con 5 años de experiencia en PHP, nos cuenta más acerca de las herramientas de este lenguaje:

“Lo uso porque es un lenguaje orientado a web, para desarrollar aplicaciones dinámicas. PHP es uno de los lenguajes mas fáciles de aprender y muy intuitivo”.

Zerial afirma que no existe niveles de programadores:

“Creo que la línea que los separa es la orientación a objetos. Una persona que sabe sobre el paradigma de orientación a objetos y trabajar con programación OO usando PHP trabaja de una forma más ordenada”.

Sigue e interactúa con el creador de PHP

Más allá de ser un ingeniero brillante, Rasmus forma parte una hermosa familia en conjunto con Christine, su esposa. El desarrollador utiliza las redes sociales como una agenda con hojas de contactos y también comparte archivos personales como las fotos del nacimiento de su hijo.

Además a través de su sitio personal Lerdorf.com puedes conocer más acerca de su vida, proyectos y avances del padre del PHP. No te olvides que también lo puedes seguir en su cuenta en Twitter: @rasmus, conocer sobre el futuro de PHP y sus actualizaciones.

Nuestra fuente: maestrosdelweb.com

$href = 'http://www.facebook.com';
echo <a href={$href}>Facebook</a>;

Además escapa automáticamente el contenido de las variables para evitar vulnerabilidades:

<?php
echo '<div>Hello '.htmlspecialchars($_GET['name']).'</div>';

<?php
echo <div>Hello {$_GET['name']}</div>

También ofrece la posibilidad de definir elementos XML, sus atributos o su estructura. Tengo mis dudas sobre su rendimiento, pero pensando en que ellos “compilan” el código PHP, al final no les afectará en rendimiento. XHP Vía / PHPDeveloper.org

Nuestra Fuente: sentidoweb.com

Reducir las sentencias if()

if($variable == 2)
{
$valor = true;
}
else
{
$valor = false;
}

Podríamos condensar esas 8 líneas de código en una única línea:

$valor = ($variable == 2) ? true : false;

Declarando variables

A menudo declaramos multiples variables cada una en líneas separadas, todas estas variables se podrían llegar a agrupar en una única declaración.

$variable1 = 7;
$variable2 = 12;
$variable3 = 9;

Podríamos declarar varias variables con diferente valor en una única línea de la siguiente manera:

list($variable1 ,$variable2 ,$variable3) = array(7,12,9);

Y más fácil todavia si las variables declaradas coinciden en el valor asignado:

$variable1 = $variable2 = $variable3 = “Prueba”;

Usar switch() en lugar de if()

Parece algo lógico pero muchas veces utilizamos if() dónde podríamos ahorrar código usando switch():

if($opcion == “menu”)
{
//cargar menu
}
elseif($opcion == “portada”)
{
//cargar portada
}
else
{
//no cargar nada
}

Usando switch() podríamos reducir el código ostensiblemente:

switch($opcion)
{
case ‘menu’:
//cargar menu
break;
case ‘portada’:
//cargar portada
break;
default:
//no cargar nada
}

Son sólo tres trucos pero seguramente te pueden ahorrar muchas líneas de código si sabes aplicarlos correctamente.

Nuestra Fuente: tufuncion.com

Para el código que se ejecuta con el servidor web suele ser útil deshabilitar funciones de PHP que no queremos usar. El problema es que seguramente la parte de la aplicación que ejecutamos periódicamente (con el cron por ejemplo) tendrá unos requerimientos diferentes.

Para poder ejecutar los procesos (mailings, calculos varios…) podemos indicar que se use un php.ini diferente mediante el parámetro -c:

php -c /etc/php.procesos.ini proceso.cualquiera.php

Mediante este comando indicamos a php que ejecute el scriptproceso.cualquiera.php usando la configuración presente en el fichero/etc/php.procesos.ini. En este fichero podremos ser más permisivos sin afectar a lasrestricciones del servidor web.

Nuestra Fuente: SystemAdmin.es