Anavem
Languageen
Comment installer et configurer le gestionnaire de paquets Chocolatey avec Microsoft Intune

Comment installer et configurer le gestionnaire de paquets Chocolatey avec Microsoft Intune

Déployer le gestionnaire de paquets Chocolatey sur les appareils Windows en utilisant Microsoft Intune comme application Win32 avec des scripts PowerShell, des règles de détection et une gestion automatisée des paquets.

Evan MaelEvan Mael
26 mars 2026 15 min
mediumintune 10 étapes 15 min

Pourquoi déployer Chocolatey Package Manager via Microsoft Intune ?

Chocolatey transforme la gestion des logiciels Windows en fournissant un gestionnaire de paquets en ligne de commande similaire à apt-get sur Linux ou Homebrew sur macOS. Lorsqu'il est déployé via Microsoft Intune, vous obtenez un contrôle centralisé sur l'installation des logiciels sur l'ensemble de votre parc d'appareils Windows, éliminant ainsi le besoin de déploiement manuel de logiciels et réduisant la charge administrative.

Cette intégration devient particulièrement puissante dans les environnements d'entreprise où vous devez maintenir des versions logicielles cohérentes, automatiser les mises à jour et assurer la conformité sur des centaines ou des milliers d'appareils. Plutôt que de visiter manuellement chaque machine ou de compter sur les utilisateurs pour installer correctement les logiciels, vous pouvez déployer des applications avec une seule commande qu'Intune exécute sur vos appareils gérés.

Quels sont les principaux avantages de cette méthode de déploiement ?

Déployer Chocolatey via Intune en tant qu'application Win32 offre plusieurs avantages par rapport aux méthodes de déploiement de logiciels traditionnelles. Tout d'abord, il exploite les capacités robustes de gestion des appareils d'Intune, y compris le ciblage de groupes d'appareils spécifiques, la planification des installations et le suivi des taux de réussite des déploiements en temps réel.

L'approche maintient également la sécurité en exécutant les installations dans le contexte système avec des politiques d'exécution appropriées, garantissant que les installations logicielles ne nécessitent pas d'intervention de l'utilisateur ou de privilèges élevés. Cela est crucial pour maintenir la conformité en matière de sécurité tout en permettant une gestion automatisée des logiciels.

Comment cela se compare-t-il à l'intégration native de Chocolatey Business ?

Bien que Chocolatey for Business offre une intégration native d'Intune via l'extension sous licence v3.0.0+, ce tutoriel se concentre sur l'approche communautaire qui fonctionne avec les installations gratuites de Chocolatey. La méthode de déploiement d'application Win32 offre une fonctionnalité similaire sans nécessiter de licence Business, la rendant accessible aux organisations de toutes tailles.

Cette méthode implique de packager Chocolatey lui-même en tant qu'application Win32 Intune, puis de l'utiliser comme base pour déployer d'autres paquets logiciels. Une fois Chocolatey installé sur les appareils, vous pouvez créer des applications Win32 supplémentaires qui utilisent les commandes Chocolatey pour installer et gérer les logiciels, créant ainsi un pipeline de déploiement logiciel évolutif.

Guide de mise en oeuvre

Procédure complète

01

Télécharger et préparer les outils requis

Tout d'abord, vous devez télécharger l'outil de préparation de contenu Microsoft Win32 et créer votre structure de répertoire de travail.

Créez un nouveau dossier sur votre machine locale pour ce projet :

New-Item -ItemType Directory -Path "C:\IntuneApps\Chocolatey" -Force
Set-Location "C:\IntuneApps\Chocolatey"

Téléchargez le IntuneWinAppUtil.exe depuis le Microsoft Download Center et placez-le dans votre répertoire de travail. Vous pouvez également le télécharger directement en utilisant PowerShell :

Invoke-WebRequest -Uri "https://github.com/Microsoft/Microsoft-Win32-Content-Prep-Tool/raw/master/IntuneWinAppUtil.exe" -OutFile "IntuneWinAppUtil.exe"
Astuce pro : Vérifiez toujours le hash des exécutables téléchargés depuis Microsoft pour assurer l'intégrité. Utilisez Get-FileHash IntuneWinAppUtil.exe -Algorithm SHA256 et comparez avec le hash publié par Microsoft.

Vérification : Exécutez dir pour confirmer que IntuneWinAppUtil.exe est présent dans votre répertoire de travail.

02

Créer le script d'installation Chocolatey

