Comment déployer des polices personnalisées sur des appareils Windows à l'aide de Microsoft Intune

Tout d'abord, vous avez besoin de l'outil de packaging officiel de Microsoft pour convertir votre déploiement de polices en un package compatible avec Intune.

Accédez au dépôt GitHub officiel de Microsoft et téléchargez le dernier Win32 Content Prep Tool :

# Télécharger depuis : https://github.com/Microsoft/Microsoft-Win32-Content-Prep-Tool
# Extraire IntuneWinAppUtil.exe vers C:\Tools\Intune

Créez un répertoire de travail pour votre projet de déploiement de polices :

New-Item -Path "C:\FontDeployment" -ItemType Directory -Force
New-Item -Path "C:\FontDeployment\fonts" -ItemType Directory -Force

Vérification : Exécutez C:\Tools\Intune\IntuneWinAppUtil.exe pour confirmer que l'outil se lance et affiche les informations d'utilisation.

Créez le script d'installation principal qui copiera les polices dans le répertoire des polices de Windows et les enregistrera dans le registre système.

Créez installfonts.ps1 dans votre répertoire FontDeployment :

# installfonts.ps1
$ErrorActionPreference = "Stop"
$LogPath = "C:\Windows\Temp\FontInstall.log"

# Démarrer la journalisation
Start-Transcript -Path $LogPath -Append

try {
    # Obtenez tous les fichiers de polices du sous-répertoire des polices
    $fonts = Get-ChildItem -Path ".\fonts" -Include *.ttf,*.otf -Recurse
    $fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
    
    Write-Host "Trouvé $($fonts.Count) fichiers de polices à installer"
    
    foreach ($font in $fonts) {
        $fontName = [System.IO.Path]::GetFileNameWithoutExtension($font.Name)
        $fontFileName = $font.Name
        $destinationPath = "C:\Windows\Fonts\$fontFileName"
        
        # Vérifiez si la police existe déjà
        if (-not (Test-Path $destinationPath)) {
            Write-Host "Installation de la police : $fontName"
            
            # Copier le fichier de police dans le répertoire des polices de Windows
            Copy-Item $font.FullName $destinationPath -Force
            
            # Enregistrer la police dans le registre
            $regName = "$fontName (TrueType)"
            if ($font.Extension -eq ".otf") {
                $regName = "$fontName (OpenType)"
            }
            
            New-ItemProperty -Path $fontRegPath -Name $regName -Value $fontFileName -PropertyType String -Force
            Write-Host "Police enregistrée : $regName"
        } else {
            Write-Host "Police déjà installée : $fontName"
        }
    }
    
    # Créer un marqueur de succès
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    "Installation des polices terminée avec succès à $timestamp" | Out-File "C:\Windows\Temp\FontInstallSuccess.txt" -Force
    
    Write-Host "Installation des polices terminée avec succès"
    exit 0
    
} catch {
    Write-Error "Échec de l'installation des polices : $($_.Exception.Message)"
    exit 1
} finally {
    Stop-Transcript
}

Vérification : Enregistrez le script et vérifiez que la taille du fichier est supérieure à 0 octet. Le script devrait faire environ 2 Ko.

Créez le script de désinstallation qui supprime les polices et nettoie les entrées de registre lorsque l'application est désinstallée.

Créez uninstallfonts.ps1 dans votre répertoire FontDeployment :

# uninstallfonts.ps1
$ErrorActionPreference = "Stop"
$LogPath = "C:\Windows\Temp\FontUninstall.log"

# Commencer la journalisation
Start-Transcript -Path $LogPath -Append

