Créer un package MSIX ou un bundle avec MakeAppx.exe

Article
10/31/2023

MakeAppx.exe crée des packages d’application (.msix ou .appx) et des bundles de packages d’application (.msixbundle ou .appxbundle). MakeAppx.exe extrait également les fichiers d’un package d’application ou d’un bundle et chiffre ou déchiffre les packages d’application et les bundles. Cet outil est inclus dans le SDK Windows 10 et peut être utilisé à partir d’une invite de commandes ou d’un fichier de script.

Pour plus d’informations sur l’utilisation de MakeApp.exe pour empaqueter une application de bureau, consultez Empaqueter une application de bureau manuellement.

Important

Si vous avez utilisé Visual Studio pour développer votre application, il est recommandé d’utiliser l’Assistant Visual Studio pour créer votre package d’application. Pour plus d’informations, consultez Empaqueter une application UWP avec Visual Studio et Empaqueter une application de bureau à partir du code source à l’aide de Visual Studio.

Important

Notez que MakeAppx.exe ne crée pas de fichier de chargement de package d’application (.appxupload ou .msixupload) qui est le type recommandé de package d’application valide pour les soumissions à l’Espace partenaires. Le fichier de chargement du package d’application est généralement créé dans le cadre du processus d’empaquetage Visual Studio, même s’il peut également être créé manuellement.

Utilisation de MakeAppx.exe

Selon votre chemin d’installation du SDK, voici où se trouve MakeAppx.exe sur votre PC Windows 10 :

C:\Program Files (x86)\Windows Kits\10\bin\<numéro de build>\<architecture>\makeappx.exe

où <architecture> = x86, x64, arm, arm64 ou chpe. Vous pouvez également le trouver dans :

C :\Program Files (x86)\Windows Kits\10\App Certification Kit\makeappx.exe

Syntaxe et options MakeAppx.exe

Syntaxe Générale MakeAppx.exe :

MakeAppx <command> [options]

Le tableau suivant décrit les commandes pour MakeAppx.exe.

Interface	Description
pack	Crée un package.
unpack	Extrait tous les fichiers du package spécifié vers le répertoire de sortie spécifié.
bundle	Crée un bundle.
dégrouper	Décompresse tous les packages dans un sous-répertoire sous le chemin de sortie spécifié nommé après le nom complet de l’offre groupée ou du package.
encrypt	Crée un package d’application ou un bundle chiffré à partir du package/bundle d’entrée au niveau du package/bundle de sortie spécifié.
decrypt	Crée un package d’application ou un bundle d’applications déchiffrés à partir du package/bundle d’application d’entrée au niveau du package/bundle de sortie spécifié.

Cette liste d’options s’applique à toutes les commandes :

Option	Description
/d	Spécifie l’entrée, la sortie ou le répertoire de contenu.
/l	Utilisé pour les packages localisés. Les voyages de validation par défaut sur les packages localisés. Cette option désactive uniquement cette validation spécifique, sans exiger que toutes les validations soient désactivées.
/kf	Chiffre ou déchiffre le package ou l’offre groupée à l’aide de la clé du fichier de clé spécifié. Ne peut s’utiliser avec /kt.
/kt	Chiffre le ou déchiffre le package ou bundle à l’aide de la clé de test globale. Elle ne peut pas être utilisée avec /kf.
/non	Empêche un remplacement du fichier de sortie s’il existe. Si vous ne spécifiez pas cette option ou l’option /o, l’utilisateur est invité à remplacer le fichier.
/nv	Ne tient pas compte de la validation sémantique. Si vous ne spécifiez pas cette option, l’outil effectue une validation complète du package.
/o	Écrase le fichier de sortie s’il existe déjà. Si vous ne spécifiez pas cette option ou l’option /no, l’utilisateur est invité à remplacer le fichier.
/p	Spécifie le package ou l’offre groupée de l’application.
/v	Active la sortie de journalisation détaillée dans la console.
/?	Affiche le texte d’aide.

La liste suivante contient les arguments possibles :

