DACL/SACL & ACE ?

Avant de rentrer dans le vif du sujet, il est important de bien comprendre les listes d’accès Active Directory. Une liste de contrôle d’accès (ACL) est une liste d’entrées de contrôle d’accès (ACE). Chaque ACE dans une ACL identifie un "trustee" (Un compte utilisateur, un groupe, ou une session sur lequel un accès de controle (ACE) s’applique) et précise les droits d’accès autorisés, refusés ou vérifiés pour l’administrateur. Le descripteur de sécurité (security descriptor) pour un objet sécurisé peut contenir deux types d’ACL: une DACL et une SACL.

Une DACL (Discretionary access control list) identifie les "trustees" qui sont autorisés ou non à accéder à un objet. Quand un processus essaie d’accéder à un objet, le système vérifie l’ACE dans la DACL de l’objet pour déterminer s’il faut accorder l’accès. Si l’objet n’a pas de DACL, le système autorise l’accès complet à tout le monde. Si la DACL de l’objet n’a pas de ACE, le système refuse toutes les tentatives pour accéder à l’objet parce que la DACL ne permet pas de droits d’accès. Le système vérifie l’ACE dans l’ordre jusqu’à ce qu’il trouve une ou plusieurs entrées de contrôle qui permettent à tous les droits d’accès requis, ou jusqu’à ce que l’un des droits d’accès demandé soit refusé.

Une SACL (System access control list) permet aux administrateurs de logger les tentatives d’accéder à un objet. Chaque ACE précise les types de tentatives d’accès par un "trustee" qui a causé la génération d’un enregistrement dans le journal des évènements de sécurité. Une ACE dans une liste SACL peut générer des enregistrements d’audit lors d’une tentative d’accès échoue, quand elle réussit, ou les deux.

Rentrons maintenant dans le sujet, jouons avec les droits standard, les droits étendus, ou les droits spécifiques. Pour l’affection de droits, la classe System.DirectoryServices.ActiveDirectoryAccessRule sera utilisé. Commençons par découvrir les constructeurs. Si vous êtes allergique à MSDN, utilisons la commande suivante:

[System.DirectoryServices.ActiveDirectoryAccessRule].GetConstructors()

Les droits standards

Commençons par les droits standards, en récupérant le SID de l’utilisateur qui recevra la délégation:

$Login = "Utilisateur-Test"   
$NTAccount = New-Object system.security.principal.ntaccount($Login)    
$SID = $NTAccount.translate([system.security.principal.securityidentifier])

Ajoutons maintenant les droits AD en utilisant le constructeur:

.ctor(    
    System.Security.Principal.IdentityReference    
    System.DirectoryServices.ActiveDirectoryRights    
    System.Security.AccessControl.AccessControlType    
)

Spécifions les droits a ajouter et spécifions le type d’accès

$rights = "GenericAll"    
$AccessType = "Allow"

Ajoutons les droits et sauvegardons l’objet

$root = [adsi]"LDAP://RootDSE"    
$OU = [adsi]"LDAP://ou=OU-Test,"+$root.distinguishedName    
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($SID, $rights, $AccessType)    
$OU.psbase.get_objectsecurity().AddAccessRule($ace)    
$OU.psbase.CommitChanges()

Les droits étendus

Passons maintenant aux droits étendus ainsi qu’aux droits spécifiques, nous allons utiliser le constructeur suivant:

.ctor(    
    System.Security.Principal.IdentityReference    
    System.DirectoryServices.ActiveDirectoryRights    
    System.Security.AccessControl.AccessControlType    
    System.Guid    
    System.DirectoryServices.ActiveDirectorySecurityInheritance    
)

Pour les droits étendus, il est nécessaire de récupérer le GUID du droit (stocké dans la partition de configuration) stocké dans l’attribut "rightsGUID". Pour ce faire, je vous propose la fonction suivante:

function Get-RightsGUID    
{    
    Param ($ExtendedRight, $dse)    
    
    $ER = [adsi]("LDAP://cn=Extended-Rights,"+$dse.configurationNamingContext)    
    $OU = [adsi]("LDAP://cn="+$ExtendedRight+","+$ER.distinguishedName)    
    [system.guid]$guid = $OU.rightsGUID    
    return $guid.ToString()    
}

Pour l’utiliser :

$guid = Get-RightsGUID "Change-PDC" $root

Même principe que précédemment pour les droits standards:

