lindev.fr

Aller au contenu | Aller au menu | Aller à la recherche

Mot-clé - serveur

Fil des billets - Fil des commentaires

07 juin 2017

Environnement de développement complet avec Docker

Qu'allons nous voir

docker-logo.jpg Nous allons voir comment mettre sur pied avec Docker un environnement de développement Web complet ( LAMP ) en quelques minutes ( si l'on compte uniquement le temps de déploiement, et non la lecture de ce post. ).

Mais surtout , rendre cet environnement facilement configurable pour qu'il réponde à vos attentes.

Au programme, nous aurons donc 3 conteneurs


Petit plus, nous aurons à disposition, un fichier de configuration permettant l'utilisation de la fonction mail() de php.

Pour lancer facilement ces conteneurs Docker, nous utiliseront l'outil docker-compose, qui permet en un seul fichier de déclarer notre environnements et bien plus encore.

Pour les plus pressés : Si vous ne souhaitez pas créer les répertoires et fichiers de conf à la main en suivant tout le billet, vous pouvez directement cloner le projet puis lancer ( Après avoir installé Docker sur votre machine évidemment ). Rendez-vous tout en bas de cette page, dans la section Go go go.

Installation de Docker et docker-compose

Franchement, il n'y a rien de compliqué, je ne vais pas détailler spécialement la méthode , juste vous donner les liens pour les différents systèmes.
Après, il suffit de suivre.

Docker CE

Docker-Compose

Bonne nouvelle pour les utilisateurs de Mac & Windows, l'outil est automatiquement installé avec Docker.

Pour les utilisateurs Linux, je conseille la commande pip

sudo pip install docker-compose

Le projet LAMP

Parfait, nous avons tout les outils nécessaires pour atteindre notre objectif.
Commençons par créer un répertoire qui contiendra l’ensemble des fichiers de configuration et le code source de nos futurs projets Web .

mkdir -p dockerlamp/www dockerlamp/docker/apache/vhosts dockerlamp/docker/mysql dockerlamp/docker/php

Voici en résumé ce que ça donne :

dockerlamp
├── docker
│   ├── apache
│   │   └── vhosts
│   ├── mysql
│   ├── php
└── www

Nous aurons donc les fichiers de configuration dans le répertoire docker/ et le code source sera dans le répertoire www/

docker-compose.yml

Je vais pas tourner autour du pot, je vais tout de suite vous donner le contenu complet du fichier docker-compose.yml, nous verrons ensuite les différents points à compléter.

Créez donc le fichier docker-compose.yml à la racine du répertoire dockerlamp/

# Adopt version 2 syntax:
#   https://docs.docker.com/compose/compose-file/#/versioning
version: '2'

volumes:
    database_data2:
        driver: local

services:
###########################
# Setup the Apache container
###########################
    httpd:
        container_name: dockerapache_httpd_1
        restart: always
        image: httpd:2.4.25
        ports:
            - 80:80
        volumes:
            - ./docker/apache/httpd.conf:/usr/local/apache2/conf/httpd.conf
            - ./docker/apache/vhosts/:/usr/local/apache2/conf/vhosts
        volumes_from:
            - php

###########################
# Setup the PHP container
###########################
    php:
        container_name: dockerapache_php_1
        restart: always
        build: ./docker/php/
        expose:
            - 9000
        volumes:
            - ./www/:/usr/local/apache2/htdocs
            - ./docker/php/ssmtp.conf:/etc/ssmtp/ssmtp.conf:ro
            - ./docker/php/php-mail.conf:/usr/local/etc/php/conf.d/mail.ini:ro


###########################
# Setup the Database (MySQL) container
###########################
    mysql:
        container_name: dockerapache_mysql_1
        restart: always
        image: mysql:5.6.36
        expose:
            - 3306
        volumes:
            - database_data2:/var/lib/mysql
            - ./docker/mysql/conf-mysql.cnf:/etc/mysql/mysql.conf.d/conf-mysql.cnf:ro
        environment:
            MYSQL_ROOT_PASSWORD: secret
            MYSQL_DATABASE: project
            MYSQL_USER: project
            MYSQL_PASSWORD: project

Configuration Apache

Afin de configurer finement le service Apache, nous allons récupérer le fichier httpd.conf et le déposer dans le répertoire dockerlamp/docker/apache/

Voici le lien de téléchargement httpd.conf

La seule modification faite à ce fichier ( comparé à la version d'origine ) est la prise en charge des virtualhosts.

Nous allons par conséquent également récupérer le virtualhost par défaut et le placer dans le répertoire dockerlamp/docker/apache/vhosts/

Voici le lien de téléchargement 000-default.conf


Pour les curieux, si vous éditez le fichier 000-default.conf, vous verrez que l'on utilise le module proxy d'apache pour gérer les sources php . Nous passons ces sources au service nommé "php" sur le port 9000.

Nous en avons terminé avec le service apache . Passons au service php.

Configuration php-fpm

Contrairement au service apache, le conteneur php-fpm doit être modifié, pour ne serait-ce qu'installer les extensions.
Nous allons donc créer un fichier Dockerfile, qui contiendra toutes les instructions pour finaliser notre container .

La bonne pratique

J'aurais pu simplement créer une image du container sur dockerHub et la mettre à disposition, mais pour partager une image modifiée, la bonne pratique consiste à utiliser comme base l'image officielle ( php ), puis d'ajouter explicitement les changements à apporter dans un DockerFile.

Ce qui vous permet d'être certain que l'image finale n'est pas corrompue.

Dockerfile

créez le fichier Dockerfile dans le répertoire dockerlamp/docker/php/, comme précisé dans docker-compose.yml.

FROM php:5.6-fpm

# install the PHP extensions we need
RUN set -ex; \
	\
	apt-get update; \
	apt-get install -y \
		libjpeg-dev \
		libpng12-dev \
                libmcrypt-dev \
                ssmtp \
	; \
	rm -rf /var/lib/apt/lists/*; \
	\
	docker-php-ext-configure gd --with-png-dir=/usr --with-jpeg-dir=/usr; \
	docker-php-ext-install gd mysqli opcache pdo_mysql json mcrypt; \
        pecl install -o -f xdebug redis \
        && rm -rf /tmp/pear \
        && echo "extension=redis.so" > /usr/local/etc/php/conf.d/redis.ini \
        && echo "zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20131226/xdebug.so" > /usr/local/etc/php/conf.d/xdebug.ini; 
# TODO consider removing the *-dev deps and only keeping the necessary lib* packages

# set recommended PHP.ini settings
# see https://secure.php.net/manual/en/opcache.installation.php
RUN { \
		echo 'opcache.memory_consumption=128'; \
		echo 'opcache.interned_strings_buffer=8'; \
		echo 'opcache.max_accelerated_files=4000'; \
		echo 'opcache.revalidate_freq=2'; \
		echo 'opcache.fast_shutdown=1'; \
		echo 'opcache.enable_cli=1'; \
	} > /usr/local/etc/php/conf.d/opcache-recommended.ini

RUN { \
                echo '[xdebug]'; \
                echo 'xdebug.default_enable = 0'; \
        } >> /usr/local/etc/php/conf.d/xdebug.ini


RUN { \
        echo 'error_reporting  =  E_ALL'; \
        echo 'log_errors = On'; \
        echo 'display_errors = Off'; \
    } > /usr/local/etc/php/php.ini

CMD ["php-fpm"]
EXPOSE 9000

php7-fpm : Si vous préférez une autre version de php, il vous suffit de la changer sur la première ligne ( ex : FROM php:7.1.5-fpm ).
Toutes les versions sont listées ici.

fonction mail()

Puisque nous utilisons le service php à l'intérieur d'un container, seul ce service est disponible ( bien qu'il soit possible de lancer plusieurs services dans un même conteneur, cette méthode n'est pas conseillée ), le service sendmail n'est pas disponible.

Pour palier à ce problème, nous allons utiliser ssmtp. Cet utilitaire ne fait que rediriger les mails vers un serveur SMTP externe.
Pour le configurer ( l'activer au sein de php et définir quel serveur SMTP utiliser ), nous allons ajouter deux fichiers dans le répertoire dockerlamp/docker/php/

  • php-mail.conf
  • ssmtp.conf
php-mail.conf

Ce fichier de configuration ( chargé comme un php.ini supplémentaire ) ne fait que surcharger le chemin de l’exécutable sendmail afin d'utiliser ssmtp.

[mail function]
sendmail_path = "/usr/sbin/ssmtp -t"
ssmtp.conf

Ce fichier vous permet de définir quel serveur SMTP utiliser pour envoyer vos mails.
Par exemple, pour utiliser un compte Gmail:

mailhub=smtp.gmail.com:587
[email protected]
AuthPass=mypassword

FromLineOverride=YES
hostname=dockerdev.foo.net
UseSTARTTLS=YES

Seules les 3 premières lignes sont à adapter selon votre cas.

Nous en avons terminé avec la configuration de php-fpm. Passons à Mysql

Configuration Mysql

C'est presque le service le plus simple... dans le fichier docker-compose, nous avons défini des variables d'environnements, qui spécifient le mot de passe du compte root, une base de données à créer avec un utilisateur associé (login et mot de passe) .

Par la suite, si vous devez ajouter une nouvelle base de données, deux possibilités .

  1. Ajouter les informations dans le fichier docker-compose, et relancer le conteneur
  2. Se connecter en root sur le service mysql et créer manuellement la base de données et son utilisateur .

Nous allons créer le fichier conf-mysql.cnf, dans le répertoire dockerlamp/docker/mysql/ ce fichier est automatiquement monté dans le conteneur Mysql à son démarrage et permet donc de modifier simplement la configuration de mysql .

Par exemple, si l'on souhaite modifier la variable sql_mode

[mysqld]  
sql_mode = "STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION"

Note : Vous pouvez laisser ce fichier vide si vous n'en avez pas l'utilité pour le moment. Mais il doit être présent dans le répertoire mysql !

Notre environnement LAMP est maintenant prêt !

Lancer l'environnement LAMP

Puisque nous avons configuré notre environnement via un fichier docker-compose.yml, nous allons évidemment utiliser la commande docker-compose pour le lancer.
Placez-vous à la racine du projet dockerlamp/

docker-compose up -d

Cette commande va construire les volumes, les interfaces réseaux, télécharger les images nécessaires, construire les conteneurs si besoin ( via le Dockerfile ) et enfin ... les exécuter en tache de fond . Oui oui .. tout ça en une seule commande .. le pied!

Le test

Nous allons tester notre stack, apache et php.

Créez deux fichiers dans le répertoire www/

  • info.php
  • index.html
info.php
<?php 
echo phpinfo();
index.html
<h1>Hello World</h1>

Enfin ouvrez un navigateur et entrez ces URLs :

Vous devriez normalement voir un magnifique Hello World, et la page d'infos de php ! Selection_999_057_.png

Un vrai projet

Je ne vais pas vous laisser avec un simple phpinfo() et un Hello World !!
Nous allons aller au bout des choses, en installant par exemple un petit Drupal.

L'objectif est d'installer Drupal et qu'il soit accessible ( sur votre machine ) depuis l'url http://drupal.local/


Le Vhost

Afin de pouvoir utiliser un nom de domaine locale, ( drupal.local ), il faut auparavant renseigner le fichier hosts, pour le déclarer .

Linux et Mac
sudo sh -c "echo '127.0.0.1   drupal.local' >> /etc/hosts"
Windows

Pour Windows vous devez ouvrir le fichier c:\Windows\System32\Drivers\etc\hosts en administrateur avec NotePad et y ajouter la ligne :

127.0.0.1   drupal.local

Maintenant, nous allons créer notre vhost afin qu'Apache sache quoi faire lorsqu'il reçoit les requêtes avec le nom de domaine drupal.local.

Editer le fichier dockerlamp/docker/apache/vhosts/drupal.conf

<VirtualHost *:80>
        ServerAdmin [email protected]
        ServerName drupal.local

        <Directory />
            AllowOverride All
            Require all granted
        </Directory>

        DocumentRoot "/usr/local/apache2/htdocs/drupal"
        <Directory "/usr/local/apache2/htdocs/drupal">
                Options Indexes FollowSymLinks
                AllowOverride All
                Require all granted
        </Directory>


    <FilesMatch \.php$>
        # 2.4.10+ can proxy to unix socket
        # SetHandler "proxy:unix:/var/run/php5-fpm.sock|fcgi://localhost/"

        # Else we can just use a tcp socket:
        SetHandler "proxy:fcgi://php:9000"
    </FilesMatch>

</VirtualHost>

On a donc déclaré le nom de domaine à Apache, en lui spécifiant de pointer sur le répertoire drupal/

Les sources

Puisque nous avons demandé à Apache de pointer sur le répertoire drupal/, nous allons télécharger les sources de Drupal dans ce répertoire qui lui-même se trouve dans le répertoire dockerlamp/www/

cd www
wget https://ftp.drupal.org/files/projects/https://ftp.drupal.org/files/projects/drupal-8.3.2.tar.gz
tar xzf drupal-8.3.2.tar.gz 
mv drupal-8.3.2 drupal
mkdir -p drupal/sites/default/files/translations && chmod -R 777 sites/default/files/translations
chmod -R 777 drupal/sites/default/files
touch drupal/sites/default/settings.php && chmod 777 drupal/sites/default/settings.php

Enfin, pour que le conteneur Apache prenne en considération notre nouveau vhost, nous allons redémarrer notre stack

docker-compose restart

L'installation

Pour l'installation, il suffit de pointer sur notre nom de domaine local et suivre les instructions

http://drupal.local/

Arrivé à l'installation de la base de données, remplissez le formulaire comme ceci ( Base de données déclarée dans le fichier docker-compose.yml ),

  • Nom de la base de données : project
  • Utilisateur : project
  • Mot de passe : project
  • Et dans options avancés > Hôte : mysql


Selection_999_058_.png

Après cette étape, Drupal s'installe tranquillement sur votre environnement
Selection_999_059_.png
Remplissez les formulaires durant l'installation, vous devriez rapidement arriver sur la page d'accueil de votre Drupal fraîchement installé .

Selection_999_060_.png Selection_999_061_.png

Conclusion

Vous avez à disposition un environnement de développement complet comme démontré avec Drupal.

Pour chaque projet vous devez donc

  1. Créer un domaine local dans votre fichier hosts
  2. Créer la configuration du virtualHost pour apache
  3. Récupérer les sources et les placer dans le répertoire www/
  4. Relancer la stack LAMP via docker-compose

Voici quelques outils / lignes de commandes pour vous aider à travailler, "debugger".

Vous trouverez ces petits scripts dans le répertoire tools/ du dépôt dockerlamp.

Ces scripts ne représentent qu'une base pour vous aider à travailler, je vous laisse maintenant parcourir la documentation de Docker pour comprendre les différentes commandes / configurations utilisées dans ce billet.

N’hésitez pas à poser des questions si besoin.

Créer un dump d'une base de données

dump_sql.sh

docker exec dockerapache_mysql_1 /usr/bin/mysqldump --databases -uroot -psecret $DATABASE > $DATABASE.sql

Restaurer/Importer une base de donnée depuis un dump sql

restore_sql.sh

cat $DUMP | docker exec -i dockerapache_mysql_1 /usr/bin/mysql -uroot -psecret

Afficher les logs Apache en temps réel ( Pour débugger )

logs.sh

docker logs --tail 100 -f dockerapache_httpd_1 

Afficher les ressources utilisées par les conteneurs sur votre machine

stats.sh

docker stats --format "table {{.Container}}\t{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.NetIO}}\t{{.BlockIO}}\t{{.PIDs}}"

Selection_999_062_.png

Go go go

On clone l'environnement

git clone https://[email protected]/cdesaintleger/dockerlamp.git && cd dockerlamp

On Configure le smtp

cp docker/php/ssmtp.conf.dist docker/php/ssmtp.conf && vim docker/php/ssmtp.conf

On lance la stack

docker-compose up -d

01 oct. 2015

EC2, ajouter un compte utilisateur avec certificat .pem

A la création d'une instance EC2, vous avez un compte par défaut ( ec2-user ou admin selon la distrib ) .
Ce compte vous permet d’accéder et d'administrer votre instance via une connexion SSH , avec une authentification par certificat ( que vous avez préalablement téléchargé à la création de l'instance ).

On va voir ici comment ajouter un compte utilisateur avec un nouveau certificat pour qu'il puisse également se connecter sur cette instance EC2.

Première étape le certificat

Nous allons commencer par créer ce nouveau certificat via l'interface d'amazon ( la clef privée )

Clef privée ( .pem )

C'est très simple, suivez le guide...

Dirigez-vous vers le service EC2 Capture_d_e_cran_2015-10-01_a__09.22.02.png

Gestion des clef Capture_d_e_cran_2015-10-01_a__09.22.13.png

Créer un clef Capture_d_e_cran_2015-10-01_a__09.22.23.png

Vous devrez alors télécharger cette nouvelle clef ( ici elle s'appelle lindev.pem )

Clef public

Coté serveur, nous allons devoir spécifier la clef publique liée à cette clef privée pour le nouvel utilisateur.
Commençons donc par récupérer cette clef publique.

Changez les droits du certificat
chmod 400 lindev.pem
Générer les clef publique à partir de la clef privée
ssh-keygen -y

Cette commande va vous demander le chemin vers la clef privée. Suite à quoi il va vous sortir la clef public .
Par exemple :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCISBb/pQYoSz1tm2mWrBBK8Yfs+8z2rdcbYhCIgz7oLE2YNrT/cs8D9WXduTezS1p/SjdfA4zhXSJNBvjNP0A0M2s1Mj3E+edpENhsYrLBxDc1F60CQ4be0hLICX2e2mDzPYi7sLgAzAdVI67Eo2Zmj/0QYwckS4JgFl7JXedV8Fz4D2gm8xjByxbtlsPhG84Y9wq7GGmtHuaHzi+H+RVS1hlDZIH8QKwX9U5eWJY3BaQjXpwnorNvn2OrlO9wmTE+22A7F0vF8zsRia+t5TwqPaVYmfX7DN5zqBMcd8tQC1LdYS0b+h6+fLAkUdaqQ0kXGm1FCxYH00hTYNS+JV/V

Gardez cette clef nous allons en avoir besoin bientôt coté serveur.

Coté serveur

Nous sommes maintenant sur notre instance EC2 avec l'utilisateur par defaut, nous allons donc créer notre second utilisateur et lui transmettre notre clef publique.

Création de l'utilisateur

[email protected]:/home/admin# adduser lindev
Adding user `lindev' ...
Adding new group `lindev' (1001) ...
Adding new user `lindev' (1001) with group `lindev' ...
Creating home directory `/home/lindev' ...
Copying files from `/etc/skel' ...
Enter new UNIX password: 
Retype new UNIX password: 
passwd: password updated successfully
Changing the user information for lindev
Enter the new value, or press ENTER for the default
	Full Name []: Lindev
	Room Number []: 
	Work Phone []: 
	Home Phone []: 
	Other []: 
Is the information correct? [Y/n] Y

Voilà mon utilisateur créé, ne nous reste plus qu'à lui créer sa configuration ssh

ssh

Création du répertoire contenant la configuration ssh de l'utilisateur

sudo -s
su - lindev
mkdir /home/lindev/.ssh
chmod 700 /home/lindev/.ssh

Création du fichier contenant les clefs publiques

touch /home/lindev/.ssh/authorized_keys
chmod 600 /home/lindev/.ssh/authorized_keys

Editer le fichier authorized_keys et y coller votre clef public .

vim /home/lindev/.ssh/authorized_keys

je colle donc :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCISBb/pQYoSz1tm2mWrBBK8Yfs+8z2rdcbYhCIgz7oLE2YNrT/cs8D9WXduTezS1p/SjdfA4zhXSJNBvjNP0A0M2s1Mj3E+edpENhsYrLBxDc1F60CQ4be0hLICX2e2mDzPYi7sLgAzAdVI67Eo2Zmj/0QYwckS4JgFl7JXedV8Fz4D2gm8xjByxbtlsPhG84Y9wq7GGmtHuaHzi+H+RVS1hlDZIH8QKwX9U5eWJY3BaQjXpwnorNvn2OrlO9wmTE+22A7F0vF8zsRia+t5TwqPaVYmfX7DN5zqBMcd8tQC1LdYS0b+h6+fLAkUdaqQ0kXGm1FCxYH00hTYNS+JV/V

On enregistre et on quitte.

Tests

Il ne vous reste plus qu'à tester a connexion avec votre nouvel utilisateur .

ssh -i "lindev.pem" [email protected]

Normalement vous devriez être connecté sans avoir à rentrer le moindre mot de passe, en utilisant le certificat Amazon.

17 sept. 2013

Serveur de fichiers AFP sous wheezy

netatalk.gif Je partages de gros volumes sur le réseau, avec majoritairement des Clients Apple .
Jusqu'à maintenant, samba répondait pleinement à mon besoin, mais depuis la version Lion d'OS X, je rencontre des lenteurs plus ou moins prononcées pendant la navigation dans les volumes partagés.
Seuls les anciens postes et autres systèmes d'exploitation se comportent normalement.

N'ayant pas trouvé la cause pour le moment, j'ai décider de tester le protocole AFP, protocole de prédilection Apple ..

Sous linux, AFP == Netatalk, qui est intégré au noyau, afin de nous faciliter la tâche pour interconnecter des réseaux Apple .

Prérequis

Sous linux ( wheezy ) au moment ou j'écris ce tuto

sudo apt-get install netatalk avahi-daemon

Configuration

Afin de diffuser le service Netatalk sur le réseau, il nous faut mettre en place Avahi

netatalk

Pour avoir une idée clair des fichiers de configuration de netatalk, utiliser la commande

afpd -V

Ce qui donne

afpd 2.2.2 - Apple Filing Protocol (AFP) daemon of Netatalk
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version. Please see the file COPYING for further information and details.
 
afpd has been compiled with support for these features:
 
          AFP versions:	1.1 2.0 2.1 2.2 3.0 3.1 3.2 3.3 
DDP(AppleTalk) Support:	Yes
         CNID backends:	dbd last tdb 
           SLP support:	No
      Zeroconf support:	Yes
  TCP wrappers support:	Yes
         Quota support:	Yes
   Admin group support:	Yes
    Valid shell checks:	Yes
      cracklib support:	Yes
        Dropbox kludge:	No
  Force volume uid/gid:	No
            EA support:	ad | sys
           ACL support:	Yes
          LDAP support:	Yes
 
             afpd.conf:	/etc/netatalk/afpd.conf
   AppleVolumes.system:	/etc/netatalk/AppleVolumes.system
  AppleVolumes.default:	/etc/netatalk/AppleVolumes.default
    afp_signature.conf:	/etc/netatalk/afp_signature.conf
      afp_voluuid.conf:	/etc/netatalk/afp_voluuid.conf
         afp_ldap.conf:	/etc/netatalk/afp_ldap.conf
       UAM search path:	/usr/lib/netatalk/
  Server messages path:	/etc/netatalk/msg/
              lockfile:	/var/run/afpd.pid

Dans mon cas, je partage un répertoire commun à tous mes utilisateurs, donc pas de login ni de mot de passe.

vim /etc/netatalk/afpd.conf

pour éviter la demande de mot de passe à la connexion, nous allons dans le fichier afpd.conf modifier la ligne suivante

- -tcp -noddp -uamlist uams_dhx.so,uams_dhx2.so -nosavepassword

par celle-ci

- -tcp -noddp -uamlist uams_guest.so,uams_dhx.so,uams_dhx2.so -nosavepassword

Afin d'activer le compte invité.

Déclarer un partage

Il ne reste plus à déclarer un partage, exemple /var/data/commun . Évidemment ce répertoire doit exister .

Nous allons déclarer ce partage dans le fichier AppleVolumes.default

vim /etc/netatalk/AppleVolumes.default

On y déclare le répertoire à partager, en ajoutant à la fin

/var/data/commun "commun" cnidscheme:dbd options:usedots,upriv,tm

Le fichier contient toutes les explications sur les options disponibles .

Avahi

Nous allons demander à Avahi de déclarer le service afpd de notre serveur sur le réseau . Nous allons donc simplement déclarer un nouveau service à avahi

vim /etc/avahi/services/afpd.service

Voici le contenu ( qui n'est pas à modifier )

<?xml version="1.0" standalone='no'?><!--*-nxml-*-->
<!DOCTYPE service-group SYSTEM "avahi-service.dtd">
<service-group>
  <name replace-wildcards="yes">%h</name>
  <service>
    <type>_afpovertcp._tcp</type>
    <port>548</port>
  </service>
  <service>
    <type>_device-info._tcp</type>
    <port>0</port>
    <txt-record>model=Xserve</txt-record>
  </service>
</service-group>

Lancement des services

Nous reste plus à lancer les services netatalk et avahi fraichement configurés .

sudo /etc/init.d/netatalk restart
sudo /etc/init.d/avahi-daemon restart

Sur les postes clients, dans l'exploration réseau, vous devriez voir apparaître le partage .

Ch.

27 mai 2011

LVM exemple de mise en pratique

recuperation-donnees-fichiers-9.jpg Cela fait longtemps que je tourne autour de ce gestionnaire de volumes jamais avoir eu l'occasion d'y mettre les mains . Aujourd'hui c'est chose faite !

LVM / LVM2 utilisation

Il y a quelques jours j'ai eu pour mission la mise en production d'un serveur web linux, hébergé sur une plateforme de virtualisation microsoft Hyper-V. Le contrainte principale était bien entendu la disponibilité de ce serveur , mais aussi la possibilité de restaurer le serveur sans connaissance particulière et surtout en un temps record ..

Première possibilité ,

La mise en place d'un cluster ( soit , deux machines virtuelles en front ou une maitre et l'autre esclave ). La machine hôte ( Hyper-V ) étant déjà bien chargé , la mise en place d'une seconde VM n'était pas envisageable.

Seconde possibilité ,

La machine hôte étant associée à une baie SAN, nous avons donc migré les données variables ( sources et BDD ) sur cette dernière , ce qui rend la restauration de la machine virtuelle aussi simple qu'un "copier coller", à partir du moment ou la vm est sauvegardé.

Pourquoi LVM

J'y viens, mettre les données dynamiques sur la baie SAN est bien beau , mais figer une taille de disque ( aussi virtuel soit-il ) est assez délicat. A moins d'être devint, il est très difficile d'estimer une taille suffisamment grande pour supporter les éventuelles évolutions, et il serait vraiment dommage de gâcher de de l'espace disque en surestimant le besoin .( l'espace disque SAS est à utiliser avec parcimonie, le moindre Go de cette qualité est précieux ).

J'ai donc créé un disque virtuel d'une taille fixe de 5Go ( il est aussi possible de créer un disque à taille variable , mais les performances chutent de 30% selon la doc ... ). 5Go est bien assez pour commencer et être tranquille un bon moment ( plus ou moins long selon l'activité ).

Ce disque virtuel nommé sdb ( que nos pouvons comparer à un disque dur physique ), sera dans un premier temps formaté, et nous allons créer une partition primaire sdb1 .

Création de la partition primaire

cfdisk /dev/sdb

Maintenant, étant donné que je souhaite utiliser ce disque avec LVM, il est nécessaire de déclarer la partition fraichement créée

Déclaration de la partition sdb1 à LVM

pvcreate /dev/sdb1

Maintenant étape importante, créer le groupe de volume(s) GV. Ce groupe de volume peut être représenté comme une unité regroupant un ensemble de volumes , ou plus simplement expliqué , une grosse partition composée de une ou plusieurs partitions de niveau inférieur appartenant ou non au même disque dur . Ce ne sera plus à vous de gérer la répartition de vos données sur entre les différentes partitions , le GV s'en chargera pour vous.

Création du GV ( Groupe de volumes )

vgcreate MONGROUP /dev/sdb1

Nous voilà maintenant avec un superbe groupe de volumes nommé MONGROUP sur lequel nous allons créer nos volumes logiques LV ( pour les utiliser comme des partitions standard )

Création d'une partition LV ( Volume Logique )

lvcreate -n mapartition -L 4,95g MONGROUP

warning.png Attention à mettre une taille valide, elle ne doit en aucun cas être supérieur à l'espace disponible ( risque de pertes ).

La partition maintenant créée, dernière étape avant de l'exploiter, le formatage .

Formatage de la partition mapartition

mkfs -t ext4 /dev/MONGROUP/mapartition

Et voilà notre volume prêt à l'emploi .

Ne reste plus qu'à le monter .. et l'exploiter ..

mount -t ext4 /dev/MONGROUP/mapartition /mnt

Je vous vois déjà venir en me disant .. que jusqu'à maintenant .. il n'y a pas d'avantage à utiliser LVM ... C'est vrai , créer simplement une partition et la formater directement serait tout aussi performant et bien plus rapide à mettre en place ..

Ok, alors le temps passe et tout d'un coup vous recevez mail de votre client indiquant avoir reçu plusieurs alerte concernant l'espace disponible sur le disque .. aïe !

Pas de panique puisque vous avez pris la peine de créer une partition géré par LVM, dans notre cas il suffira d'augmenter la taille de notre disque virtuel ( ou d'en créer un second ) et de l'ajouter à notre groupe de volumes MONGROUP

Augmenter la capacité du volume

Voyons comment faire cette manip en 5 minutes.

Dans un premier temps il faut démonter le volume avec la commande umount

Démonter le volume à modifier

umount /mnt

Puis il nous faut créer une nouvelle partition ( à partir du nouveau disque ou de l'espace disponible sur le disque virtuel sdb 5G de plus )

cfdisk /dev/sdb

info.png La nouvelle partition sera déclarée comme étant sdb2 ( à adapter dans votre cas )

Une fois la partition créée, nous allons la déclarer à LVM

pvcreate /dev/sdb2

Nous allons ensuite étendre notre groupe de volumes ( MONGROUP ) afin qu'il prenne en compte ma nouvelle partition , et de ce fait , offrir autant d'espace en plus.

Extension du groupe de volumes

vgextend MONGROUP /dev/sdb2

Voilà qui est fait. Nous allons vérifier la partition existante avant de la redimensionner

Vérification de la partition existante

e2fsck -f /dev/MONGROUP/mapartition

Une fois terminé, l'étape la plus importante , le redimensionnement de la partition . Pour commencer nous allons redimensionner notre volume logique ( LV ) mapartition

Redimensionnement de mapartition ( LV )

lvresize -L9,95g /dev/MONGROUP/mapartition

warning.png Attention à mettre une taille valide, elle ne doit en aucun cas être supérieur à l'espace disponible ( risque de pertes ).

Enfin, le volume logique redimensionné, reste à redimensionner notre système de fichiers ext4

Redimensionnement du système de fichiers ext4

resize2fs /dev/MONGROUP/mapartition

Et voilà mon espace disque vient d'augmenter de 5Go . Cette opération peut être répété autant de fois que nécessaire .

lvm2.png

Ch.

14 sept. 2010

Git pour une petite équipe

header.gif Un billet sans prétention , qui explique comment mettre en place GIT sur un serveur pour partager les sources entres développeurs afin de permettre le travail en équipe sans risquer de se marcher dessus .

Installation

Cette étape est la même sur les postes clients et sur le serveur .

L'installation est très simple , dans un premier temps vérifier que les paquets suivants sont bien installé :

apt-get install curl-devel expat-devel gettext-devel openssl-devel zlib-devel

Une fois fait ,

apt-get install git-core

Votre identité

Il vous faut ( sur chaque poste client ) définir au moins deux paramètres qui permettrons de vous identifier à chaque commit , il est donc important de les initialiser .

cd ~
git config --global user.name "Mon nom"
git config --global user.email [email protected]

Nous voilà maintenant prêt à utiliser git .

Créer l'utilisateur git

Pour simplifier les étapes suivantes ( connexion ssh ) nous allons créer tout de suite l'utilisateur **git**

sudo adduser git

Nous allons limiter les possibilités de ce nouvel utilisateur sur le serveur , pour celà , nous allons lui attribuer un autre interpréteur de commande .

sudo vim /etc/passwd

Remplacer /bin/bash à la ligne ( selon l'interpréteur par défaut )

git:x:1002:1003:,,,:/home/git:/bin/bash

par

git:x:1002:1003:,,,:/home/git:/usr/bin/git-shell

Créer un Dépôt vierge sur le serveur

Voilà une étape importante et indispensable pour ce que nous souhaitons faire .
Rendez-vous sur votre serveur de développement , dans le répertoire qui contiendra les dépôts .

su git
cd /var/www/depotsGit
mkdir monProjet.git
git --bare init 

Et voilà votre dépôt est bien créé.

Accès ssh

Afin de na pas avoir à rentrer le mot de passe de git à chaque "push" nous allons mettre en place l'authentification ssh par certificats .
Suivez les étapes suivantes :

Sur votre poste utilisateur

Génération des clef

N'entrer ni passphrase ni mot de passe , passer les étapes en tapant "enter" ...

cd ~
ssh-keygen -t rsa 

Copie de la clef public

Copier le contenu de se fichier

vim ~/.ssh/id_rsa.pub

Sur le serveur

Nous allons ajouter la clef public au compte git .

su git
cd ~
mkdir .ssh
vim authorized_keys

Copier la clef public dans de fichier , enregistrez et quittez .

Répéter cette étape ( copier-coller de clef publique ) pour chaque poste qui doit avoir un accès aux dépôt GIT .

Premier git push

Retournez sur votre machine ( poste utilisateur ) , vérifiez tout de même que vous avez un accès ssh sans mot de passe

ssh [email protected]

Vous devriez avoir un message de ce type :

fatal: What do you think I am? A shell?
Connection to golum closed.

Si c'est la cas bravo tout va bien , sinon, revoyez le passage clef ssh/public.

Nous allons maintenant nous occuper de nos fichiers sources , rendez-vous dans le répertoire qui va contenir vous sources .

mkdir /var/www/monSite
cd /var/www/monSite

Le répertoire est pour le moment vide , nous allons donc créer un premier fichier , **.giignore** qui vous servira peut être plus tard ( vous pouvez créer ce que vous voulez comme fichier , j'utilise .gitignore car quite à faire un test , autant faire quelque chose qui me servira :) )

Initialisation du dépôt local

Il nous faut initialiser notre dépôt local , afin que **git** gère les fichiers de ce répertoire .

touch .gitignore
git init
git add .
git commit -a -m "Initialisation Dépôt local"

Et voilà , vous avez désormais un dépôt local sur lequel vous pouvez gérer vos versions , vos branches ect .. bref utiliser toute la puissance de GIT.

Synchronisation avec le serveur de dépôts

Étape importante maintenant puisque nous souhaitons rendre nos sources public ( enfin public pour les postes qui auront copié leur clef public sur le serveur )

cd /var/www/monSite
git remote add origin [email protected]:/var/www/depotsGit/monProjet.git
git push origin master

Cette dernière ligne aura pour effet d'envoyer les modifications dans le dépôt sur le serveur sur a branche "master".

Chaque développeur déclaré dans authorized_keys peut maintenant cloner le dépôt à partir du serveur , mais aussi envoyer leurs modifications .
Par exemple , si je veux cloner le dépôt actuel et donc récupérer le fichier **.gitignore** que vous avez posté .

cd /var/www/
git clone [email protected]:/var/www/depotsGit/monProjet.git

Fin

Je vous laisse lire les nombreux tutoriaus concernant les commandes de bases de GIT , pour ajouter supprimer renommer les fichiers branches ect ...

www.deimos.fr
www.alexgirard.com
www.siteduzero.com
www.unixgarden.com

- page 1 de 6