Passage du dédié au cloud : cadre de la conférence

Dans le cadre de ma série d’articles intitulés « Passage du dédié au cloud » , je commence par revenir sur le contenu de la conférence, afin de faire un petit récapitulatif.

Revenons donc en 2014, où j’ai effectué, dans le cadre de mon travail, un passage de serveur dédié au cloud de type PaaS au travers de la plateforme EngineYard (à l’époque il offrait du PaaS tout langage). Cette plateforme, à ce moment-là, possédait une surcouche sur AWS et un support qui nous a franchement aidés dans bien des cas complexes.

Mais commençons par le début, avant avril 2014, l’infrastructure c’était surtout quelques applications PHP déployés par FTP, dans des VM. Peu de temps a consacré a l’infra, et plein de choses old-school. Mais cela marchait, et c’est l’essentiel. Suite à plusieurs soucis de production, on s’est vite rendu compte qu’il fallait se bouger si l’on désirait aller plus loin, gagner en stabilité et être plus zen au quotidien.

Par ailleurs, en cas de désastre, le recovery plan c’était pire que de se jeter depuis l’espace en parachute, avec 0 garantie de retrouvée une stabilité ou une plateforme équivalente… Bref, un truc bien dégueu. 1.

 

En février 2014, au phpbenelux conference, j’ai eu l’occasion de discuter avec diverses personnes2, dont une personne technique de chez EngineYard. Chemin faisant, je me suis dit pourquoi ne pas tenter. Tout du moins préparer le terrain ne pouvait pas nuire. En mars 2014, après un peu de discutions business, on commence la vraie analyse de nos besoins en termes de plateforme d’un côté et on travail sur l’amélioration du code existant pour le rendre compatible cloud. Nous travaillons aussi si du fine tunning de notre future plateforme de production.

Avec de l’aide du fournisseur, et pas mal d’huile de coude, nous finissons par tout mettre en place et avoir le tout en production. Et en prime on améliore notre environnement de développements, avec une meilleure gestion de la configuration. Bref, on se retrouve avec les points suivants :

  • code déployable, et buildable de manière automatisés,
  • un environnement de développements plus facilement configurable,
  • du déploiement au « bouton rouge » (on click, cela déploie),
  • un environnement de validation,
  • des app scalable,

Bref, on est content, tout du moins techniquement parlant. En effet, en termes de budget on fait fois six. Cependant, ce n’est plus tout à fait la même chose.

Avant, en faisant court :

  • dédiés
  • déploiement à la main, avec risque de fausse manœuvre et de désynchronisation du code entre la prod et le dev
  • 0 support autre que matériel (genre un disque qui flanche)
  • pas de possibilités de scaler
  • pas d’environnement de validation
  • infrastructure non rebuildable
  • un support technique (moi) qui dormait mal

Après :

  • dédié (certaines applications devaient rester en dehors du cloud)
  • déploiement automatisé
  • support infra et technique
  • possibilité du cloud
  • environnement de validation
  • infrastructure rebuildable « rapidement »
  • moi : zen, sommeil réparateur 😉

Bref, pas vraiment comparable, surtout le dernier point.

 

En résumé, moins de 3 mois entre l’idée et la production, et ce avec énormément de gain. Ceci grâce au PaaS et non à du cloud du type IaaS, la différence entre les deux est surtout liée au fait que vous n’avez besoin que de vous concentrer sur votre applicatif et non sur la configuration de la plateforme. Ceci a une grande importance, même si le coût financier peut rebuter.

Certains m’ont signalé, lors de ma présentation au PHPTour, que je n’avais pas donné assez de détail technique à l’époque, ceci est corrigé avec le billet suivant « Passage du dédié au cloud : conférence, détail techniques« .

  1. Mais mieux que lors de mon arrivée, où l’environnement de développement pointait sur la base de données de production, par défaut 😉
  2. comme c’est souvent le cas dans les conférences

Passage du dédié au cloud : introduction

En 2015, j’ai eu l’occasion de présenter « Comment migrer avec succès dans le cloud » (slides) au PHPTour Luxembourg. Avec une série de plusieurs billets, je vous propose donc de revenir dessus et bien entendu d’apporter quelques informations supplémentaires.

Deux ans, c’est assez long, pas mal de choses ont évolué au niveau technologique! Nous commencerons donc par un point sur ce qui a été présenté dans la conférence, suivie de quelques détails plus techniques et pour finir, un point sur la situation actuel.

Bref, voici le plan des prochains billets :

  • Passage du dédié au cloud : cadre de la conférence
  • Passage du dédié au cloud : conférence, détail techniques
  • Passage du dédié au cloud : 2014-2016
  • Passage du dédié au cloud : vers l’infini et au-delà
  • Passage du dédié au cloud : détail technique
  • Passage du dédié au cloud : Il y en a un peu plus, je vous le mets quand même?

Création de nouveau formulaire facilement avec Zend Form Maker

La création de formulaire avec zend framework peut être facilitée grâce à un petit développement : Zend Form Maker. Projet disponible sur github. À la base créer pour des besoins scolaires, sarlak a eu la bonne idée de rendre le dev open source sous licence GPL 3.0.

Le but du logiciel est de permettre via une interface très simple d’accès, de créer des formulaires et ensuite de forger une classe PHP, basé sur zend framework afin d’obtenir un formulaire tout frais moulu. Ultra pratique, et ultra simple, et surtout cela fait gagner un temps de dingue!

Pour l’installer, il vous faut de quoi faire fonctionner zend framework (celui-ci doit être installé). Sous Unix cela donnera ceci :