$Login = "Utilisateur-Test"    
$NTAccount = New-Object system.security.principal.ntaccount($Login)    
$Rights = "ExtendedRight"    
$AccessType = "Allow"    
$Inherit = [System.DirectoryServices.ActiveDirectorySecurityInheritance]"All"    
$ace    = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($NTAccount, $Rights, $AccessType, $guid, $Inherit)    
$OU.psbase.get_objectSecurity().AddAccessRule($ace)    
$OU.psbase.CommitChanges()

Les droits spécifiques

Pour les droits spécifiques, il est nécessaire de récupérer le GUID du droit (stocké dans la partition "schéma") stocké dans l’attribut "schemaIDGUID". Pour ce faire, je vous propose la fonction suivante:

function get-schemaGUID    
{    
    Param ($OU, $dse)

    $obj = [adsi]"LDAP://cn="+$OU+","+$dse.schemaNamingContext   
    [system.guid]$guid = $obj.schemaIDGUID[0]    
    return $guid.ToString()    
}

Pour l’utiliser:

$guid = get-schemaGUID "computer" $root

Même principe que précédemment:

$Login = "Utilisateur-Test"    
$NTAccount = New-Object system.security.principal.ntaccount($Login)    
$Rights = “ReadProperty, WriteProperty”    
$AccessType = "Allow"    
$Inherit = [System.DirectoryServices.ActiveDirectorySecurityInheritance]"All"    
$ace    = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($NTAccount, $Rights, $AccessType, $guid, $Inherit)    
$OU.psbase.get_objectSecurity().AddAccessRule($ace)    
$OU.psbase.CommitChanges()

Voila qui conclu cette introductions aux ACL Active Directory. Vous trouverez plus d’informations sur la gestion de l’Active Directory en .NET sur MSDN

Pour palier à ça, je vous propose un script permettant de « dumper » dans un répertoire les fichiers plus gros qu’une taille définie, et de les supprimer du mail qui les contient, sans supprimer le mail en question.

Côté serveur en utilisant la console MMC Exchange Management Shell, les informations récupérées sont assez peu convaincantes, et surtout trop peu complètes pour pouvoir être exploitées.

L’avantage des produits Microsoft sont les synergies possibles entre ceux ci. Exploiter Outlook via Powershell est d’une simplicité déconcertante.

param(
    [int]$MaxSize = $(throw "Please specify size of max file"),
    [string] $DeleteAttachedFiles = $false
    )

# Attached files will be saved in this folder
$AttachmentsFolder = "C:\tmp\"

# Check folder existence
if (-not (test-path $AttachmentsFolder) )
{
    New-Item -ItemType Directory $AttachmentsFolder | out-null
}

# Attached files list
$ResultList = @()

# Create an outlook object
$OutlookObj = New-Object -ComObject Outlook.Application
$objNamespace = $OutlookObj.GetNamespace("MAPI")
$objFolder = $objNamespace.GetDefaultFolder(6)

# Get all items
$Items = $objFolder.Items 

# Items - Loop
foreach ($item in $Items)
{
    # Check if any file is attached
    if ($item.Attachments) { 

        # Attachments - Loop
        $item.Attachments | % {
            $FileName = $_.FileName
            $SavedName = join-path $AttachmentsFolder $FileName

            # Check size
            if( $($_.size) -ge $MaxSize )
            {
                # Save file
                $_.SaveAsFile($SavedName)

                $Result = new-Object -typename System.Object
                $Result | add-Member -memberType noteProperty -name "Subject" $Subject
                $Result | add-Member -memberType noteProperty -name "FileName" $FileName
                $Result | add-Member -memberType noteProperty -name "Size (Mb)" $(($_.size/1mb).tostring("0.000"))
                $ResultList += $Result

                if ($DeleteAttachedFiles -eq $true)
                {
                    # Delete attachment
                    $_.delete()
                    $item.save()
                    write-host "[Deleted] [$Subject] [$(($_.size).tostring("0.000"))] $FileName"
                }   

            }

        }
    }
}

# Close Outlook
$OutlookObj.quit()

$ResultList | sort size

Une bride d’explications, l’objet $item est le mail en court de traitement, cet objet possède la propriété « Attachments » qui renvoie les pièces jointes du message. Les objets pièces jointes peuvent ensuite être utilisées en utilisant les méthodes « SaveAsFile » ou « Delete »

Une fois la pièce jointe supprimée du message, regardons les méthodes disponibles pour cet objet:

La méthode « Save » permet de faire ça!

Le script accepte deux paramêtres:
- La taille au dessus de laquelle les fichiers seront dumpés
- Le paramètre de suppression (non mandatory), par default défini à $false. Si ce paramètre n’est pas défini, le script n’effectuera que le dump des fichiers, et ne les supprimeras pas de la boite aux lettres.

Exemple 1:
script.ps1 2mb -> Dumperas les fichiers, aucune suppression

Exemple 2:
script.ps1 2mb $true -> Dumperas les fichiers, et supprimera les pièces jointes

$DNGroup = [Completer]
$dom = New-Object DirectoryServices.DirectoryEntry("LDAP://$DNGroup")

Les méthodes de l’objet $dom peuvent maintenant etre utilisées:

$dom | get-member

Il est maintenant assez facile de lister les membres

$dom.member

Pour ajouter un utilisateur, il faut maintenant utiliser la methode add en passant en parametre le distringuishedName de l’utilisateur. Voila ce que ça donne

$dom.member.Add($DNUser)
$dom.setInfo()

Dans le cas d’une connexion à un domaine non trusté. Il est nécessaire de recupérer les credentials de l’utilisateur

$cred = get-credential

Notre mot de passe est maintenant chiffré, mais la création d’un objet directory entry nécessite que le mot de passes ne soit pas chiffré. Pas de probleme, powershell fournis une méthode pour le faire

$pwd = [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($cred.Password))

Et maintenant, il ne reste plus qu’à recreer l’objet directory entry en passant en parametre, la chaine ldap, le username ainsi que le mot de passe

$dom = New-Object DirectoryServices.DirectoryEntry("LDAP://$domain/$DNGroup",$cred.UserName,$pwd)

Considérons maintenant que nous nous trouvons dans un domaine (DomaineA) et un autre domaine, qui sera trusté (DomaineB). Admettons maintenant que nous souhaitions ajouter dans un groupe de DomaineA, un utilisateur de DomaineB. Si nous utilisons la méthode vu plus haut

$dom.member.Add($DNUser)
$dom.setInfo()

Lors du setinfo une erreur se produira, car il n’est pas possible d’ajouter une utilisateur d’un domaine étranger en passant son DN.

Il est nécessaire de passer par son SID. Pour recuperer le SID d’un utilisateur, il faut faire comme suit:

$User = "Domaine\Utilisateur"
$AccountSID = ((New-Object System.Security.Principal.NTAccount($User)).Translate([System.Security.Principal.SecurityIdentifier])).Value

Une fois le SID recupéré, il est maintenant possible de l’ajouter dans le groupe en forgeant sa chaine ldap comme suit :

$LDAP = "LDAP:// < SID=$AccountSID>"
$dom.member.Add($LDAP)
$dom.setInfo()

Et voila qui conclu pour cet article sur la gestion des groupes AD en powershell

Le but étant de pouvoir générer des graphs de ce type

Ce dont on a besoin :

• PowerShell V1 (ou supérieur)
• Framework .NET 3.5
• Microsoft Chart Controls

Première étape, on importe les assemblies