try {
    # Définissez vos polices personnalisées à supprimer (personnalisez cette liste)
    $customFontNames = @(
        "YourCompanyFont-Regular.ttf",
        "YourCompanyFont-Bold.ttf",
        "YourCompanyFont-Italic.ttf"
        # Ajoutez plus de noms de fichiers de polices si nécessaire
    )
    
    $fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
    
    foreach ($fontFileName in $customFontNames) {
        $fontPath = "C:\Windows\Fonts\$fontFileName"
        $fontName = [System.IO.Path]::GetFileNameWithoutExtension($fontFileName)
        
        # Supprimer le fichier de police
        if (Test-Path $fontPath) {
            Remove-Item $fontPath -Force
            Write-Host "Fichier de police supprimé : $fontFileName"
        }
        
        # Supprimer les entrées de registre
        $regEntries = Get-ItemProperty -Path $fontRegPath | Get-Member -MemberType NoteProperty | Where-Object { $_.Name -like "*$fontName*" }
        
        foreach ($entry in $regEntries) {
            try {
                Remove-ItemProperty -Path $fontRegPath -Name $entry.Name -ErrorAction SilentlyContinue
                Write-Host "Entrée de registre supprimée : $($entry.Name)"
            } catch {
                Write-Warning "Impossible de supprimer l'entrée de registre : $($entry.Name)"
            }
        }
    }
    
    # Supprimer le marqueur de succès
    Remove-Item "C:\Windows\Temp\FontInstallSuccess.txt" -Force -ErrorAction SilentlyContinue
    
    Write-Host "Désinstallation des polices terminée avec succès"
    exit 0
    
} catch {
    Write-Error "Échec de la désinstallation des polices : $($_.Exception.Message)"
    exit 1
} finally {
    Stop-Transcript
}

Vérification : Personnalisez le tableau $customFontNames avec vos noms de fichiers de polices réels et enregistrez le script.

Le script de détection indique à Intune si les polices sont installées avec succès sur l'appareil cible. Cela est crucial pour une surveillance correcte du déploiement.

Créez DetectionCheck.ps1 dans votre répertoire FontDeployment :

# DetectionCheck.ps1
$ErrorActionPreference = "SilentlyContinue"

# Définissez vos fichiers de polices à vérifier (doit correspondre à vos fichiers de polices réels)
$requiredFonts = @(
    "YourCompanyFont-Regular.ttf",
    "YourCompanyFont-Bold.ttf",
    "YourCompanyFont-Italic.ttf"
)

$allFontsInstalled = $true
$fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"

foreach ($fontFile in $requiredFonts) {
    $fontPath = "C:\Windows\Fonts\$fontFile"
    $fontName = [System.IO.Path]::GetFileNameWithoutExtension($fontFile)
    
    # Vérifiez si le fichier de police existe
    if (-not (Test-Path $fontPath)) {
        $allFontsInstalled = $false
        break
    }
    
    # Vérifiez si la police est enregistrée
    $regEntries = Get-ItemProperty -Path $fontRegPath -ErrorAction SilentlyContinue
    $fontRegistered = $false
    
    foreach ($property in $regEntries.PSObject.Properties) {
        if ($property.Name -like "*$fontName*" -and $property.Value -eq $fontFile) {
            $fontRegistered = $true
            break
        }
    }
    
    if (-not $fontRegistered) {
        $allFontsInstalled = $false
        break
    }
}

# Vérifiez le fichier marqueur de succès
$successMarker = Test-Path "C:\Windows\Temp\FontInstallSuccess.txt"

if ($allFontsInstalled -and $successMarker) {
    Write-Host "Toutes les polices sont correctement installées et enregistrées"
    exit 0  # Succès
} else {
    Write-Host "Les polices ne sont pas correctement installées"
    exit 1  # Non installé
}

Vérification : Mettez à jour le tableau $requiredFonts avec vos noms de fichiers de polices réels. Testez le script localement en l'exécutant après avoir installé manuellement vos polices.

Maintenant, organisez vos fichiers de polices et scripts dans la structure appropriée pour l'emballage.

Copiez vos fichiers de polices personnalisées dans le sous-répertoire fonts :