Créez le script PowerShell qui installera Chocolatey sur les appareils cibles. Ce script gère le processus d'installation complet, y compris les protocoles de sécurité et les politiques d'exécution.

Créez un nouveau fichier appelé install.ps1 dans votre dossier Chocolatey :

# Script d'installation de Chocolatey pour le déploiement Intune
# Définir la politique d'exécution pour ce processus
Set-ExecutionPolicy Bypass -Scope Process -Force

# Activer TLS 1.2 pour les téléchargements sécurisés
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072

# Télécharger et exécuter le script d'installation de Chocolatey
try {
    Write-Output "Démarrage de l'installation de Chocolatey..."
    iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
    Write-Output "Installation de Chocolatey terminée avec succès"
    
    # Vérifier l'installation
    $chocoPath = "$env:ProgramData\chocolatey\choco.exe"
    if (Test-Path $chocoPath) {
        Write-Output "Chocolatey installé à : $chocoPath"
        & $chocoPath --version
    } else {
        throw "Échec de l'installation de Chocolatey - exécutable non trouvé"
    }
} catch {
    Write-Error "Échec de l'installation de Chocolatey : $($_.Exception.Message)"
    exit 1
}

Créez un script de désinstallation appelé uninstall.ps1 :

# Script de désinstallation de Chocolatey
try {
    if (Test-Path "$env:ProgramData\chocolatey") {
        Write-Output "Suppression de Chocolatey..."
        Remove-Item "$env:ProgramData\chocolatey" -Recurse -Force
        Write-Output "Chocolatey supprimé avec succès"
    } else {
        Write-Output "Chocolatey non trouvé - rien à désinstaller"
    }
} catch {
    Write-Error "Échec de la désinstallation : $($_.Exception.Message)"
    exit 1
}
Avertissement : Le script d'installation télécharge du contenu depuis internet. Assurez-vous que vos appareils cibles ont accès à internet et que chocolatey.org n'est pas bloqué par votre pare-feu ou vos paramètres de proxy.

Vérification : Exécutez Get-Content install.ps1 pour confirmer que le contenu du script est correct.

03

Emballer l'application avec IntuneWinAppUtil

Maintenant, vous allez convertir vos scripts PowerShell en un package .intunewin compatible avec Intune en utilisant l'outil Microsoft Win32 Content Prep Tool.

Exécutez la commande IntuneWinAppUtil pour créer le package :

IntuneWinAppUtil.exe -c "C:\IntuneApps\Chocolatey" -s "install.ps1" -o "C:\IntuneApps\Output" -q

Les paramètres expliqués :

  • -c : Dossier source contenant vos fichiers d'installation
  • -s : Fichier de configuration (votre script install.ps1)
  • -o : Répertoire de sortie pour le fichier .intunewin
  • -q : Mode silencieux (supprime les invites)

L'outil créera un fichier appelé install.intunewin dans votre répertoire de sortie. Cela contient votre script PowerShell et les métadonnées nécessaires par Intune.

Astuce pro : Si vous devez inclure des fichiers supplémentaires (comme des fichiers de configuration ou des dépendances), placez-les dans le dossier source avant d'exécuter IntuneWinAppUtil. Tous les fichiers du dossier source seront inclus dans le package.

Vérification : Vérifiez que le fichier .intunewin a été créé avec succès :

Get-ChildItem "C:\IntuneApps\Output" -Filter "*.intunewin"
04

Téléchargez l'application sur Microsoft Intune

Accédez au centre d'administration Microsoft Intune et créez une nouvelle entrée d'application Win32 pour votre package Chocolatey.

Accédez à Applications > Toutes les applications > Ajouter et sélectionnez Application Windows (Win32) dans le menu déroulant.

Dans la section Fichier du package de l'application, cliquez sur Sélectionner le fichier du package de l'application et téléchargez votre fichier install.intunewin. Intune extraira automatiquement les métadonnées du package.

Configurez les informations de l'application :

  • Nom : Chocolatey Package Manager
  • Description : Chocolatey est un gestionnaire de packages pour Windows qui simplifie l'installation et la gestion des logiciels
  • Éditeur : Chocolatey Software
  • Catégorie : Outils de développement
  • URL d'information : https://chocolatey.org
  • URL de confidentialité : https://chocolatey.org/privacy

Pour l'icône de l'application, vous pouvez télécharger le logo officiel de Chocolatey depuis leur site web ou utiliser cette commande PowerShell pour le télécharger :