[void][Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
[void][Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms.DataVisualization")

Pour générer notre graph nous allons simuler un traitement par lot ayant retourné des codes retours de 3 types: OK, ERROR, UNKNOW

$nbError = random(1..10)
$nbOK = random(1..3)
$nbUnknow = random(1..10)

$labelError = "Erreur ("+$nbError.toString()+")"
$labelOK = "OK ("+$nbOK.toString()+")"
$labelUnknow = "Unknow ("+$nbUnknow.toString()+")"

Nous créons une liste contenant nos labels ainsi que le nombre qui lui est associé en fonction de son type

$resultList = @{$labelError=$nbError.toString();
$labelOK=$nbOK.toString();
$labelUnknow=$nbUnknow.toString(); }

Nous créons maintenant l’objet graph et définissons sa taille

$Chart = New-object System.Windows.Forms.DataVisualization.Charting.Chart
$Chart.Width = 500
$Chart.Height = 400
$Chart.Left = 50
$Chart.Top = 30

On crée ensuite un chartarea dans lequel on ajoutera le graph

$ChartArea = New-Object System.Windows.Forms.DataVisualization.Charting.ChartArea
$Chart.ChartAreas.Add($ChartArea)

On ajoute les données du graph à partir de la liste

[void]$Chart.Series.Add("Data")
$Chart.Series["Data"].Points.DataBindXY($resultList.Keys, $resultList.Values)

On définit le type de graph

$Chart.Series["Data"].ChartType = [System.Windows.Forms.DataVisualization.Charting.SeriesChartType]::Pie

On définit ensuite les couleurs pour les données du  graph. Par exemple ici, nous définissons que la valeur minimum sera en rouge (et max en bleu) en utilisant la méthode FindMinByValue FindMaxByValue)

$maxValuePoint = $Chart.Series["Data"].Points.FindMaxByValue()
$maxValuePoint.Color = [System.Drawing.Color]::lightblue
$minValuePoint = $Chart.Series["Data"].Points.FindMinByValue()
$minValuePoint.Color = [System.Drawing.Color]::Red

On définit les options du graph

$Chart.Series["Data"]["PieLabelStyle"] = "Outside"
$Chart.Series["Data"]["PieLineColor"] = "Black"
$Chart.Series["Data"]["PieDrawingStyle"] = "Concave"
($Chart.Series["Data"].Points.FindMaxByValue())["Exploded"] = $true

Pour afficher le graph, il est nécessaire de créer un objet de type Windows.Form.Form dans lequel on ajoutera l’objet graph

$Form = New-Object Windows.Forms.Form
$Form.Text = "Powershell/MSChart"
$Form.Width = 600
$Form.Height = 500
$Form.controls.add($Chart)
$Form.Add_Shown({$Form.Activate()})
$Form.ShowDialog()

Et voila le résultat

Pour plus d’informations sur MSChart je viens invite a visiter cette page ou vous pourrez aussi trouver des samples (vbs/C#)

Appeler des fonctions PowerShell depuis du WPF

De la même façon, il est possible d’utiliser du WPF depuis PowerShell en important les assemblies adaptées. Dans cet exemple nous allons créer un mini Task-Manager permettant d’afficher les ressources utilisées par un processus.

On importe l’assembly

[Reflection.Assembly]::LoadWithPartialName("PresentationFramework")

Il est nécessaire de créer une interface en XAML pour notre interface, Expression blend est parfait pour faire ça

On stocke le code XAML généré par blend

$xaml = [xml]'

Selectionner un process

'

On récupère la liste des processus en cours d’exécution. Pour simplifier la suite du code, je fais fi des doublons en utilisant le pipe unique

$Processes = Get-Process | unique | Sort-Object -Property WS | Select-Object Name,WS,ID
$ProcNames = @(foreach($Proc in $Processes){$Proc.Name})

On utilise le code XAML pour créer notre fenêtre

$XAML=(New-Object System.Xml.XmlNodeReader $xaml)
$XAMLR=[Windows.Markup.XamlReader]::Load($XAML)

On bind nos variables

$PR = $Form.FindName('ComBoxProcess')
$OU = $Form.FindName('TextBoxProcess')

On itére sur les processus pour les ajouter à notre liste

foreach ($row in $ProcNames) {
[void]$PR.Items.Add($row)
}

On utilise la méthode add_SelectionChanged pour que lorsque qu’un processus différent est sélectionné, le TextForm soit actualisé avec les bonnes données.

$PR.add_SelectionChanged({
$OU.clear()
$Proc = Get-Process -Name $PR.SelectedItem | unique
$disp = (($Proc.WS)/1MB).tostring()
$disp +=" MB"+[environment]::NewLine
$disp += ($Proc.Handles).tostring()
$disp +=" Handles"+[environment]::NewLine
$OU.AppendText($disp)
})

Et enfin, on affiche !

[void]$XAMLR.ShowDialog()

Et voila le résultat

Voila pour cette introduction aux interfaces et au graph au travers de Powershell, dans un prochain billet, je reviendrais plus en détail sur les synergies .NET/Powershell

Mais revenons en à SharePoint Server 2010. Il ne sera utilisable que sur un Windows Server 2008 (64bits) ou Windows Server 2008 R2 (64 bits) et nécessitera obligatoirement un SQL Server 2005 ou 2008 (en 64 bits là encore).

Par ailleurs, nous apprenons que les navigateurs compatibles avec la nouvelle mouture seront Explorer 7+ et Firefox 3+ ainsi que Safari 3+ afin de respecter les standards XHTML 1.0 (Je vous l’accorde Microsoft a toujours du mal a respecter les standards Web, et c’est encore le cas de IE 8).

En ce qui concerne Internet Explorer 6, l’équipe a annoncé qu’il ne sera pas officiellement supporté malgré qu’il représente encore aujourd’hui 20% des parts de marché des navigateurs (Mars 2009). Cependant, le support d’IE 6 s’arrêtera officiellement en juillet 2010.

VMware Converter permet entre autre de convertir des machines physiques locales et distantes en machines virtuelles, de réaliser plusieurs conversions simultanément, de convertir d’autres formats de machines virtuelles comme Microsoft Virtual PC/Microsoft Virtual Server ou des images de sauvegarde de machines physiques comme Symantec Backup Exec LiveState Recovery ou Ghost 9 en machines virtuelles VMware, ou encore de cloner et sauvegarder des machines physiques en machines virtuelles dans le cadre d’un plan de récupération d’urgence.

J’avais créé une machine virtuelle de Windows Server 2008 pour des déploiements d’OS, mais je me suis vite retrouvé à l’étroit avec seulement 10Go. Je vais vous présenter ici comment augmenter la taille du disque système

Tout d’abord il est nécessaire de lancer une vérification du disque à convertir afin de vérifier l’intégralité des blocs de celui-ci. Si le disque présente une ou plusieurs erreurs, la suite de la procédure échouera.

Une fois la vérification terminée, lancer VMware Converter, et choisissez « Convert Machine », sélectionnez « Other » puis spécifiez l’emplacement de votre machine virtuelle

Sélectionnez maintenant l’option « resize or add space » puis, renseignez le champ « New disk space » avec l’espace nécessaire pour votre utilisation.

Passez les quelques étapes suivantes en choisissant l’emplacement du fichier vmdk avec la nouvelle taille, puis terminez l’assistant. La conversion est maintenant en court

Une fois la conversion terminée, vérifiez le contenu des logs afin de confirmer qu’aucune erreur n’est présente

Votre fichier vmdk est créé. Ouvrez maintenant votre logiciel VMware Server ou Workstation puis, rendez vous dans les settings afin de spécifier l’emplacement de celui-ci

Et voila ! Votre machine virtuelle est prête a être utiliser

• SrvAsterisk-1 : 192.168.1.201
• SrvAsterisk-2 : 192.168.1.202
• L’adresse P virtuelle pour y accéder sera : 192.168.1.200

Nous allons dans cet article nous atteler a mettre en place une IP virtuelle qui assura une continuité de service lors de la perte d’un des serveurs.

Méthode 1 : Utilisation de Heartbeat

Tout d’abord il est nécessaire de l’installer : sudo apt-get install heartbeat

Sa configuration repose sur 3 fichiers :

• /etc/ha.d/ha.cf
• /etc/ha.d/haresources
• /etc/ha.d/authkeys

Voici en détail comment configurer ces trois fichiers.

• /etc/ha.d/ha.cf
  bcast eth0
  node SrvAsterisk-1
  node SrvAsterisk-2
  auto_failback off
  keepalive 2
  deadtime 30
  warntime 5
  initdead 60
  udpport 694
  debugfile /var/log/ha-debug
  logfile /var/log/ha-log

  Quelques éléments pour comprendre ce fichier de configuration :
  Bcast : Interface réseau
  Node : Spécifier ici vos serveurs a intégrer dans le cluster
  auto_failback : Si  » On  » lorsque SrvAsterisk-1 revient, il reprend le relai, si  » Off « , SrvAsterisk-2 continu l’intérim jusqu’à une intervention humaine
  Keepalive : Fréquence de pouls
  Deadtime : Temps avant qu’on considère que le node est HS
  Warntime : Temps avant d’envoyer une alerte
  Initdead : Temps avant que le 2nd serveur prenne le relai
  Udpport : Port utiliser entre les deux serveurs pour communiquer
  debugfile/logfile : Emplacement des logs

• /etc/ha.d/haresources (Identique sur les deux serveurs)
  SrvAsterisk-1Â IPaddr::192.168.1.200

  Nous définissons ici que le serveur principal est SrvAsterisk-1

• /etc/ha.d/authkeys
  auth 1
  1 md5 « !#@ClusterAsterisk/\ »
  2 crc

  Ce fichier contient le nécessaire pour que les deux serveurs puissent communiquer entre eux. Nous utilisons utiliser du md5 et la clé est  » !#@ClusterAsterisk/\ « .

Une fois toutes ces modifications effectuées il est nécessaire de relancer le service avec la commande : sudo /etc/init.d/heartbeat reload

Cependant, un pouls toute les deux secondes peut vite polluer votre réseau, c’est pourquoi je vous conseil grandement un lien dédié entre votre deux serveurs Asterisk.

Méthode 2 : Cron+Nmap+Arping

Gregg Hansen, auteur du site thiscoolsite a créé deux scripts (Flip1405) se plaçant en concurrent de Heartbeat. Je vous explique ici leurs fonctionnements.

Tout d’abord il est nécessaire de récupérer les deux fichiers

• SrvAsterisk-1
• SrvAsterisk-2

Ces fichiers sont configurés avec les IP spécifiés au début de ce post, il vous faut les changer pour adapter à vos serveurs. Copier chaque fichier sur le serveur adapté, puis éditer le contenu de contab (crontab –e)

• SrvAsterisk-1
  */2 * * * * /emplacement/fichier/flip1405_primary
• SrvAsterisk-2
  */2 * * * * /emplacement/fichier/flip1405_secondary

Et voila ! Vos scripts seront lancés toutes les deux minutes. Si votre serveur principal venait à tomber, le serveur secondaire prendra le relai jusqu’au retour du serveur principal.

Ceci clos cet article sur la mise en place d’une adresse IP virtuelle de notre cluster Asterisk. Mon prochain article traitera de la mise en place de la synchronisation des données (Compte SIP/Messagerie) entre les différents noeuds.

Cet article est les prémisses d’une série d’articles à venir sur Asterisk et sur sa mise en place via des solutions haute disponibilité (HA). Asterisk est un PABX open source pour systèmes GNU/Linux, publié sous licence GPL. Il permet, entre autres, la messagerie vocale, les conférences, les files d’attente, les agents d’appels, les musiques d’attente et bon nombre de fonctionnalités qui le placent au niveau des PBX les plus complexes.

Au sein des très grandes installations, il est courant de répartir les fonctionnalités sur plusieurs serveurs. L’un sera dédié au traitement des appels et celui-ci sera épaulé par des serveurs secondaires traitant d’autres tâches comme la base de données, les boîtes vocales ou les conférences. Pour des installations plus petites, un serveur suffisamment costaud est capable de gérer l’ensemble assez facilement et sera épauler par un serveur de backup.

Asterisk implémente les protocoles H.320, H.323 et SIP, ainsi que IAX (Inter-Asterisk eXchange). Ce protocole rend possible la communication entre un serveur est un client mais aussi la communication entre deux serveurs Asterisk en utilisant le port 4569 (en UDP) permettant de renvoyer les appels à partir d’un serveur Asterisk au travers d’IAX.

Il comprend de base un nombre très élevé de fonctions pour répondre à la majorité des besoins en téléphonie permettant ainsi de remplacer totalement, par le biais de cartes FXO/FXS, un PABX propriétaire, et d’y adjoindre des fonctionnalités de ToIP pour le transformer en IPPBX. Certains modules tiers permettent de visualiser ou paramétrer le PBX via une interface web ou via un client léger. Asterisk est extensible par des scripts ou des modules écrit en Perl, en Python, en C, voir en PHP permettant aux développeurs de l’adapter au maximum à ses besoins.

Exemple d’un cluster Asterisk

Les serveurs Asterisk en entreprise joue un rôle indispensable puisque l’ensemble de la téléphonie repose dessus. Il est donc vital d’avoir une solution haute disponibilité. Pour ce faire, certaines règles doivent être respectées, je vous en livre quelques une, mais elles sont loin d’être exhaustives.

• Ne JAMAIS monter un serveur Asterisk en production hors d’un cluster. Si votre serveur venait à flancher, ce serait la catastrophe. Un minimum de deux serveurs est nécessaire en fonction de la charge qui sera demandé. Cela permet de pouvoir mettre un serveur à jour pendant que l’autre/les autres continuent à fonctionner et d’assurer la continuité de service en cas de panne importante.
• Il est nécessaire d’effectuer des backups réguliers de vos serveurs. Il existe aujourd’hui bon nombres de solutions de clichés instantanés (même gratuites). Prévoyez aussi un plan de reprise après incident ! On ne sait jamaisÂ
• Monitorer vos serveurs en utilisant des outils adéquats par exemple Cacti, Nagios/Centreon, Zabbix, HP OpenView…Certains sont gratuits et permettent de monitorer et/ou gérer les pannes de façon efficace avec les remontées d’alarmes, voir même de les anticiper.
• Utiliser des outils de réplication/synchronisation pour garder vos différents serveurs à jour.
  • Heartbeat : Afin de pouvoir tester les nodes du cluster, chacune des machines va vérifier si les autres répondent toujours en prenant le pouls des autres. Si une machine cesse de fonctionner, les autres assurent le service.
  • DRBD : C’est un module pour le kernel implémentant un périphérique en mode bloc qui en plus d’écrire l’information sur le disque physique de la machine, la transmet à son homologue miroir qui se trouve sur l’autre (ou les autres serveurs). Cette solution permet la mise en miroir d’un disque complet.
  • RSYNC/CSYNC2 : Cette solution permet d’effectuer une synchronisation dans un intervalle de temps relativement court. Ce type de solution convient car les données ne changeant pas trop fréquemment. Attention cependant si elle est utilisée dans une très grosse installation la limitation de Rsync devient évidente. Même en synchronisant les serveurs toutes les 2 minutes, nous risquons de perdre des données modifiées durant cet intervalle. Attention dans certains cas, Rsync peut mettre vos serveurs à genoux. Cette solution est beaucoup plus facile à gérer et plus pratique si l’objectif est d’avoir un miroir sur simplement quelques répertoires
• Forcer la rotation de serveur tous les jours pour vérifier le bon fonctionnement. Si votre cluster est constitué d’un système Actif/Passif, forcer le failover chaque nuit, cela permettra de s’assurer que les deux serveurs fonctionnent. Il est aberrant de voir des systèmes sans rotation jusqu’au jour ou la bascule est faite, mais ça ne fonctionne pas…

Cela conclu cette introduction à Asterisk, dans les prochains articles, nous rentrerons plus dans la partie technique en mettant les mains dans le cambouis. Il sera nécessaire d’avoir de solides compétences des systèmes GNU/Linux afin de pouvoir effectuer ses manipulations. Si ce n’est pas le cas, Google regorge de bons nombres de tutoriaux en tout genre afin de se faire la mainÂ

]]> http://blog.chanliau.fr/2008/11/asterisk-en-entreprise/feed/ 2 http://blog.chanliau.fr/2008/11/asterisk-en-entreprise/ http://feedproxy.google.com/~r/Chanliau/~3/AvVMufxz9TY/ http://blog.chanliau.fr/2008/11/les-wafs/#comments Thu, 13 Nov 2008 21:27:50 +0000 Gauthier http://blog.chanliau.fr/?p=208 Jusqu’à peu la gestion des sites distants était un vrai calvaire pour les ressources informatiques d’une entreprise. Le coût actuel de cet éclatement informatique est jugé exorbitant par bon nombre d’entre elles que ce soit en termes de ressources, de matériel, ou de prestations. Les architectures montrant souvent trop d’hétérogénéité, augmentant les coûts liés à la prestation externe et à l’utilisation des ressources internes. Ils engendrent par ailleurs des coûts d’administration importants notamment pour l’exécution des procédures de sauvegarde ainsi que pour les coûts de maintenance.

