Criar um pacote ou pacote MSIX com MakeAppx.exe

MakeAppx.exe cria pacotes de aplicativos (.msix ou .appx) e pacotes de pacotes de aplicativo (.msixbundle ou .appxbundle). Além disso, a MakeAppx.exe extrai arquivos de um pacote ou lote de aplicativo e criptografa ou descriptografa pacotes e lotes de aplicativos. Essa ferramenta está incluída no SDK do Windows 10 e pode ser usada em 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 app, é recomendável que você use o Assistente do Visual Studio para criar e assinar seu pacote de app. Para obter mais informações, consulte Empacotar um aplicativo UWP com Visual Studio e empacotar um aplicativo da área de trabalho do código-fonte usando 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 de aplicativo normalmente é criado como parte do processo de empacotamento Visual Studio, embora também possa ser criado manualmente.

Usando a MakeAppx.exe

Dependendo do seu caminho de instalação do SDK, a MakeAppx.exe é instalada no computador Windows 10 nos seguintes locais:

  • C:\Arquivos de Programas (x86)\Windows Kits\10\bin\<build number>\<architecture>\makeappx.exe

onde <arquitetura> = x86, x64, arm, arm64 ou chpe. Como alternativa, ele pode estar localizado em:

  • C:\Arquivos de Programas (x86)\Windows Kits\10\Certificação de Aplicativos Kit\makeappx.exe

Sintaxe e opções da MakeAppx.exe

Sintaxe geral da MakeAppx.exe:

MakeAppx <command> [options]      

A tabela a seguir descreve os comandos da MakeAppx.exe.

Comando Descrição
pack Cria um pacote.
unpack Extrai todos os arquivos do pacote especificado para o diretório de saída especificado.
bundle Cria um pacote.
unbundle Desempacota todos os pacotes em um subdiretório no caminho de saída especificado com o nome completo do pacote ou do pacote.
encrypt Cria um pacote ou lote de aplicativo criptografado a partir do pacote/lote de entrada no pacote/lote de saída especificado.
descriptografar Cria um pacote ou lote de aplicativo descriptografado a partir do pacote/lote de aplicativo de entrada no pacote/lote de saída especificado.

Esta lista de opções se aplica a todos os comandos:

Opção Descrição
/d Especifica a entrada, a saída ou o diretório de conteúdo.
/l Usado para pacotes localizados. A validação padrão é bloqueada em pacotes localizados. Essas opção desabilita apenas aquela validação específica, sem exigir que todas as validações sejam desabilitadas.
/kf Criptografa ou descriptografa o pacote ou lote usando a chave do arquivo de chave especificado. Essa opção não pode ser usada com /kt.
/kt Criptografa ou descriptografa o pacote ou lote usando a chave de teste global. Essa opção não pode ser usada com /kf.
/no Impede uma substituição do arquivo de saída, se houver. Se você não especificar essa opção ou a opção /o, será perguntado ao usuário se ele 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 houver. Se você não especificar essa opção ou a opção /no, será perguntado ao usuário se ele deseja substituir o arquivo.
/p Especifica o pacote ou lote de aplicativo.
/v Habilita a saída do log detalhado no console.
/? Exibe o texto da Ajuda.

A lista a seguir contém argumentos possíveis:

Argument Descrição
<output package name> O nome do pacote criado. Esse é o nome do arquivo acrescentado com .msix ou .appx.
<encrypted output package name> O nome do pacote criptografado criado. Esse é o nome do arquivo acrescentado com .emsix ou .eappx.
<input package name> O nome do pacote. Esse é o nome do arquivo acrescentado com .msix ou .appx.
<encrypted input package name> O nome do pacote criptografado. Esse é o nome do arquivo acrescentado com .emsix ou .eappx.
<output bundle name> O nome do lote criado. Esse é o nome do arquivo acrescentado com .msixbundle ou .appxbundle.
<encrypted output bundle name> O nome do lote criptografado criado. Esse é o nome do arquivo acrescentado com .emsixbundle ou .eappxbundle.
<input bundle name> O nome do lote. Esse é o nome do arquivo acrescentado com .msixbundle ou .appxbundle.
<encrypted input bundle name> O nome do lote criptografado. Esse é o nome do arquivo acrescentado com .emsixbundle ou .eappxbundle.
<content directory> Caminho do conteúdo do pacote ou lote de aplicativo.
<mapping file> Nome do arquivo que especifica a origem e o destino do pacote.
<output directory> Caminho do diretório de pacotes e lotes de saída.
<key file> Nome do arquivo que contém uma chave de criptografia ou descriptografia.
<algorithm ID> Algoritmos usados durante a criação de 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 informar 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 desejar criptografar o pacote, você deverá usar /ep e especificar se está usando um arquivo de chave (/kf) ou a tecla de teste global (/kt). Para obter mais informações sobre como criar um pacote criptografado, consulte Criptografar ou descriptografar um pacote ou um lote.