Invoke-WebRequest -Uri "https://chocolatey.org/content/images/logo_square.svg" -OutFile "chocolatey-icon.svg"
Avertissement : Assurez-vous d'avoir les droits d'utiliser tous les logos ou icônes. Le logo Chocolatey est disponible pour utilisation lors du déploiement de leur logiciel conformément à leurs directives de marque.

Vérification : Confirmez que l'application apparaît dans votre liste d'applications Intune avec le statut "Non assigné".

05

Configurer les commandes d'installation et de désinstallation

Configurez les commandes qu'Intune utilisera pour installer et désinstaller Chocolatey sur les appareils cibles.

Dans la section Programme de la configuration de votre application :

Commande d'installation :

powershell.exe -executionpolicy bypass -windowstyle hidden -file install.ps1

Commande de désinstallation :

powershell.exe -executionpolicy bypass -windowstyle hidden -file uninstall.ps1

Configurez le comportement d'installation :

  • Comportement de redémarrage de l'appareil : Aucune action spécifique
  • Comportement d'installation : Système
  • Codes de retour : Conservez les codes de succès (0) et de redémarrage (3010) par défaut

Définissez les exigences :

  • Architecture du système d'exploitation : x64
  • Système d'exploitation minimum : Windows 10 1607
  • Espace disque requis : 100 MB
  • Mémoire physique requise : 1 GB
Astuce pro : Le paramètre -windowstyle hidden empêche les fenêtres PowerShell d'apparaître aux utilisateurs finaux pendant l'installation, offrant une expérience de déploiement plus propre.

Vérification : Vérifiez attentivement toute la syntaxe des commandes - des fautes de frappe ici entraîneront des échecs de déploiement sur l'ensemble de votre parc d'appareils.

06

Créer des règles de détection pour la vérification de l'installation

Configurez des règles de détection qui indiquent à Intune comment vérifier si Chocolatey est installé avec succès sur un appareil.

Dans la section Règles de détection, cliquez sur Ajouter et sélectionnez Fichier comme type de règle.

Configurez la règle de détection de fichier :

  • Chemin : C:\ProgramData\chocolatey
  • Fichier ou dossier : choco.exe
  • Méthode de détection : Fichier ou dossier existant
  • Associé à une application 32 bits sur des clients 64 bits : Non

Pour une détection plus robuste, vous pouvez ajouter une deuxième règle en utilisant la détection par script PowerShell. Créez un script de détection :

# Script de détection Chocolatey
$chocoPath = "$env:ProgramData\chocolatey\choco.exe"

if (Test-Path $chocoPath) {
    try {
        $version = & $chocoPath --version --limit-output
        if ($version -match "^\d+\.\d+\.\d+") {
            Write-Output "Version de Chocolatey $version détectée"
            exit 0
        }
    } catch {
        Write-Output "Exécutable Chocolatey trouvé mais non fonctionnel"
        exit 1
    }
} else {
    Write-Output "Chocolatey non détecté"
    exit 1
}

Si vous utilisez la méthode de détection PowerShell :

  • Type de script : PowerShell
  • Exécuter le script en tant que processus 32 bits : Non
  • Exécuter ce script avec les identifiants de l'utilisateur connecté : Non
Avertissement : Les règles de détection sont essentielles pour une gestion correcte des applications. Si la détection échoue, Intune essaiera continuellement de réinstaller l'application, ce qui pourrait causer des conflits.

Vérification : Testez votre logique de détection manuellement sur une machine de test en exécutant le script de détection PowerShell.

07

Configurer les dépendances et la substitution

Configurez toutes les dépendances requises par Chocolatey et configurez les relations de supersession si vous effectuez une mise à jour à partir d'une version précédente.

Pour Chocolatey, la principale dépendance est de s'assurer que PowerShell 5.1 ou supérieur est installé. Comme cela est inclus par défaut dans Windows 10/11, vous n'avez généralement pas besoin de dépendances supplémentaires.

Si vous avez un déploiement Chocolatey existant, configurez la supersession :

  • Cliquez sur Ajouter dans la section Supersession
  • Sélectionnez votre application Chocolatey précédente
  • Choisissez Désinstaller pour supprimer l'ancienne version avant d'installer la nouvelle

Pour les organisations qui souhaitent s'assurer que des modules PowerShell spécifiques sont disponibles, vous pouvez créer un script de dépendance :