Pour faire face à ces couts, l’idée a été de centraliser les données, les bases de données, les serveurs antivirus et de messagerie ainsi que les applications métiers dans un seul est même lieux, dans un Datacenter. Mais cette solution conduit le plus souvent à diminuer fortement les performances du réseau pour les utilisateurs. Les temps d’accès aux ressources ainsi que les besoins en bande passante sur la partie WAN du réseau explosent. En effet les protocoles de gestion de fichiers n’ayant pas été conçu pour une utilisation WAN, ils se révèlent être très bavard et donc très gourmands. Mais heureusement les WAFS ont fait leur apparition.

Qu’est ce qu’est concrètement ? La technologie Wide Area Files Services (WAFS) apporte une réponse aux problématiques WAN de latence, de fiabilité aléatoire et de liens congestionnés des réseaux, dont peuvent parfois souffrir les utilisateurs des sites distants. Elle vise à réduire les coûts télécoms (en bande passante), les coûts informatiques (moins de serveurs) ainsi que la complexité liée à l’administration du réseau et des serveurs de l’entreprise.

Pour bien comprendre l’architecture le plus simple est encore un schéma. Celui-ci fait fi d’un site de secours pour le Datacenter puisque simplifié au maximum, cependant la centralisation des données présente un risque, il doit impérativement être prévu pour assurer une continuité de service en cas de problème.