Opções específicas ao 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 pode ser usado apenas com o comando pack. Os algoritmos válidos incluem: SHA256 (padrão), SHA384, SHA512.
/m Especifica o caminho de um manifesto de aplicativo de entrada que será usado como base para gerar o pacote de aplicativo de saída ou o manifesto 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 detectado.
/r Cria um pacote de recursos. Isso 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 estão alguns 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 lote de aplicativo

Um lote de aplicativo é semelhante a um pacote de aplicativo, mas um lote pode reduzir o tamanho do app que os usuários baixam. Os lotes de aplicativos são úteis para ativos específicos ao 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, também é possível criptografar o lote de aplicativo ao agrupá-lo. Para criptografar o lote de aplicativo, use a opção /ep e especifique se está usando um arquivo de chave (/kf) ou a tecla de teste global (/kt). Para obter mais informações sobre como criar um lote criptografado, consulte Criptografar ou descriptografar um pacote ou um lote.

Opções específicas ao comando bundle:

Opção Descrição
/bv Especifica o número de versão do lote. O número de versão deve estar em quatro partes separadas por pontos no formato: <Principal>.<Secundário>.<Compilação>.<Revisão>.
/f Especifica o arquivo de mapeamento.

Observe que, se a versão do lote não for especificada ou se estiver definida como "0.0.0.0", o lote será criado com a data e a hora atuais.

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 seguinte bloco contém exemplos do 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 arquivos de um pacote ou um lote

Além de empacotar e agrupar apps, a MakeAppx.exe também pode desempacotar ou desagrupar pacotes existentes. Você deve fornecer o diretório de conteúdo como um destino para os arquivos extraídos. Se você estiver tentando extrair arquivos de um pacote ou um lote criptografado, poderá descriptografar e extrair os arquivos ao mesmo tempo usando a opção /ep e especificando se ele deve ser descriptografado com um arquivo de chave (/kf) ou a chave de teste global (/kt). Para obter mais informações sobre como descriptografar um pacote ou um lote, consulte Criptografar ou descriptografar um pacote ou um lote.

Opções específicas aos comandos unpack e unbundle:

Opção Descrição
/nd Não realiza a descriptografia ao descompactar ou desagrupar o pacote/lote.
/pfn Desempacotar/desagrupar todos os arquivos em um subdiretório no caminho de saída especificado, com o nome completo do pacote ou pacote

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 seguinte bloco contém exemplos de uso dos 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 um lote

A ferramenta MakeAppx.exe também pode criptografar ou descriptografar um pacote ou um lote existente. Você deve simplesmente informar 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 com o Assistente de empacotamento do Visual Studio.

Opções específicas aos comandos encrypt e decrypt:

Opção Descrição
/ep Especifica um pacote ou lote de aplicativo criptografado.

Os exemplos de uso a seguir mostram algumas opções de sintaxe possíveis para os comandos encrypt e decrypt:

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 seguinte bloco contém exemplos de uso dos comandos encrypt e decrypt:

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

Arquivos de chave

Os arquivos de chave devem iniciar com uma linha contendo a cadeia de caracteres "[Keys]" seguida por linhas que descrevem as chaves com as quais criptografar cada pacote. Cada chave é representada por um par de cadeias de caracteres entre aspas, separadas por espaços ou tabulações. A primeira cadeia de caracteres representa a 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 iniciar com uma linha contendo a cadeia de caracteres "[Files]" 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 tabulações. Cada arquivo representa sua origem (no disco) e seu 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ê poderá 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 serem incluídos no manifesto gerado. Se você usar a opção /m, o arquivo de mapeamento deverá conter uma seção que comece com a linha "[ResourceMetadata]", seguida por linhas que especificam "ResourceDimensions" e "ResourceId". É possível que um pacote de aplicativo contenha várias "ResourceDimensions", mas só pode haver uma "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

A MakeAppx.exe realiza a validação semântica limitada, que é projetada para capturar os erros mais comuns de implantação e ajudar a garantir que o pacote de aplicativo seja válido. Consulte a opção /nv se desejar ignorar a validação ao usar a MakeAppx.exe.

Essa validação garante que:

  • Todos os arquivos referenciados no manifesto do pacote sejam incluídos no pacote de aplicativo.
  • Um app não tenha duas chaves idênticas.
  • Um app não seja registrado para um protocolo proibido desta lista: SMB, FILE, MS-WWA-WEB, MS-WWA.

Essa não é uma validação semântica completa, já que é projetada apenas para capturar erros comuns. Os pacotes compilados pela MakeAppx.exe não são garantidos como instaláveis.