Argument	Description
<nom du package de sortie>	Nom du package créé. Il s’agit du nom de fichier ajouté avec .msix ou .appx.
<nom du package de sortie chiffré>	Nom du package chiffré créé. Il s’agit du nom de fichier ajouté avec .emsix ou .eappx.
<nom du package d’entrée>	Nom du package. Il s’agit du nom de fichier ajouté avec .msix ou .appx.
<nom du package d’entrée chiffré>	Nom du package chiffré. Il s’agit du nom de fichier ajouté avec .emsix ou .eappx.
<nom du bundle de sortie>	Nom du bundle créé. Il s’agit du nom de fichier ajouté avec .msixbundle ou .appxbundle.
<nom du bundle de sortie chiffré>	Nom du bundle chiffré créé. Il s’agit du nom de fichier ajouté avec .emsixbundle ou .eappxbundle.
<nom du bundle d’entrée>	Le nom du regroupement. Il s’agit du nom de fichier ajouté avec .msixbundle ou .appxbundle.
<Nom du bundle d’entrée chiffré>	Nom du bundle chiffré. Il s’agit du nom de fichier ajouté avec .emsixbundle ou .eappxbundle.
<répertoire de contenu>	Chemin d’accès au package d’application ou au contenu groupé.
<fichier de mappage>	Nom de fichier qui spécifie la source et la destination du package.
<répertoire de sortie>	Chemin d’accès au répertoire des packages de sortie et des bundles.
<fichier de clé>	Nom du fichier contenant une clé pour le chiffrement ou le déchiffrement.
<ID d’Algorithme>	Algorithmes utilisés lors de la création d’une carte de blocs. Les algorithmes valides sont les suivants : SHA256 (valeur par défaut), SHA384, SHA512.

Créer un package d'application

Un package d’application est un ensemble complet des fichiers de l’application inclus dans un fichier de package .msix ou .appx. Pour créer un package d’application à l’aide de la commande pack, vous devez fournir un répertoire de contenu ou un fichier de mappage pour l’emplacement du package. Vous pouvez également chiffrer un package lors de sa création. Si vous souhaitez chiffrer le package, vous devez utiliser /ep et spécifier si vous utilisez un fichier de clé (/kf) ou la clé de test globale (/kt). Pour plus d’informations sur la création d’un package chiffré, consultez Chiffrer ou déchiffrer un package ou un bundle.

Options spécifiques à la commandepack :

Option	Description
/f	Spécifie le fichier de mappage.
/h	Spécifie l’algorithme de hachage à utiliser lors de la création de la carte de blocs. Cela ne peut être utilisé qu’avec la commande pack. Les algorithmes valides sont les suivants : SHA256 (valeur par défaut), SHA384, SHA512.
/m	Spécifie le chemin d’accès à un manifeste d’application d’entrée qui sera utilisé comme base pour générer le package d’application de sortie ou le manifeste du package de ressources. Lorsque vous utilisez cette option, vous devez également utiliser /f et inclure une section [ResourceMetadata] dans le fichier de mappage pour spécifier les dimensions de ressource à inclure dans le manifeste généré.
/nc	Empêche la compression des fichiers de package. Par défaut, les fichiers sont compressés en fonction du type de fichier détecté.
/r	Génère un package de ressources. Cela doit être utilisé avec /m et implique l’utilisation de l’option /l.

Les exemples d’utilisation suivants montrent certaines options de syntaxe possibles pour la commande pack :

MakeAppx pack [options] /d <content directory> /p <output package name>
MakeAppx pack [options] /f <mapping file> /p <output package name>
MakeAppx pack [options] /m <app package manifest> /f <mapping file> /p <output package name>
MakeAppx pack [options] /r /m <app package manifest> /f <mapping file> /p <output package name>
MakeAppx pack [options] /d <content directory> /ep <encrypted output package name> /kf <key file>
MakeAppx pack [options] /d <content directory> /ep <encrypted output package name> /kt

Voici des exemples de ligne de commande pour la commande pack :

MakeAppx pack /v /h SHA256 /d "C:\My Files" /p MyPackage.msix
MakeAppx pack /v /o /f MyMapping.txt /p MyPackage.msix
MakeAppx pack /m "MyApp\AppxManifest.xml" /f MyMapping.txt /p AppPackage.msix
MakeAppx pack /r /m "MyApp\AppxManifest.xml" /f MyMapping.txt /p ResourcePackage.msix
MakeAppx pack /v /h SHA256 /d "C:\My Files" /ep MyPackage.emsix /kf MyKeyFile.txt
MakeAppx pack /v /h SHA256 /d "C:\My Files" /ep MyPackage.emsix /kt

Créer un ensemble d’applications

Un ensemble d’applications est similaire à un package de l’application, mais un ensemble peut réduire la taille de l’application que les utilisateurs téléchargent. Les ensembles d’applications sont utiles pour les ressources spécifiques au langage, les ressources variables à l’échelle de l’image ou les ressources qui s’appliquent à des versions spécifiques de Microsoft DirectX, par exemple. Comme pour créer un package d’application chiffré, vous pouvez également chiffrer l’ensemble d’applications pendant le processus de regroupement. Pour chiffrer l’ensemble d’applications, utilisez l’option /ep et spécifiez si vous utilisez un fichier de clé (/kf) ou la clé de test globale (/kt). Pour plus d’informations sur la création d’un bundle chiffré, consultez Chiffrer ou déchiffrer un package ou un bundle.

