Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
MakeAppx.exe cria pacotes de aplicativos (.msix ou .appx) e pacotes de aplicativos (.msixbundle ou .appxbundle). MakeAppx.exe também extrai ficheiros de um pacote ou pacote de aplicações e encripta ou desencripta pacotes e pacotes de aplicações. Esta ferramenta está incluída no SDK do Windows 10 e pode ser usada a partir de um prompt de comando ou um arquivo de script.
Para obter informações sobre como usar MakeApp.exe para empacotar um aplicativo da área de trabalho, consulte Empacotar um aplicativo da área de trabalho manualmente.
Importante
Se você usou o Visual Studio para desenvolver seu aplicativo, é recomendável usar o assistente do Visual Studio para criar seu pacote de aplicativo. Para obter mais informações, consulte Empacotar um aplicativo UWP com o Visual Studio e Empacotar um aplicativo da área de trabalho a partir do código-fonte usando o Visual Studio.
Importante
Observe que MakeAppx.exe não cria um arquivo de carregamento de pacote de aplicativo (.appxupload ou .msixupload), que é o tipo recomendado de pacote de aplicativo válido para envios ao Partner Center. O arquivo de carregamento do pacote do aplicativo normalmente é criado como parte do processo de empacotamento do Visual Studio, embora também possa ser criado manualmente.
Usando MakeAppx.exe
Com base no caminho de instalação do SDK, é aqui que se encontra MakeAppx.exe no seu PC com Windows 10.
- C:\Arquivos de programas (x86)\Windows Kits\10\bin\<número de compilação>\<arquitetura>\makeappx.exe
onde <arquitetura> = x86, x64, arm, arm64 ou chpe. Em alternativa, pode localizar-se em:
- C:\Program Files (x86)\Windows Kits\10\App Certification Kit\makeappx.exe
MakeAppx.exe sintaxe e opções
Sintaxe MakeAppx.exe geral:
MakeAppx <command> [options]
A tabela a seguir descreve os comandos para MakeAppx.exe.
| Comando | Descrição |
|---|---|
| embalagem | Cria um pacote. |
| desembalar | Extrai todos os arquivos no pacote especificado para o diretório de saída especificado. |
| pacote | Cria um pacote. |
| desagregar | Descompacta todos os pacotes num subdiretório sob o caminho de saída especificado, nomeado com o nome completo do conjunto ou pacote. |
| criptografar | Cria um pacote ou uma coleção de aplicativos criptografados a partir do pacote ou coleção de entrada no pacote ou coleção de saída especificado. |
| desencriptar | Cria um pacote ou pacote de aplicação descriptografado a partir do pacote ou pacote de aplicação de entrada no pacote ou pacote de saída especificado. |
Esta lista de opções aplica-se a todos os comandos:
| Opção | Descrição |
|---|---|
| /d | Especifica o diretório de entrada, saída ou conteúdo. |
| /l | Usado para pacotes localizados. As viagens de validação padrão em pacotes localizados. Esta opção desativa apenas essa validação específica, sem exigir que toda a validação seja desativada. |
| /kf | Encripta ou desencripta o pacote ou conjunto usando a chave do ficheiro de chave especificado. Isso não pode ser usado com /kt. |
| /kt | Encripta ou desencripta o pacote ou conjunto utilizando a chave de teste global. Isso não pode ser usado com /kf. |
| /Não | Impede uma substituição do arquivo de saída, se ele existir. Se você não especificar essa opção ou a opção /o, o usuário será perguntado se deseja substituir o arquivo. |
| /nv | Ignora a validação semântica. Se você não especificar essa opção, a ferramenta executará uma validação completa do pacote. |
| /o | Substitui o arquivo de saída, se ele existir. Se você não especificar essa opção ou a opção /no, o usuário será perguntado se deseja substituir o arquivo. |
| /p | Especifica o pacote ou o conjunto da aplicação. |
| /v | Ativa a saída de log verboso para o console. |
| /? | Exibe o texto de ajuda. |
A lista a seguir contém argumentos possíveis:
| Argumento | Descrição |
|---|---|
| <Nome do pacote de saída> | O nome do pacote criado. Este é o nome do arquivo anexado com .msix ou .appx. |
| <Nome do pacote de saída criptografado> | O nome do pacote criptografado criado. Este é o nome do arquivo anexado com .emsix ou .eappx. |
| <nome do pacote de entrada> | O nome do pacote. Este é o nome do arquivo anexado com .msix ou .appx. |
| <Nome do pacote de entrada criptografado> | O nome do pacote criptografado. Este é o nome do arquivo anexado com .emsix ou .eappx. |
| <Nome do pacote de saída> | O nome do pacote criado. Este é o nome de arquivo anexado com .msixbundle ou .appxbundle. |
| <Nome do pacote de saída criptografado> | O nome do pacote criptografado criado. Este é o nome de arquivo anexado com .emsixbundle ou .eappxbundle. |
| <nome do pacote de entrada> | O nome do pacote. Este é o nome de arquivo anexado com .msixbundle ou .appxbundle. |
| <Nome do pacote de entrada criptografado> | O nome do pacote criptografado. Este é o nome de arquivo anexado com .emsixbundle ou .eappxbundle. |
| <Diretório de conteúdo> | Caminho para o pacote de aplicação ou conteúdo de pacote. |
| <Arquivo de mapeamento> | Nome do arquivo que especifica a origem e o destino do pacote. |
| <diretório de saída> | Caminho para o diretório de pacotes e conjuntos de saída. |
| <ficheiro-chave> | Nome do ficheiro que contém uma chave para encriptação ou desencriptação. |
| <ID do algoritmo> | Algoritmos usados ao criar um mapa de blocos. Os algoritmos válidos incluem: SHA256 (padrão), SHA384, SHA512. |
Criar um pacote de aplicativo
Um pacote de aplicativo é um conjunto completo de arquivos do aplicativo empacotados em um arquivo de pacote .msix ou .appx. Para criar um pacote de aplicativo usando o comando pack , você deve fornecer um diretório de conteúdo ou um arquivo de mapeamento para o local do pacote. Você também pode criptografar um pacote ao criá-lo. Se você quiser criptografar o pacote, você deve usar /ep e especificar se você está usando um arquivo de chave (/kf) ou a chave de teste global (/kt). Para obter mais informações sobre como criar um pacote criptografado, consulte Criptografar ou descriptografar um pacote ou conjunto.
Opções específicas para o comando pack :
| Opção | Descrição |
|---|---|
| /f | Especifica o arquivo de mapeamento. |
| /h | Especifica o algoritmo de hash a ser usado ao criar o mapa de blocos. Isso só pode ser usado com o comando pack. Os algoritmos válidos incluem: SHA256 (padrão), SHA384, SHA512. |
| /m | Especifica o caminho para um manifesto do aplicativo de entrada que será usado como base para gerar o manifesto do pacote do aplicativo de saída ou do pacote de recursos. Ao usar essa opção, você também deve usar /f e incluir uma seção [ResourceMetadata] no arquivo de mapeamento para especificar as dimensões do recurso a serem incluídas no manifesto gerado. |
| /nc | Impede a compactação dos arquivos do pacote. Por padrão, os arquivos são compactados com base no tipo de arquivo detetado. |
| /r | Cria um pacote de recursos. Isto deve ser usado com /m e implica o uso da opção /l. |
Os exemplos de uso a seguir mostram algumas opções de sintaxe possíveis para o comando 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
A seguir são mostrados exemplos de linha de comando para o comando 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
Criar um pacote de aplicativos
Um pacote de aplicativos é semelhante a um pacote de aplicativos, mas um pacote pode reduzir o tamanho do aplicativo baixado pelos usuários. Os pacotes de aplicativos são úteis para ativos específicos de idioma, ativos de escala de imagem variáveis ou recursos que se aplicam a versões específicas do Microsoft DirectX, por exemplo. Semelhante à criação de um pacote de aplicativo criptografado, você também pode criptografar o pacote de aplicativos enquanto o agrupa. Para criptografar o pacote de aplicativos, use a opção /ep e especifique se você está usando um arquivo de chave (/kf) ou a chave de teste global (/kt). Para obter mais informações sobre como criar um conjunto criptografado, consulte Criptografar ou descriptografar um pacote ou conjunto.
Opções específicas para o comando bundle :
| Opção | Descrição |
|---|---|
| /bv | Especifica o número da versão do pacote. O número da versão deve estar dividido em quatro partes, separadas por pontos no formato: <Maior>.<Menor>.<Compilação>.<Revisão>. |
| /f | Especifica o arquivo de mapeamento. |
Observe que, se a versão do pacote não for especificada ou estiver definida como "0.0.0.0", o pacote será criado usando a data-hora atual.
Os exemplos de uso a seguir mostram algumas opções de sintaxe possíveis para o comando 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
O bloco a seguir contém exemplos para o comando 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
Extrair ficheiros de um pacote ou conjunto
Além de empacotar e agrupar aplicativos, MakeAppx.exe também pode descompactar ou desagregar pacotes existentes. Você deve fornecer o diretório de conteúdo como um destino para os arquivos extraídos. Se estiver a tentar extrair ficheiros de um pacote ou pacote encriptado, pode desencriptar e extrair os ficheiros ao mesmo tempo usando a opção /ep e especificando se deve ser desencriptado usando um ficheiro de chave (/kf) ou a chave de teste global (/kt). Para obter mais informações sobre como descriptografar um pacote ou pacote, consulte Criptografar ou descriptografar um pacote ou pacote.
Opções específicas para descompactar e desagregar comandos:
| Opção | Descrição |
|---|---|
| /nd | Não executa a decifração ao descompactar ou desagregar o pacote/conjunto. |
| /PFN | Descompacta/desagrega todos os ficheiros para um subdiretório no caminho de saída especificado, nomeado conforme o nome completo do pacote ou conjunto. |
Os exemplos de uso a seguir mostram algumas opções de sintaxe possíveis para os comandos unpack e unbundle :
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
O bloco a seguir contém exemplos para usar os comandos unpack e unbundle :
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
Criptografar ou descriptografar um pacote ou conjunto
A ferramenta MakeAppx.exe também pode encriptar ou desencriptar um pacote ou conjunto existente. Você deve simplesmente fornecer o nome do pacote, o nome do pacote de saída e se a criptografia ou descriptografia deve usar um arquivo de chave (/kf) ou a chave de teste global (/kt).
A criptografia e a descriptografia não estão disponíveis por meio do assistente de empacotamento do Visual Studio.
Opções específicas para encriptar e desencriptar comandos:
| Opção | Descrição |
|---|---|
| /ep | Especifica um pacote de aplicativo ou conjunto criptografado. |
Os exemplos de uso a seguir mostram algumas opções de sintaxe possíveis para os comandos criptografar e descriptografar :
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
O bloco a seguir contém exemplos para usar os comandos criptografar e descriptografar :
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
Dossiês chave
Os arquivos de chave devem começar com uma linha contendo a cadeia de caracteres "[Keys]" seguida por linhas que descrevem as chaves com as quais criptografar cada pacote. Cada tecla é representada por um par de cadeias de caracteres entre aspas, separadas por espaços ou tabulações. A primeira cadeia de caracteres representa o ID da chave de 32 bytes codificada em base64 e a segunda representa a chave de criptografia de 32 bytes codificada em base64. Um arquivo de chave deve ser um arquivo de texto simples.
Exemplo de um arquivo de chave:
[Keys]
"OWVwSzliRGY1VWt1ODk4N1Q4R2Vqc04zMzIzNnlUREU=" "MjNFTlFhZGRGZEY2YnVxMTBocjd6THdOdk9pZkpvelc="
Arquivos de mapeamento
Os arquivos de mapeamento devem começar com uma linha contendo a cadeia de caracteres "[Arquivos]" seguida por linhas que descrevem os arquivos a serem adicionados ao pacote. Cada arquivo é descrito por um par de caminhos entre aspas, separados por espaços ou guias. Cada arquivo representa sua origem (no disco) e destino (no pacote). Um arquivo de mapeamento deve ser um arquivo de texto simples.
Exemplo de um arquivo de mapeamento (sem a opção /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"
Ao usar um arquivo de mapeamento, você pode escolher se deseja usar a opção /m. A opção /m permite que o usuário especifique os metadados do recurso no arquivo de mapeamento a ser incluído no manifesto gerado. Se você usar a opção /m, o arquivo de mapeamento deverá conter uma seção que começa com a linha "[ResourceMetadata]", seguida por linhas que especificam "ResourceDimensions" e "ResourceId". É possível que um pacote de aplicativo contenha vários "ResourceDimensions", mas só pode haver um "ResourceId".
Exemplo de um arquivo de mapeamento (com a opção /m):
[ResourceMetadata]
"ResourceDimensions" "language-en-us"
"ResourceId" "English"
[Files]
"images\en-us\logo.png" "en-us\logo.png"
"en-us.pri" "resources.pri"
Validação semântica realizada por MakeAppx.exe
MakeAppx.exe executa uma validação semática limitada projetada para detetar os erros de implantação mais comuns e ajudar a garantir que o pacote do aplicativo seja válido. Consulte a opção /nv se quiser ignorar a validação ao usar MakeAppx.exe.
Esta validação garante que:
- Todos os arquivos referenciados no manifesto do pacote são incluídos no pacote do aplicativo.
- Um aplicativo não tem duas chaves idênticas.
- Um aplicativo não se registra para um protocolo proibido desta lista: SMB, FILE, MS-WWA-WEB, MS-WWA.
Esta não é uma validação semântica completa, pois é projetada apenas para detetar erros comuns. Não é garantido que os pacotes criados por MakeAppx.exe sejam instaláveis.