# Copiez vos fichiers .ttf et .otf dans le répertoire fonts
Copy-Item "C:\Path\To\Your\Fonts\*.ttf" "C:\FontDeployment\fonts\" -Force
Copy-Item "C:\Path\To\Your\Fonts\*.otf" "C:\FontDeployment\fonts\" -Force

Vérifiez que votre structure de répertoire ressemble à ceci :

C:\FontDeployment\
├── fonts\
│   ├── YourCompanyFont-Regular.ttf
│   ├── YourCompanyFont-Bold.ttf
│   └── YourCompanyFont-Italic.ttf
├── installfonts.ps1
├── uninstallfonts.ps1
└── DetectionCheck.ps1

Vérifiez la taille totale du package :

# Vérifiez la taille du package (doit être inférieure à 8 Go pour les applications Win32)
$size = (Get-ChildItem "C:\FontDeployment" -Recurse | Measure-Object -Property Length -Sum).Sum / 1MB
Write-Host "Taille du package : $([math]::Round($size, 2)) MB"

Vérification : Exécutez Get-ChildItem "C:\FontDeployment" -Recurse pour confirmer que tous les fichiers sont présents et que le sous-répertoire fonts contient vos fichiers de polices.

Utilisez l'outil de préparation de contenu Win32 de Microsoft pour créer le package .intunewin que Intune peut déployer.

Ouvrez une invite de commande avec élévation de privilèges et accédez à votre répertoire d'outils :

cd C:\Tools\Intune

Exécutez la commande de packaging :

IntuneWinAppUtil.exe -c "C:\FontDeployment" -s "installfonts.ps1" -o "C:\FontDeployment\Output" -q

Les paramètres signifient :