# Vérification des prérequis PowerShell
$psVersion = $PSVersionTable.PSVersion.Major
if ($psVersion -lt 5) {
    Write-Error "PowerShell 5.1 ou supérieur requis. Version actuelle : $psVersion"
    exit 1
}

# Vérifiez si la politique d'exécution permet l'exécution de scripts
$executionPolicy = Get-ExecutionPolicy
if ($executionPolicy -eq "Restricted") {
    Write-Output "La politique d'exécution est Restreinte - sera contournée pendant l'installation"
}

Write-Output "Vérification des prérequis réussie"
exit 0
Astuce pro : Utilisez les dépendances pour créer un ordre d'installation logique. Par exemple, si vous prévoyez de déployer des applications via Chocolatey, faites en sorte que ces applications dépendent de cette installation de Chocolatey.

Vérification : Examinez la chaîne de dépendance dans la console Intune pour garantir le bon ordre d'installation.

08

Attribuer l'application aux groupes d'appareils

Configurez quels appareils ou utilisateurs recevront l'installation de Chocolatey en configurant des attributions.

Dans la section Attributions, cliquez sur Ajouter un groupe pour créer des règles d'attribution.

Configurez les paramètres d'attribution :

  • Type d'attribution : Requis (pour une installation automatique) ou Disponible (pour un libre-service)
  • Groupes inclus : Sélectionnez vos groupes d'appareils cibles ou groupes d'utilisateurs
  • Groupes exclus : Excluez éventuellement des groupes spécifiques (comme les appareils de test)

Définissez le calendrier d'attribution :

{
  "startDateTime": "2026-03-26T09:00:00Z",
  "useLocalTime": true,
  "deadlineDateTime": "2026-03-27T17:00:00Z",
  "restartSettings": {
    "restartNotificationSnoozeDurationInMinutes": 60,
    "restartCountDownDisplayDurationInMinutes": 15
  }
}

Pour les déploiements pilotes, commencez par un petit groupe de test :

  1. Créez un groupe de test avec 5-10 appareils
  2. Attribuez l'application comme "Requis" à ce groupe
  3. Surveillez le succès du déploiement avant d'élargir
Avertissement : Testez toujours avec un petit groupe d'abord. Un script d'installation défectueux déployé sur des milliers d'appareils peut causer une perturbation significative à votre organisation.

Configurez les paramètres de notification si vous souhaitez que les utilisateurs soient informés de l'installation :

  • Afficher toutes les notifications toast : Oui
  • Afficher la boîte de dialogue de redémarrage : Oui (si redémarrage requis)
  • Permettre à l'utilisateur de redémarrer : Oui

Vérification : Vérifiez que le statut d'attribution affiche "En attente" pour vos appareils cibles dans la section Statut d'installation de l'appareil.

09

Déployer le moniteur et résoudre les problèmes

Surveillez la progression du déploiement et résolvez tout problème d'installation qui survient pendant le déploiement.

Accédez à Apps > All apps > Chocolatey Package Manager > Device install status pour voir le statut de déploiement en temps réel.

Indicateurs de statut courants :

  • Installed : Déploiement réussi
  • Failed : L'installation a rencontré une erreur
  • Pending : En attente de l'enregistrement de l'appareil ou d'une action de l'utilisateur
  • Not applicable : L'appareil ne répond pas aux exigences

Pour les installations échouées, vérifiez les journaux de l'appareil. Sur l'appareil cible, exécutez :

# Vérifiez les journaux de l'extension de gestion Intune
Get-WinEvent -LogName "Microsoft-Windows-DeviceManagement-Enterprise-Diagnostics-Provider/Operational" | Where-Object {$_.TimeCreated -gt (Get-Date).AddHours(-2)} | Format-Table TimeCreated, LevelDisplayName, Message -Wrap

Étapes courantes de dépannage :

  1. Problèmes de politique d'exécution : Assurez-vous que la commande d'installation inclut -executionpolicy bypass
  2. Connectivité réseau : Vérifiez que les appareils peuvent atteindre chocolatey.org
  3. Permissions : Confirmez que l'application est configurée pour s'installer dans le contexte Système
  4. Échecs de règle de détection : Testez la logique de détection manuellement sur les appareils concernés

Créez un script de dépannage pour un diagnostic rapide :

# Script de dépannage de déploiement Chocolatey
Write-Output "=== Diagnostics de déploiement Chocolatey ==="

