# Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados
O multipart upload permite que você faça upload de um único objeto como um conjunto de partes. Cada parte é uma parte contígua de dados do objeto. O upload dessas partes de objetos pode ser feito de maneira independente e em qualquer ordem. Se a transmissão de alguma parte falhar, você poderá retransmitir essa parte sem afetar outras partes. Depois que todas as partes do objeto forem carregadas, o Amazon S3 montará essas partes e criará o objeto. Geralmente, quando seu objeto alcança 100 MB de tamanho, você deve considerar o uso de multipart uploads em vez de fazer upload do objeto em uma única operação. Para obter mais informações sobre multipart uploads, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md). Para ver os limites relacionados a carregamentos fracionados, consulte [Limites do multipart upload do Amazon S3](qfacts.md).
É possível usar somas de verificação para verificar se os ativos não são alterados quando copiados. A execução de uma soma de verificação consiste em usar um algoritmo para iterar sequencialmente sobre cada byte em um arquivo. O Amazon S3 oferece várias opções de soma de verificação para conferir a integridade dos dados. Recomendamos que você execute essas verificações de integridade como prática recomendada de durabilidade e para garantir que cada byte seja transferido sem alteração. O Amazon S3 também é compatível com os seguintes algoritmos: SHA-1, SHA-256, CRC32 e CRC32C. O Amazon S3 usa um ou mais desses algoritmos para calcular um valor de soma de verificação adicional e armazená-lo como parte dos metadados do objeto. Para ter mais informações sobre somas de verificação, consulte [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
**Objetivo**
Neste tutorial, você aprenderá a fazer upload de um objeto no Amazon S3 usando um carregamento fracionado e uma soma de verificação SHA-256 adicional por meio da AWS Command Line Interface (AWS CLI). Você também aprenderá a conferir a integridade dos dados do objeto calculando o hash MD5 e a soma de verificação SHA-256 do objeto carregado.
**Topics**
+ [Pré-requisitos](#mpu-prerequisites)
+ [Etapa 1: criar um arquivo grande](#create-large-file-step1)
+ [Etapa 2: dividir o arquivo em vários arquivos](#split-large-file-step2)
+ [Etapa 3: criar o carregamento fracionado com uma soma de verificação adicional](#create-multipart-upload-step3)
+ [Etapa 4: fazer upload das partes do carregamento fracionado](#upload-parts-step4)
+ [Etapa 5: listar todas as partes do carregamento fracionado](#list-parts-step5)
+ [Etapa 6: concluir o carregamento fracionado](#complete-multipart-upload-step6)
+ [Etapa 7: confirmar se o objeto foi carregado no bucket](#confirm-upload-step7)
+ [Etapa 8: verificar a integridade do objeto com uma soma de verificação MD5](#verify-object-integrity-step8)
+ [Etapa 9: verificar a integridade do objeto com uma soma de verificação adicional](#verify-object-integrity-sha256-step9)
+ [Etapa 10: Limpar os recursos](#clean-up-step10)
## Pré-requisitos
+ Antes de iniciar este tutorial, confira se você tem acesso a um bucket do Amazon S3 para o qual possa fazer upload. Para obter mais informações, consulte [Criar um bucket de uso geral](create-bucket-overview.md).
+ É necessário ter a AWS CLI instalada e configurada. Se você ainda não tiver a AWS CLI instalada, consulte [Install or update to the latest version of the AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html) no *Guia do usuário da AWS Command Line Interface*.
+ Também é possível executar comandos da AWS CLI pelo console usando o AWS CloudShell. O AWS CloudShell é um shell pré-autenticado e baseado em navegador que você pode iniciar diretamente do Console de gerenciamento da AWS. Para ter mais informações, consulte [What is CloudShell?](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) e [Getting started with AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html) no *Guia do usuário do AWS CloudShell*.
## Etapa 1: criar um arquivo grande
Se você já tiver um arquivo pronto para upload, poderá usá-lo para este tutorial. Caso contrário, crie um arquivo de 15 MB usando as etapas a seguir. Para ver os limites relacionados a carregamentos fracionados, consulte [Limites do multipart upload do Amazon S3](qfacts.md).
**Como criar um arquivo grande**
Use um dos seguintes comandos para criar o arquivo, dependendo do sistema operacional que estiver usando.
**Linux ou macOS**
Para criar um arquivo de 15 MB, abra o terminal local e execute o seguinte comando:
```
dd if=/dev/urandom of=census-data.bin bs=1M count=15
```
Esse comando cria um arquivo de 15 MB denominado `census-data.bin` preenchido com bytes aleatórios.
**Windows**
Para criar um arquivo de 15 MB, abra o terminal local e execute o seguinte comando:
```
fsutil file createnew census-data.bin 15728640
```
Esse comando cria um arquivo denominado `census-data.bin` com um tamanho de 15 MB de dados arbitrários (15.728.640 bytes).
## Etapa 2: dividir o arquivo em vários arquivos
Para realizar o carregamento fracionado, é necessário dividir o arquivo grande em partes menores. Depois, é possível fazer upload das partes menores usando o processo de carregamento fracionado. Esta etapa demonstra como dividir em partes menores o arquivo grande criado na [Etapa 1](#create-large-file-step1). O exemplo a seguir usa um arquivo de 15 MB denominado `census-data.bin`.
**Como dividir um arquivo grande em partes**
**Linux ou macOS**
Para dividir o arquivo grande em partes de 5 MB, use o comando `split`. Abra o terminal e execute o seguinte:
```
split -b 5M -d census-data.bin census-part
```
Esse comando divide `census-data.bin` em partes de 5 MB denominadas `census-part**`, em que `**` é um sufixo numérico de `00`.
**Windows**
Para dividir o arquivo grande, use o PowerShell. Abra o [PowerShell](https://learn.microsoft.com/en-us/powershell/) e execute o seguinte script:
```
$inputFile = "census-data.bin"
$outputFilePrefix = "census-part"
$chunkSize = 5MB
$fs = [System.IO.File]::OpenRead($inputFile)
$buffer = New-Object byte[] $chunkSize
$fileNumber = 0
while ($fs.Position -lt $fs.Length) {
$bytesRead = $fs.Read($buffer, 0, $chunkSize)
$outputFile = "{0}{1:D2}" -f $outputFilePrefix, $fileNumber
$fileStream = [System.IO.File]::Create($outputFile)
$fileStream.Write($buffer, 0, $bytesRead)
$fileStream.Close()
$fileNumber++
}
$fs.Close()
```
O script do PowerShell lê o arquivo grande em partes de 5 MB e grava cada uma em um novo arquivo com um sufixo numérico.
Depois de executar o comando apropriado, você deverá ver as partes no diretório no qual executou o comando. Cada parte terá um sufixo correspondente ao número da parte, por exemplo:
```
census-part00 census-part01 census-part02
```
## Etapa 3: criar o carregamento fracionado com uma soma de verificação adicional
Para iniciar o processo de carregamento fracionado, é necessário criar a solicitação de carregamento fracionado. Essa etapa envolve iniciar o carregamento fracionado e especificar uma soma de verificação adicional para a integridade dos dados. O exemplo a seguir usa a soma de verificação SHA-256. Se você quiser fornecer metadados que descrevam o objeto que está sendo carregado, deverá fornecê-los na solicitação para iniciar o carregamento fracionado.
**nota**
Nesta etapa e nas etapas subsequentes, este tutorial usa o algoritmo adicional SHA-256. Também é possível usar outra soma de verificação adicional para essas etapas, como CRC32, CRC32C ou SHA-1. Se você usar um algoritmo diferente, deverá usá-lo em todas as etapas do tutorial.
**Como iniciar o carregamento fracionado**
No terminal, use o comando `create-multipart-upload` a seguir para iniciar um carregamento fracionado para o bucket. Substitua `{{{{amzn-s3-demo-bucket1}}}}` pelo nome do bucket real. Além disso, substitua o `census_data_file` pelo nome do arquivo escolhido. Esse nome de arquivo torna-se a chave do objeto quando o upload é concluído.
```
aws s3api create-multipart-upload --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --checksum-algorithm sha256
```
Se a solicitação for bem-sucedida, você verá uma saída JSON como a seguinte:
```
{
"ServerSideEncryption": "AES256",
"ChecksumAlgorithm": "SHA256",
"Bucket": "{{amzn-s3-demo-bucket1}}",
"Key": "census_data_file",
"UploadId": "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz"
}
```
**nota**
Quando você envia uma solicitação para iniciar um multipart upload, o Amazon S3 retorna uma resposta com um ID de upload, que é um identificador exclusivo do seu multipart upload. É necessário incluir esse ID de upload sempre que fizer upload de partes, listar as partes, concluir um upload ou interromper um upload. Será necessário usar os valores `UploadId`, `Key` e `Bucket` para as etapas posteriores; portanto, lembre-se de salvá-los.
Além disso, se você estiver usando um carregamento fracionado com somas de verificação adicionais, os números das partes deverão ser consecutivos. Se você usar números de parte não consecutivos, a solicitação `complete-multipart-upload` poderá gerar um HTTP `500 Internal Server Error`.
## Etapa 4: fazer upload das partes do carregamento fracionado
Nesta etapa, você fará upload das partes do carregamento fracionado no bucket do S3. Use o comando `upload-part` para fazer upload de cada parte individualmente. Esse processo requer a especificação do ID do upload, do número da parte e do arquivo a ser carregado para cada parte.
**Como fazer upload das partes**
1. Ao fazer upload de uma parte, além do ID do upload, é necessário especificar o número da parte usando o argumento `--part-number`. Você pode escolher qualquer número de parte entre 1 e 10.000. Um número de parte identifica com exclusividade a parte e sua posição no objeto do qual você está fazendo upload. O número da parte que você escolher não precisa estar em uma sequência consecutiva (por exemplo, pode ser 1, 2 ou 3). Se você fizer upload de uma nova parte usando o mesmo número da parte anteriormente carregada, a parte anteriormente carregada será substituída.
1. Use o comando `upload-part` para fazer upload de cada parte do carregamento fracionado. O `--upload-id` é o mesmo que estava na saída criada pelo comando `create-multipart-upload` na [Etapa 3](#create-multipart-upload-step3). Para fazer upload da primeira parte dos dados, use o seguinte comando:
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --part-number {{1}} --body {{census-part00}} --upload-id "{{cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz}}" --checksum-algorithm {{SHA256}}
```
Após a conclusão de cada comando `upload-part`, você deverá ver uma saída como a seguinte:
```
{
"ServerSideEncryption": "AES256",
"ETag": "\"e611693805e812ef37f96c9937605e69\"",
"ChecksumSHA256": "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0="
}
```
1. Para as partes subsequentes, aumente o número da parte apropriadamente:
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --part-number {{}} --body --upload-id "" --checksum-algorithm SHA256
```
Por exemplo, use o seguinte comando para fazer upload da segunda parte:
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key 'census_data_file' --part-number 2 --body census-part01 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
O Amazon S3 exibe uma tag de entidade (ETag) e somas de verificação adicionais para cada parte carregada como cabeçalho na resposta.
1. Continue usando o comando `upload-part` até fazer upload de todas as partes do objeto.
## Etapa 5: listar todas as partes do carregamento fracionado
Para concluir o carregamento fracionado, você precisará de uma lista de todas as partes que foram carregadas para esse carregamento fracionado específico. A saída do comando `list-parts` fornece algumas informações, como nome do bucket, chave, ID do upload, número da parte, ETag, somas de verificação adicionais etc. É útil salvar essa saída em um arquivo para que você possa usá-la na próxima etapa ao concluir o processo de carregamento fracionado. É possível criar um arquivo de saída JSON chamado `parts.json` usando o método a seguir.
**Como criar um arquivo que liste todas as partes**
1. Para gerar um arquivo JSON com os detalhes de todas as partes carregadas, use o comando `list-parts` a seguir. Substitua **{{amzn-s3-demo-bucket1}}** pelo nome real do bucket e **** pelo ID de upload recebido na [Etapa 3](#create-multipart-upload-step3). Para ter mais informações sobre o comando `list-parts`, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html) no *Guia do usuário da AWS Command Line Interface*.
```
aws s3api list-parts --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --upload-id {{}} --query '{Parts: Parts[*].{PartNumber: PartNumber, ETag: ETag, ChecksumSHA256: ChecksumSHA256}}' --output json > parts.json
```
Um novo arquivo chamado `parts.json` é gerado. O arquivo contém as informações em formato JSON de todas as partes carregadas. O arquivo `parts.json` inclui informações essenciais para cada parte do carregamento fracionado, como os números de parte e os valores de ETag correspondentes, os quais são necessários para concluir o processo de carregamento fracionado.
1. Abra `parts.json` usando qualquer editor de texto ou pelo terminal. Veja a saída de exemplo:
```
{
"Parts": [
{
"PartNumber": 1,
"ETag": "\"3c3097f89e2a2fece47ac54b243c9d97\"",
"ChecksumSHA256": "fTPVHfyNHdv5VkR4S3EewdyioXECv7JBxN+d4FXYYTw="
},
{
"PartNumber": 2,
"ETag": "\"03c71cc160261b20ab74f6d2c476b450\"",
"ChecksumSHA256": "VDWTa8enjOvULBAO3W2a6C+5/7ZnNjrnLApa1QVc3FE="
},
{
"PartNumber": 3,
"ETag": "\"81ae0937404429a97967dffa7eb4affb\"",
"ChecksumSHA256": "cVVkXehUlzcwrBrXgPIM+EKQXPUvWist8mlUTCs4bg8="
}
]
}
```
## Etapa 6: concluir o carregamento fracionado
Depois de fazer upload de todas as partes do carregamento fracionado e listá-las, a etapa final é concluir o carregamento fracionado. Essa etapa mescla todas as partes carregadas em um único objeto no bucket do S3.
**nota**
É possível calcular a soma de verificação do objeto antes de chamar `complete-multipart-upload` incluindo `--checksum-sha256` na solicitação. Se as somas de verificação não coincidirem, o Amazon S3 rejeitará a solicitação. Consulte mais informações em [https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html) no *Guia de Usuário AWS Command Line Interface*.
**Como concluir o carregamento fracionado**
Para finalizar o carregamento fracionado, use o comando `complete-multipart-upload`. Esse comando requer o arquivo `parts.json` criado na [Etapa 5](#list-parts-step5), o nome do bucket e o ID do upload. Substitua **<{{amzn-s3-demo-bucket1}}>** pelo nome do bucket e **** pelo ID do upload de `parts.json`.
```
aws s3api complete-multipart-upload --multipart-upload file://parts.json --bucket {{amzn-s3-demo-bucket1}} --key 'census_data_file' --upload-id
```
Veja a saída de exemplo:
```
{
"ServerSideEncryption": "AES256",
"Location": "https://{{amzn-s3-demo-bucket1}}.s3.us-east-2.amazonaws.com/census_data_file",
"Bucket": "{{amzn-s3-demo-bucket1}}",
"Key": "census_data_file",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3"
}
```
**nota**
Não exclua ainda os arquivos de parte individuais. Você precisará das partes individuais para poder realizar somas de verificação e conferir a integridade do objeto mesclado.
## Etapa 7: confirmar se o objeto foi carregado no bucket
Depois de concluir o carregamento fracionado, você poderá verificar se o objeto foi carregado com êxito no bucket do S3. Para listar os objetos no bucket e confirmar a presença do arquivo recém-carregado, use o comando `list-objects-v2`
**Como listar o objeto carregado**
Para listar os objetos no bucket, use o bucket de comando `list-objects-v2`. Substitua **{{amzn-s3-demo-bucket1}}** pelo nome do bucket real.
```
aws s3api list-objects-v2 --bucket {{amzn-s3-demo-bucket1}}
```
Esse comando exibe uma lista de objetos no bucket. Procure o arquivo carregado (por exemplo, `census_data_file`) na lista de objetos.
Para ter mais informações, consulte a seção [Examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects-v2.html) do comando `list-objects-v2` no *Guia do usuário do AWS Command Line Interface*.
## Etapa 8: verificar a integridade do objeto com uma soma de verificação MD5
Ao fazer upload de um objeto, é possível especificar um algoritmo de soma de verificação a ser usado pelo Amazon S3. Por padrão, o Amazon S3 armazena o resumo MD5 de bytes como ETag do objeto. Para carregamentos fracionados, a ETag não é a soma de verificação do objeto completo, mas um composto de somas de verificação de cada parte.
**Como verificar a integridade do objeto usando uma soma de verificação MD5**
1. Para recuperar a ETag do objeto carregado, faça uma solicitação `head-object`:
```
aws s3api head-object --bucket {{amzn-s3-demo-bucket1}} --key {{census_data_file}}
```
Veja a saída de exemplo:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
Essa ETag tem “-3” anexado ao final. Isso indica que o objeto foi carregado em três partes usando o carregamento fracionado.
1. Depois, calcule a soma de verificação MD5 de cada parte usando o comando `md5sum`. Forneça o caminho correto para os arquivos de parte:
```
md5sum census-part*
```
Veja a saída de exemplo:
```
e611693805e812ef37f96c9937605e69 census-part00
63d2d5da159178785bfd6b6a5c635854 census-part01
95b87c7db852451bb38b3b44a4e6d310 census-part02
```
1. Para esta etapa, combine manualmente os hashes MD5 em uma string. Depois, execute o comando a seguir para converter a string em binário e calcular a soma de verificação MD5 do valor binário:
```
echo "{{e611693805e812ef37f96c9937605e6963d2d5da159178785bfd6b6a5c63585495b87c7db852451bb38b3b44a4e6d310}}" | xxd -r -p | md5sum
```
Veja a saída de exemplo:
```
f453c6dccca969c457efdf9b1361e291 -
```
Esse valor de hash deve corresponder ao valor de hash do valor da ETag original na [Etapa 1](#create-large-file-step1), que valida a integridade do objeto `census_data_file`.
Quando você instrui o Amazon S3 a usar somas de verificação adicionais, ele calcula o respectivo valor para cada parte e armazena os valores. Se você quiser recuperar os valores da soma de verificação para partes individuais de carregamentos fracionados ainda em andamento, poderá usar `list-parts`.
Consulte mais informações sobre como as somas de verificação funcionam com objetos de carregamento fracionado em [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
## Etapa 9: verificar a integridade do objeto com uma soma de verificação adicional
Nesta etapa, este tutorial usa o SHA-256 como uma soma de verificação adicional para validar a integridade do objeto. Se você usou uma soma de verificação adicional diferente, use esse valor de soma de verificação.
**Como verificar a integridade do objeto com SHA256**
1. Execute o seguinte comando no terminal, incluindo o argumento `--checksum-mode enabled`, para exibir o valor `ChecksumSHA256` do objeto:
```
aws s3api head-object --bucket {{amzn-s3-demo-bucket1}} --key census_data_file --checksum-mode enabled
```
Veja a saída de exemplo:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
1. Use os comandos a seguir para decodificar os valores `ChecksumSHA256` das partes individuais em base64 e salvá-los em um arquivo binário chamado `outfile`. Esses valores podem ser encontrados no arquivo `parts.json`. Substitua as strings base64 de exemplo pelos valores `ChecksumSHA256` reais.
```
echo "{{QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0=}}" | base64 --decode >> outfile
echo "{{xCdgs1K5Bm4jWETYw/CmGYr+m6O2DcGfpckx5NVokvE=}}" | base64 --decode >> outfile
echo "{{f5wsfsa5bB+yXuwzqG1Bst91uYneqGD3CCidpb54mAo=}}" | base64 --decode >> outfile
```
1. Execute o seguinte comando para calcular a soma de verificação SHA256 do `outfile`:
```
sha256sum outfile
```
Veja a saída de exemplo:
```
688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9 outfile
```
Na próxima etapa, converta o valor do hash em um valor binário. Esse valor binário deve corresponder ao valor `ChecksumSHA256` da [Etapa 1](#create-large-file-step1).
1. Converta a soma de verificação SHA256 da [Etapa 3](#create-multipart-upload-step3) em um valor binário e, depois, codifique-o em base64 para verificar se ele corresponde ao valor `ChecksumSHA256` da [Etapa 1](#create-large-file-step1):
```
echo "688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9" | xxd -r -p | base64
```
Veja a saída de exemplo:
```
aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=
```
Essa saída deve confirmar se a saída base64 corresponde ao valor `ChecksumSHA256` da saída do comando `head-object`. Se a saída corresponder ao valor da soma de verificação, o objeto será válido.
**Importante**
Quando você instrui o Amazon S3 a usar somas de verificação adicionais, ele calcula os respectivos valores para cada parte e armazena esses valores.
Se você quiser recuperar os valores da soma de verificação para partes individuais de carregamentos fracionados ainda em andamento, poderá usar o comando `list-parts`.
## Etapa 10: Limpar os recursos
Se você quiser limpar os arquivos criados neste tutorial, use o método a seguir. Para obter instruções sobre como excluir os arquivos carregados no bucket do S3, consulte [Excluir objetos do Amazon S3](DeletingObjects.md).
**Exclua os arquivos locais criados na [Etapa 1](#create-large-file-step1):**
Para remover os arquivos criados para o carregamento fracionado, execute o seguinte comando no diretório de trabalho:
```
rm {{census-data.bin}} census-part* outfile parts.json
```