• -c : Dossier source contenant tous les fichiers
• -s : Fichier de configuration (script d'installation principal)
• -o : Répertoire de sortie pour le fichier .intunewin
• -q : Mode silencieux (sortie minimale)

L'outil créera installfonts.intunewin dans le répertoire de sortie.

Vérification : Vérifiez que le fichier .intunewin a été créé et notez sa taille :

Get-ChildItem "C:\FontDeployment\Output\*.intunewin" | Select-Object Name, Length, CreationTime

Créez maintenant l'application Win32 dans le centre d'administration Microsoft Intune et configurez ses paramètres de déploiement.

Accédez au centre d'administration Intune :

1. Allez à Applications > Windows > Ajouter
2. Sélectionnez Application Windows (Win32)
3. Cliquez sur Sélectionner le fichier du package d'application et téléchargez votre fichier installfonts.intunewin

Configurez les informations de l'application :

• Nom : "Polices personnalisées de l'entreprise"
• Description : "Déploie des polices personnalisées de l'entreprise sur les appareils Windows"
• Éditeur : Le nom de votre entreprise
• Catégorie : Affaires (facultatif)

Dans l'onglet Programme, configurez ces commandes :

Commande d'installation :
%windir%\sysnative\windowspowershell\v1.0\powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -File "installfonts.ps1"

Commande de désinstallation :
%windir%\sysnative\windowspowershell\v1.0\powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -File "uninstallfonts.ps1"

Définissez ces paramètres de programme supplémentaires :

• Comportement de redémarrage de l'appareil : Aucune action spécifique
• Codes de retour : Conserver par défaut (0 = Succès, 1707 = Succès avec redémarrage)
• Comportement d'installation : Système

Vérification : Cliquez sur Suivant et confirmez que tous les paramètres sont correctement enregistrés avant de passer aux exigences.

Configurez la méthode de détection et les exigences système pour votre déploiement de police.

Dans l'onglet Exigences :

• Architecture du système d'exploitation : x64, x86
• Système d'exploitation minimum : Windows 10 1909
• Espace disque requis : Calculer en fonction de vos fichiers de police (généralement 1-50 Mo)
• Mémoire physique requise : Non applicable

Dans l'onglet Règles de détection :

1. Sélectionnez Utiliser un script de détection personnalisé
2. Cliquez sur Sélectionner un fichier et téléchargez votre DetectionCheck.ps1
3. Définissez Exécuter le script en tant que processus 32 bits sur les clients 64 bits : Non
4. Définissez Appliquer la vérification de signature de script : Non (sauf si vous avez des scripts signés)

Méthode de détection alternative (si vous préférez la détection basée sur les fichiers) :

Méthode de détection : Configurer manuellement les règles de détection
Type de règle : Fichier
Chemin : C:\Windows\Temp
Fichier ou dossier : FontInstallSuccess.txt
Méthode de détection : Le fichier ou dossier existe

Vérification : Testez votre script de détection localement en l'exécutant dans PowerShell. Il doit se terminer avec le code 0 lorsque les polices sont installées et le code 1 lorsqu'elles ne le sont pas.

Configurez les paramètres d'affectation et déployez votre package de polices sur les appareils cibles ou les groupes d'utilisateurs.

Dans l'onglet Affectations :

1. Cliquez sur Ajouter un groupe sous Requis (pour une installation obligatoire) ou Disponible pour les appareils inscrits (pour une installation optionnelle)
2. Sélectionnez vos groupes cibles (groupes d'appareils recommandés pour les polices)
3. Configurez l'optimisation de la livraison si nécessaire

Définissez les paramètres d'affectation :

• Intention : Requis (les polices s'installent automatiquement)
• Notification : Afficher toutes les notifications toast
• Disponibilité : Dès que possible
• Date limite d'installation : Dès que possible

Examinez et créez l'application :

1. Cliquez sur Suivant pour examiner tous les paramètres
2. Vérifiez les informations du package, les commandes et les affectations
3. Cliquez sur Créer pour déployer l'application

Surveillez le déploiement :

Accédez à : Apps > Windows > Polices personnalisées de l'entreprise > Statut d'installation de l'appareil
Vérifiez : Progression de l'installation et codes d'erreur éventuels

Vérification : Après le déploiement, vérifiez le Statut d'installation de l'appareil pour voir la progression de l'installation. Les installations réussies devraient afficher le statut "Installé".

Vérifiez que vos polices personnalisées sont correctement installées et disponibles sur les appareils Windows cibles.

Sur un appareil cible, forcez une synchronisation pour vérifier les nouvelles applications :

1. Ouvrez Paramètres > Comptes > Accéder au travail ou à l'école
2. Cliquez sur votre compte professionnel et sélectionnez Informations
3. Cliquez sur Synchroniser pour forcer l'actualisation des politiques

Vérifiez l'installation des polices en utilisant PowerShell sur l'appareil cible :

# Vérifiez si les fichiers de polices existent
Get-ChildItem "C:\Windows\Fonts" | Where-Object { $_.Name -like "*YourCompanyFont*" }

# Vérifiez les entrées du registre
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts" | Select-Object *YourCompanyFont*

# Vérifiez le journal d'installation
Get-Content "C:\Windows\Temp\FontInstall.log" -Tail 20

Testez la disponibilité des polices dans les applications :

1. Ouvrez Microsoft Word ou Notepad
2. Cliquez sur le menu déroulant des polices
3. Recherchez les noms de vos polices personnalisées
4. Tapez du texte et appliquez la police personnalisée

Vérifiez le rapport Intune :

Centre d'administration Intune > Applications > Windows > Polices personnalisées de l'entreprise
- Statut d'installation de l'appareil : Devrait indiquer "Installé"
- Statut d'installation de l'utilisateur : Vérifiez les échecs éventuels
- Statut de protection des applications : Surveillez les problèmes

Vérification : Vos polices personnalisées devraient apparaître dans la liste des polices de toutes les applications Office et autres programmes. Le texte formaté avec ces polices devrait s'afficher correctement.