# Vérifiez si Chocolatey est installé
$chocoPath = "$env:ProgramData\chocolatey\choco.exe"
if (Test-Path $chocoPath) {
    Write-Output "✓ Exécutable Chocolatey trouvé à : $chocoPath"
    try {
        $version = & $chocoPath --version
        Write-Output "✓ Version de Chocolatey : $version"
    } catch {
        Write-Output "✗ Exécutable Chocolatey non fonctionnel : $($_.Exception.Message)"
    }
} else {
    Write-Output "✗ Chocolatey non trouvé à l'emplacement attendu"
}

# Vérifiez la version de PowerShell
Write-Output "Version de PowerShell : $($PSVersionTable.PSVersion)"

# Vérifiez la politique d'exécution
Write-Output "Politique d'exécution : $(Get-ExecutionPolicy)"

# Vérifiez la connectivité Internet
try {
    $response = Invoke-WebRequest -Uri "https://chocolatey.org" -UseBasicParsing -TimeoutSec 10
    Write-Output "✓ Connectivité Internet à chocolatey.org : OK"
} catch {
    Write-Output "✗ Problème de connectivité Internet : $($_.Exception.Message)"
}

Write-Output "=== Fin des diagnostics ==="
Conseil pro : Configurez un rapport automatisé en créant une tâche planifiée qui exécute le script de dépannage et envoie les résultats par e-mail à votre équipe informatique pour une surveillance proactive.

Vérification : Confirmez le déploiement réussi en vérifiant que les appareils affichent le statut "Installed" et peuvent exécuter choco --version avec succès.

10

Configurer les mises à jour automatiques et la maintenance

Configurez des tâches de maintenance automatisées pour garder Chocolatey à jour et assurer des performances optimales sur votre parc d'appareils.

Créez un script de tâche planifiée pour les mises à jour automatiques de Chocolatey :

# Script de mise à jour automatique de Chocolatey
# Enregistrer sous : ChocolateyMaintenance.ps1

Start-Transcript -Path "$env:ProgramData\chocolatey\logs\maintenance.log" -Append

try {
    Write-Output "Démarrage de la maintenance de Chocolatey - $(Get-Date)"
    
    # Mettre à jour Chocolatey lui-même
    Write-Output "Mise à jour de Chocolatey..."
    & choco upgrade chocolatey -y
    
    # Mettre à jour tous les paquets installés
    Write-Output "Mise à jour de tous les paquets..."
    & choco upgrade all -y
    
    # Nettoyer les fichiers temporaires
    Write-Output "Nettoyage des fichiers temporaires..."
    & choco cache clean
    
    Write-Output "Maintenance terminée avec succès - $(Get-Date)"
} catch {
    Write-Error "Échec de la maintenance : $($_.Exception.Message)"
} finally {
    Stop-Transcript
}

Déployez ce script de maintenance comme une autre application Win32 avec ces paramètres :

  • Commande d'installation : powershell.exe -executionpolicy bypass -file ChocolateyMaintenance.ps1
  • Règle de détection : Détection basée sur un script vérifiant le dernier horodatage d'exécution
  • Affectation : Requis, récurrent tous les 7 jours

Créez un script de détection pour la tâche de maintenance :

# Script de détection de maintenance
$logPath = "$env:ProgramData\chocolatey\logs\maintenance.log"
$maxAge = (Get-Date).AddDays(-7)

if (Test-Path $logPath) {
    $lastWrite = (Get-Item $logPath).LastWriteTime
    if ($lastWrite -gt $maxAge) {
        Write-Output "Maintenance effectuée dans les 7 jours"
        exit 0
    }
}

Write-Output "Maintenance requise"
exit 1

Configurez les paramètres globaux de Chocolatey pour une utilisation en entreprise :

# Script de configuration d'entreprise
choco config set cacheLocation "$env:ProgramData\chocolatey\cache"
choco config set commandExecutionTimeoutSeconds 14400
choco config set containsLegacyPackageInstalls true
choco config set maxDownloadRateBitsPerSecond 10485760
choco feature enable -n allowGlobalConfirmation
choco feature enable -n logEnvironmentValues
choco feature disable -n showNonElevatedWarnings
Avertissement : Les mises à jour automatiques peuvent potentiellement casser des applications si les mises à jour des paquets introduisent des changements incompatibles. Envisagez de tester les mises à jour dans un groupe pilote avant de les déployer sur les appareils de production.

Mettez en place une surveillance des tâches de maintenance en créant un script de rapport simple :