Chaque appliance WAFS communique avec les PC (client ou serveur) au travers d’un protocole tel que CIFS ou NFS. Par contre les échanges entre les appliances utilisent un protocole dédié, optimisé pour les réseaux WAN. Ce protocole, associé à un certain nombre d’optimisation, permet au WAFS d’éliminer les principaux facteurs de latence.

Selon Packeteer le WAFS permet de diviser les temps d’attente pour l’accès au fichier par 10 lors qu’il s’agit du premier accès, et même plus encore dans le cas des accès suivants grace à son système de cache.

Quels avantages pour cette technologie ?

• Virtualisation des fichiers et des services
• Suppression des serveurs sur les sites distants
• Technologie transparente pour les utilisateurs
• Sécurité optimale des données
• Diminué au maximum les allers et venu sur ces sites distants pour des interventions
• Libéré du temps aux équipes informatiques pour d’autres projets

La technologie WAFS, qui, comme nous venons de le voir répond à de vrais besoins se présente sur des systèmes tournant sur une base Linux ou Windows Storage Server. Nous parlons bien ici de technologie et non de protocole, ce qui implique que chaque constructeur est libre de rajouter des fonctions à son appliance pouvant faire la différence en fonction de l’entreprise.

Nous allons ici déployer un Ubuntu 8.04 x86. Je vous invite bien évidemment à ne pas troller dans les commentaires sur les différentes distrib