Options spécifiques à la commande bundle :

Option	Description
/bv	Spécifie le numéro de version du bundle. Le numéro de version doit être en quatre parties séparées par des points sous la forme : <Major>.<Mineur>.<Générer>.<Révision>.
/f	Spécifie le fichier de mappage.

Notez que si la version de l’offre groupée n’est pas spécifiée ou si elle est définie sur « 0.0.0.0 », le bundle est créé à l’aide de la date-heure actuelle.

Les exemples d’utilisation suivants montrent certaines options de syntaxe possibles pour la commande bundle :

MakeAppx bundle [options] /d <content directory> /p <output bundle name>
MakeAppx bundle [options] /f <mapping file> /p <output bundle name>
MakeAppx bundle [options] /d <content directory> /ep <encrypted output bundle name> /kf MyKeyFile.txt
MakeAppx bundle [options] /f <mapping file> /ep <encrypted output bundle name> /kt

Le bloc suivant contient des exemples pour la commande bundle :

MakeAppx bundle /v /d "C:\My Files" /p MyBundle.msixbundle
MakeAppx bundle /v /o /bv 1.0.1.2096 /f MyMapping.txt /p MyBundle.msixbundle
MakeAppx bundle /v /o /bv 1.0.1.2096 /f MyMapping.txt /ep MyBundle.emsixbundle /kf MyKeyFile.txt
MakeAppx bundle /v /o /bv 1.0.1.2096 /f MyMapping.txt /ep MyBundle.emsixbundle /kt

Extraire des fichiers d’un package ou d’un bundle

Outre l’empaquetage et le regroupement d’applications, MakeAppx.exe peut également décompresser ou dissocier des packages existants. Vous devez fournir le répertoire de contenu comme destination pour les fichiers extraits. Si vous essayez d’extraire des fichiers à partir d’un package ou d’un bundle chiffré, vous pouvez déchiffrer et extraire les fichiers en même temps à l’aide de l’option /ep et spécifier s’il doit être déchiffré à l’aide d’un fichier de clé (/kf) ou de la clé de test globale (/kt). Pour plus d’informations sur le déchiffrement d’un package ou d’un bundle, consultez Chiffrer ou déchiffrer un package ou un bundle.

Options propres à décompresser et dissocier les commandes :

Option	Description
/nd	N’effectue pas de déchiffrement lors de la décompression ou de la dissociation du package/bundle.
/pfn	Décompresser/dissocier tous les fichiers dans un sous-répertoire sous le chemin de sortie spécifié, nommé après le nom complet de l’offre du bundle ou du package

Les exemples d’utilisation suivants montrent certaines options de syntaxe possibles pour les commandes décompresser et dissocier :

MakeAppx unpack [options] /p <input package name> /d <output directory>
MakeAppx unpack [options] /ep <encrypted input package name> /d <output directory> /kf <key file>
MakeAppx unpack [options] /ep <encrypted input package name> /d <output directory> /kt

MakeAppx unbundle [options] /p <input bundle name> /d <output directory>
MakeAppx unbundle [options] /ep <encrypted input bundle name> /d <output directory> /kf <key file>
MakeAppx unbundle [options] /ep <encrypted input bundle name> /d <output directory> /kt

Le bloc suivant contient des exemples d’utilisation des commandes de décompression et de dissociation :

MakeAppx unpack /v /p MyPackage.msix /d "C:\My Files"
MakeAppx unpack /v /ep MyPackage.emsix /d "C:\My Files" /kf MyKeyFile.txt
MakeAppx unpack /v /ep MyPackage.emsix /d "C:\My Files" /kt

MakeAppx unbundle /v /p MyBundle.msixbundle /d "C:\My Files"
MakeAppx unbundle /v /ep MyBundle.emsixbundle /d "C:\My Files" /kf MyKeyFile.txt
MakeAppx unbundle /v /ep MyBundle.emsixbundle /d "C:\My Files" /kt

Chiffrer ou déchiffrer un package ou un bundle

L’outil MakeAppx.exe peut également chiffrer ou déchiffrer un package ou un bundle existant. Vous devez simplement fournir le nom du package, le nom du package de sortie et si le chiffrement ou le déchiffrement doit utiliser un fichier de clé (/kf) ou la clé de test globale (/kt).