# Script de rapport de maintenance
$devices = Get-Content "devices.txt"  # Liste des noms d'appareils
$report = @()

foreach ($device in $devices) {
    try {
        $logPath = "\\$device\c$\ProgramData\chocolatey\logs\maintenance.log"
        if (Test-Path $logPath) {
            $lastRun = (Get-Item $logPath).LastWriteTime
            $status = if ($lastRun -gt (Get-Date).AddDays(-7)) { "OK" } else { "En retard" }
        } else {
            $status = "Pas de journal"
            $lastRun = "Jamais"
        }
        
        $report += [PSCustomObject]@{
            Device = $device
            LastMaintenance = $lastRun
            Status = $status
        }
    } catch {
        $report += [PSCustomObject]@{
            Device = $device
            LastMaintenance = "Erreur"
            Status = "Inaccessible"
        }
    }
}

$report | Export-Csv "ChocolateyMaintenanceReport.csv" -NoTypeInformation
$report | Format-Table -AutoSize

Vérification : Vérifiez que le script de maintenance s'exécute avec succès et crée des entrées de journal dans $env:ProgramData\chocolatey\logs\maintenance.log.

Questions Fréquentes

Puis-je déployer Chocolatey via Intune sans licence Business ?+
Oui, vous pouvez déployer Chocolatey en tant qu'application Win32 via Intune en utilisant la version communautaire sans nécessiter de licence Chocolatey Business. Cette méthode implique de packager le script d'installation PowerShell en utilisant IntuneWinAppUtil et de le déployer comme toute autre application Win32. Bien que vous n'obteniez pas l'intégration API native disponible avec les licences Business, vous pouvez toujours réaliser un déploiement automatisé de logiciels sur l'ensemble de votre parc d'appareils.
Quelles règles de détection fonctionnent le mieux pour les déploiements Chocolatey Intune ?+
La règle de détection la plus fiable consiste à vérifier l'existence du fichier choco.exe à C:\ProgramData\chocolatey\choco.exe. Vous pouvez également utiliser une détection par script PowerShell qui non seulement vérifie l'existence du fichier, mais s'assure également de son bon fonctionnement en exécutant 'choco --version'. Cette approche double garantit que Chocolatey est à la fois installé et opérationnel, évitant ainsi les faux positifs dus à des installations incomplètes.
Comment dépanner les installations échouées de Chocolatey via Intune ?+
Vérifiez les journaux de l'extension de gestion Intune sur les appareils affectés en utilisant Get-WinEvent avec le journal Microsoft-Windows-DeviceManagement-Enterprise-Diagnostics-Provider/Operational. Les problèmes courants incluent les restrictions de la politique d'exécution (assurez-vous que votre commande d'installation utilise -executionpolicy bypass), les problèmes de connectivité réseau pour atteindre chocolatey.org, et les permissions insuffisantes (vérifiez que l'application s'installe dans le contexte Système). Créez un script de diagnostic pour tester automatiquement ces conditions.
Puis-je mettre à jour automatiquement Chocolatey et les packages installés via Intune ?+
Oui, créez une application Win32 distincte contenant un script de maintenance PowerShell qui exécute 'choco upgrade all -y' et 'choco upgrade chocolatey -y'. Déployez cela comme une affectation récurrente obligatoire avec une règle de détection basée sur le dernier horodatage d'exécution. Cette approche fournit des mises à jour automatisées tout en maintenant les capacités de suivi et de rapport de déploiement d'Intune à des fins de conformité et de surveillance.
Quelles sont les exigences système pour déployer Chocolatey via Intune ?+
Les appareils cibles doivent avoir Windows 10 version 1607 ou supérieure (64 bits), PowerShell 5.1 ou ultérieur, et une connexion internet pour accéder à chocolatey.org. Le déploiement nécessite au moins 100 Mo d'espace disque libre et 1 Go de RAM. Votre locataire Intune doit avoir la capacité de gestion des applications Win32 activée, et vous aurez besoin de l'outil de préparation de contenu Microsoft Win32 (IntuneWinAppUtil.exe) pour empaqueter les scripts d'installation.
Evan Mael
Écrit par

Evan Mael

Microsoft MCSA-certified Cloud Architect | Fortinet-focused. I modernize cloud, hybrid & on-prem infrastructure for reliability, security, performance and cost control - sharing field-tested ops & troubleshooting.

Discussion

Partagez vos réflexions et analyses

Connectez-vous pour participer