Pré-requis:

• WDS installé. (Sinon, vous pouvez utiliser ce tutorial)
• IIS installé et configuré.

Fichiers nécessaires:

• Un CD d’Ubuntu (Version alternate, elle ouvre une souplesse, et permet une automatisation)
  http://www.ubuntu-fr.org/telechargement
• Un Kickstart. Ce kickstart correspond au fichier unattend.txt de Windows. Libre à vous de le modifier pour changer le langue, la résolution ainsi que toutes les options.
  http://blog.chanliau.fr/wp-content/uploads/2008/10/kickstartscript.zip
  
• Un fichier default contenant les paramètres pour le déploiement.
  http://blog.chanliau.fr/wp-content/uploads/2008/10/default
• Syslinux. Il contient pxelinux
  http://www.kernel.org/pub/linux/utils/boot/syslinux/syslinux-3.71.zip
• Une image d’arrière-plan sympa

Partie 1:Â Config de IIS

1. Dans les paramètres de IIS
   
   1. Créer un répertoire virtuel nommé Ubuntu (par ex. E:ISOUbuntuSysteme)
      

      Dans la partie configuration du répertoire virtuel de Ubuntu pour les types MIME, ajouter l’extension . * avec comme type MIME « text/plain » ainsi que .cfg
      

   2. Créer un second répertoire virtuel nommé kickstart (par ex E:ISOUbuntuKickstart)
      
      