Le chiffrement et le déchiffrement ne sont pas disponibles via l’Assistant Empaquetage Visual Studio.

Options spécifiques aux commandes de chiffrement et de déchiffrement :

Option	Description
/ep	Spécifie un package ou un bundle d’application chiffré.

Les exemples d’utilisation suivants montrent certaines options de syntaxe possibles pour les commandes de chiffrement et de déchiffrement :

MakeAppx encrypt [options] /p <package name> /ep <output package name> /kf <key file>
MakeAppx encrypt [options] /p <package name> /ep <output package name> /kt

MakeAppx decrypt [options] /ep <package name> /p <output package name> /kf <key file>
MakeAppx decrypt [options] /ep <package name> /p <output package name> /kt

Le bloc suivant contient des exemples d’utilisation des commandes de chiffrement et de déchiffrement :

MakeAppx.exe encrypt /p MyPackage.msix /ep MyEncryptedPackage.emsix /kt
MakeAppx.exe encrypt /p MyPackage.msix /ep MyEncryptedPackage.emsix /kf MyKeyFile.txt

MakeAppx.exe decrypt /p MyPackage.msix /ep MyEncryptedPackage.emsix /kt
MakeAppx.exe decrypt p MyPackage.msix /ep MyEncryptedPackage.emsix /kf MyKeyFile.txt

Fichier clé

Les fichiers clés doivent commencer par une ligne contenant la chaîne « [Keys] », puis les lignes décrivant les clés pour chiffrer chaque package. Chaque clé est représentée par une paire de chaînes entre guillemets, séparées par des espaces ou des onglets. La première chaîne représente l’ID de clé 32 octets codée en base64 et la deuxième représente la clé de chiffrement 32 octets encodée en base64. Un fichier de clé doit être un fichier texte simple.

Exemple d’un fichier clé :

[Keys]
"OWVwSzliRGY1VWt1ODk4N1Q4R2Vqc04zMzIzNnlUREU="    "MjNFTlFhZGRGZEY2YnVxMTBocjd6THdOdk9pZkpvelc="

Fichiers de mappage

Les fichiers de mappage doivent commencer par une ligne contenant la chaîne « [Files] » suivie de lignes décrivant les fichiers à ajouter au package. Chaque fichier est décrit par une paire de chemins entre guillemets, séparés par des espaces ou des onglets. Chaque fichier représente sa source (sur disque) et sa destination (dans le package). Un fichier de mappage doit être un fichier texte simple.

Exemple de fichier de mappage (sans l’option /m) :

[Files]
"C:\MyApp\StartPage.html"               "default.html"
"C:\Program Files (x86)\example.txt"    "misc\example.txt"
"\\MyServer\path\icon.png"              "icon.png"
"my app files\readme.txt"               "my app files\readme.txt"
"CustomManifest.xml"                    "AppxManifest.xml"

Lorsque vous utilisez un fichier de mappage, vous pouvez choisir si vous souhaitez utiliser l’option /m. L’option /m permet à l’utilisateur de spécifier les métadonnées de ressource dans le fichier de mappage à inclure dans le manifeste généré. Si vous utilisez l’option /m, le fichier de mappage doit contenir une section commençant par la ligne « [ResourceMetadata] », suivie de lignes qui spécifient « ResourceDimensions » et « ResourceId ». Il est possible qu’un package d’application contienne plusieurs « ResourceDimensions », mais il ne peut jamais y avoir qu’un seul « ResourceId ».

Exemple de fichier de mappage (avec l’option /m) :

[ResourceMetadata]
"ResourceDimensions"                    "language-en-us"
"ResourceId"                            "English"

[Files]
"images\en-us\logo.png"                 "en-us\logo.png"
"en-us.pri"                             "resources.pri"

Validation sémantique effectuée par MakeAppx.exe

MakeAppx.exe effectue une validation sématique limitée conçue pour intercepter les erreurs de déploiement les plus courantes et vous assurer que le package d’application est valide. Consultez l’option /nv si vous souhaitez ignorer la validation lors de l’utilisation de MakeAppx.exe.

Cette validation garantit que :

Tous les fichiers référencés dans le manifeste du package sont inclus dans le package d’application.
Une application n’a pas deux clés identiques.
Une application ne s’inscrit pas pour un protocole interdit à partir de cette liste : PME, FILE, MS-WWA-WEB, MS-WWA.

Il ne s’agit pas d’une validation sémantique complète, car elle est conçue uniquement pour intercepter les erreurs courantes. Les packages générés par MakeAppx.exe ne sont pas garantis pour être installables.