git clone https://github.com/sarlak/Zend-Form-Maker.git
ln -s pathToYourZFLibrary
chmod 0777 Zend-Form-Maker/public/resources/xml
chmod 0777 Zend-Form-Maker/public/resources/form_made

Bien entendu, à peu de choses près ceci est adaptable sous MS-Windows

Pour créer votre premier formulaire, il vous suffit de vous rendre sur l’URL adéquate, aller sur « form list » et « Bazinga! ». Une démo existe en ligne!

Une petite capture d’écran :

À noter que j’ai corrigé un ou deux petits trucs qui me dérangeaient, il y a un bout de temps.

ZF : ACL et ressources multiple

Lorsque l’on utilise des ACL dans Zend Framework, une chose assez embêtante est de devoir tout mettre en place1. Pour ma part, j’ai par facilité voulu ajouté le support de ressource multiple.

Avant de commencer, il convient de contextualisé les choses, les ACL de ZF pouvant être utilisé de bien des manière.

Dans le cas qui nous intéresse, j’ai simplement défini ceci :

  • les ressources2 = module.controller
  • les privilèges3 = action

Ce que je voulait c’est pouvoir définir une ressource pour tous les contrôleurs. La syntaxe évidente qu’il m’est venu est la suivante : module.*

Dans ma classe qui étend Zend_ACL j’ai simplement fait ceci :

    public function isAllowed($role = null, $resource = null, $privilege = null)
    {
    	if (null === $resource)
    		return parent::isAllowed($role, $resource, $privilege);
 
    	$resources = $this->getResourcesPossibility($resource);
    	foreach($resources as $resource)
    	{
    		if ($this->has($resource) && parent::isAllowed($role, $resource, $privilege))
    		{
    			return true;
    		}
    	}
    	return false;
    }
 
    public function getResourcesPossibility($resource = null)
    {
    	$ret = array($resource);
    	if (null !== $resource)
    	{
    		$resources = explode('.', $resource);
    		$cptRessources = count($resources);
    		if ($cptRessources >= 2)
    		{
    			$resources[ $cptRessources - 1 ] = '*';
    		}
    		$ret[] = implode('.', $resources);
    	}
    	return $ret;
    }

Ceci peut bien entendu être enrichi mais permet au moins de profiter de l’utilisation des ACL dans le menu et sur des aides de vue qui serait éventuellement définie comme expliqué dans la plupart des tutoriaux.

Pour en savoir plus sur les ACL et Zend Framework, je vous renvoi a un très bon article.

  1. surtout si on utilise l’aide de vue pour généré un menu (Zend_navigation)
  2. resource
  3. privilege

Espace de nom PHP et chargement automatique

PHP 5.3 ajoute une notion intéressante : les espaces de nom (ou namespace en anglais). Les espaces de nom permettent de séparer différents … « espace« , permettant ainsi d’avoir deux classe portant le même nom. Idéal pour l’utilisation de framework mais aussi de « l’isolation » de certains composants. Voyons voir comment créer un chargeur automatique (ou autoloader) comprenant les espaces de nom.

Si vous êtes sous Ms Windows, aucun problème un simple spl_autoload_register(); suffit. Malheureusement, sous *nix un bug existe il faudra donc implémenté une solution maison.

Le code

Ce code provient du « PHP Standards Working Group » :

function autoload($className)
{
	$className = ltrim($className, '\\');
	$fileName  = '';
	$namespace = '';
	if ($lastNsPos = strripos($className, '\\'))
	{
		$namespace = substr($className, 0, $lastNsPos);
		$className = substr($className, $lastNsPos + 1);
		$fileName  = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
	}
	$fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
 
	require $fileName;
}

Pour l’utiliser, il faut définir deux choses :

  1. Ne pas oublier de modifier l’include path si nécessaire.
  2. Ajouter cette fonction au chargeur de classes présent.

L’exemple

Voici un exemple un peu plus complet.
index.php

<?php
set_include_path(get_include_path() . PATH_SEPARATOR . dirname(__FILE__) . '/lib/');//on ajoute le dossier lib dans l'include path
spl_autoload_register();//sur windows ceci devrait suffire .
//le code pour les autres
//----------------------------------------------------------
function autoload($className)
{
	$className = ltrim($className, '\\');
	$fileName  = '';
	$namespace = '';
	if ($lastNsPos = strripos($className, '\\'))
	{
		$namespace = substr($className, 0, $lastNsPos);
		$className = substr($className, $lastNsPos + 1);
		$fileName  = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
	}
	$fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
 
	require $fileName;
}
spl_autoload_register('autoload');
//----------------------------------------------------------
//fin du code de fix
 
use grummfy\test\Test;
Test::sayHello();
 
\grummfy\std\Test::sayHello();
 
# EOF

./lib/grummfy/test/Test.php

<?php
namespace grummfy\test;//pour rappel ceci doit-être la première instruction php (et on ne doit pas avoir de HTML avant)
echo 'Je suis inclus (' . __FILE__ . ')!';
class Test
{
	public static function sayHello()
	{
		echo 'Bonjour depuis ' . __CLASS__;
	}
}
 
# EOF

./lib/grummfy/std/Test.php

<?php
namespace grummfy\std;
echo 'Je suis inclus (' . __FILE__ . ')!';
class Test
{
	public static function sayHello()
	{
		echo 'Bonjour depuis ' . __CLASS__;
	}
}
 
# EOF

Le résultat devrait être :

Je suis inclus (/.../lib/grummfy/test/Test.php)!
Bonjour depuis grummfy\test\Test
Je suis inclus (/.../lib/grummfy/std/Test.php)!
Bonjour depuis grummfy\std\Test