2. Extraire le CD Ubuntu dans le répertoire de votre choix (ici E:ISOUbuntuSysteme).
   Attention cependant, c’est un ISO 9660. Utiliser MagicISO pour ne pas avoir le problème des 255 caractères.
3. Placer le kickstart (fichier Ubuntu_Desktop_32.cfg) dans votre dossier kickstart (ici E:ISOUbuntuKickstart). Le mot de passe chiffré est « ubuntu ».

Partie 2: Config de WDS

1. Copiez les fichiers initrd.gz et linux du dossier
   E:ISOUbuntuSystemeinstallnetbootubuntu-installeri386
   vers E:RemoteInstallBootx86Hardy32
2. Extraire syslinux (cf. FN), et copier dans le répertoire E:RemoteInstallBootx86
   syslinux-3.71com32menuvesamenu.c32
   syslinux-3.71corepxelinux.o
   Puis renommer pxelinux.o en pxelinux.com dans ce dernier.
3. Placer votre image d’arrière-plan (cf. FN) dans E:RemoteInstallBootx86
   Cette image doit se nommer: “DeploymentBackground.png”
4. Dans le dossier E:RemoteInstallBootx86, faire une copie de pxeboot.n12 et le renommer en pxeboot.0
5. Configurer WDS pour qu’il utilise le fichier de démarrage pxelinux.com (Dans « propriétés du serveur » / « onglet démarrer »)
   
6. Dans le dossier E:RemoteInstallBootx86, créez un dossier appelé pxelinux.cfg
7. Dans le dossier E:RemoteInstallBootx86pxelinux.cfg, placer le fichier default (cf. FN)

Et voila, vous pouvez déployer des stations Ubuntu depuis un serveur Windows…Elle est pas belle la vie ?