O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Carregar dados do Amazon S3
O comando COPY utiliza a arquitetura de processamento paralelo em massa (MPP) do Amazon Redshift para ler e carregar dados em paralelo de um ou mais arquivos em um bucket do Amazon S3. Aproveite ao máximo a vantagem do processamento paralelo dividindo seus dados em vários arquivos, nos casos em que os arquivos são compactados. (Há exceções a essa regra. Elas são detalhados em [Carregar arquivos de dados](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-multiple-files.html).) Você também pode aproveitar ao máximo a vantagem do processamento paralelo ao configurar chaves de distribuição em suas tabelas. Para obter mais informações sobre chaves de distribuição, consulte [Distribuição de dados para otimização de consultas](t_Distributing_data.md).
Os dados são carregados em uma tabela de destino, uma linha por linha. Os campos no arquivo de dados são correspondidos com as colunas da tabela em ordem, da esquerda para a direita. Os campos nos arquivos de dados podem ser de largura fixa ou delimitados por caracteres; o delimitador padrão é um pipe (\$1). Por padrão, todas as colunas da tabela são carregadas, mas você pode, opcionalmente, definir uma lista de colunas separadas por vírgula. Se uma tabela não foi incluída na lista de colunas especificada no comando COPY, ela será carregada com um valor padrão. Para obter mais informações, consulte [Carregamento de valores padrão de coluna](c_loading_default_values.md).
**Topics**
+ [Carregar dados de arquivos compactados e não compactados](t_splitting-data-files.md)
+ [Carregar arquivos no Amazon S3 para usar com COPY](t_uploading-data-to-S3.md)
+ [Usando o comando COPY para carregar do Amazon S3](t_loading-tables-from-s3.md)
# Carregar dados de arquivos compactados e não compactados
Ao carregar dados compactados, recomendamos dividir os dados de cada tabela em vários arquivos. Quando você carrega dados descompactados e delimitados, o comando COPY usa processamento paralelo em massa (MPP) e intervalos de varredura para carregar dados de arquivos grandes em um bucket do Amazon S3.
## Carregar dados de vários arquivos compactados
Caso você tenha dados compactados, recomendamos dividir os dados de cada tabela em vários arquivos. O comando COPY pode carregar dados a partir de vários arquivos em paralelo. Você pode carregar vários arquivos especificando um prefixo comum ou *prefixo de chave* para o conjunto ou listando explicitamente os arquivos em um arquivo manifesto.
Divida seus dados em arquivos de modo que o número de arquivos seja um múltiplo do número de fatias em seu cluster. Assim, o Amazon Redshift pode dividir os dados igualmente entre as fatias. O número de fatias por nó depende do tamanho do nó do cluster. Por exemplo, cada nó de computação dc2.large tem duas fatias e cada nó de computação dc2.8xlarge tem 16 fatias. Para obter mais informações sobre o número de fatias que cada tamanho de nó possui, consulte “[Clusters e nós no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes)” no *Guia de gerenciamento de clusters do Amazon Redshift*.
Todos os nós participam da execução de consultas paralelas, trabalhando nos dados que são distribuídos da maneira mais uniforme possível pelas fatias. Caso tenha um cluster com dois nós dc2.large, você poderá dividir os dados em quatro arquivos ou em um múltiplo de quatro. O Amazon Redshift não leva em conta o tamanho do arquivo ao dividir o workload. Desse modo, você precisa garantir que os arquivos tenham aproximadamente o mesmo tamanho, de 1 MB a 1 GB, após a compactação.
Para usar prefixos de objeto para identificar arquivos de carregamento, nomeie cada arquivo com um prefixo comum. Por exemplo, você poderá dividir o arquivo `venue.txt` em quatro arquivos, do modo a seguir.
```
venue.txt.1
venue.txt.2
venue.txt.3
venue.txt.4
```
Ao colocar vários arquivos em uma pasta de seu bucket, você pode especificar o nome da pasta como o prefixo, e o COPY carregará todos os arquivos na pasta. Se você explicitamente listar os arquivos a serem carregador usando um arquivo manifesto, os arquivos podem residir em buckets ou pastas diferentes.
Para obter mais informações sobre arquivos manifesto, consulte [Uso de um manifesto para especificar arquivos de dados](r_COPY_command_examples.md#copy-command-examples-manifest).
## Carregar dados de arquivos descompactados e delimitados
Ao carregar dados delimitados e descompactados, o comando COPY usa a arquitetura de processamento paralelo em massa (MPP) no Amazon Redshift. O Amazon Redshift usa automaticamente fatias que trabalham em paralelo para carregar intervalos de dados de um arquivo grande para um bucket do Amazon S3. Para que o carregamento paralelo ocorra, o arquivo deve ser delimitado. Por exemplo, delimitado por barras verticais. O carregamento de dados automático e paralelo com o comando COPY também está disponível para arquivos CSV. Você também pode utilizar o processamento paralelo configurando chaves de distribuição em suas tabelas. Para obter mais informações sobre chaves de distribuição, consulte [Distribuição de dados para otimização de consultas](t_Distributing_data.md).
O carregamento paralelo automático não é compatível quando a consulta COPY inclui uma das seguintes palavras-chave: ESCAPE, REMOVEQUOTES e FIXEDWIDTH.
Os dados dos arquivos são carregados em uma tabela de destino, uma linha por linha da tabela. Os campos no arquivo de dados são correspondidos com as colunas da tabela em ordem, da esquerda para a direita. Os campos nos arquivos de dados podem ser de largura fixa ou delimitados por caracteres; o delimitador padrão é um pipe (\$1). Por padrão, todas as colunas da tabela são carregadas, mas você pode, opcionalmente, definir uma lista de colunas separadas por vírgula. Se a tabela não estiver incluída na lista de colunas especificada no comando COPY, ela será carregada com um valor padrão. Para obter mais informações, consulte [Carregamento de valores padrão de coluna](c_loading_default_values.md).
Siga este processo geral para carregar dados do Amazon S3 quando os dados são descompactados e delimitados:
1. Faça upload de seus arquivos para o Amazon S3.
1. Execute um comando COPY para carregar a tabela.
1. Verifique se os dados foram carregados corretamente.
Para obter exemplos de comandos COPY, consulte [Exemplos de COPY](r_COPY_command_examples.md). Para obter informações sobre dados carregados no Amazon Redshift, verifique as tabelas de sistema [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md) e [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md).
Para obter mais informações sobre nós e as fatias contidas em cada um deles, consulte “[Clusters e nós no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes)” no *Guia de gerenciamento de clusters do Amazon Redshift*.
# Carregar arquivos no Amazon S3 para usar com COPY
Há algumas abordagens a serem adotadas ao carregar arquivos de texto para o Amazon S3:
+ Se você tiver arquivos compactados, recomendamos dividir arquivos grandes para aproveitar a vantagem do processamento paralelo no Amazon Redshift.
+ No entanto, o COPY divide automaticamente dados de arquivos grandes, descompactados e delimitados por texto para facilitar o paralelismo e distribuir efetivamente dados de arquivos grandes.
Crie um bucket do Amazon S3 para armazenar seus arquivos de dados e, em seguida, carregue os arquivos de dados para o bucket. Para obter informações sobre a criação de buckets e carregamento de arquivos, consulte [Trabalhar com buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) no *Guia do usuário do Amazon Simple Storage Service*.
**Importante**
O bucket do Amazon S3 que contém os arquivos de dados deve ser criado na mesma região da AWS do seu cluster, a menos que você use a opção [REGION](copy-parameters-data-source-s3.md#copy-region) para especificar a região em que o bucket do Amazon S3 está localizado.
Certifique-se de que os intervalos de IP do S3 sejam adicionados à sua lista de permissões. Para saber mais sobre os intervalos de IP do S3 necessários, consulte [ Isolamento de rede](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
Você pode criar um bucket do Amazon S3 em uma região específica selecionando a região ao criar o bucket usando o console do Amazon S3 ou especificando um endpoint ao criar o bucket usando a API ou CLI do Amazon S3.
Após o carregamento de dados, verifique se os arquivos corretos estão presentes no Amazon S3.
**Topics**
+ [Gerenciamento da consistência de dados](managing-data-consistency.md)
+ [Carregamento de dados criptografados para Amazon S3](t_uploading-encrypted-data.md)
+ [Verificação da presença dos arquivos corretos no bucket](verifying-that-correct-files-are-present.md)
# Gerenciamento da consistência de dados
O Amazon S3 oferece uma forte consistência de leitura após gravação para operações COPY, UNLOAD, INSERT (tabela externa), CREATE EXTERNAL TABLE AS e Amazon Redshift Spectrum em buckets do Amazon S3 em todas as regiões da AWS. Além disso, as operações de leitura no Amazon S3 Select, lista de controle de acesso do Amazon S3, Amazon S3 Object Tags e metadados de objeto (por exemplo, objeto HEAD) são fortemente consistentes. Para obter mais informações sobre consistência de dados, consulte [Modelo de consistência de dados do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Introduction.html#ConsistencyModel) no *Guia do usuário do Amazon Simple Storage Service*.
# Carregamento de dados criptografados para Amazon S3
O Amazon S3 oferece suporte para criptografia do lado do servidor e criptografia do lado do cliente. Este tópico discute as diferenças entre a criptografia do lado do servidor e do lado do cliente e descreve as etapas para usar a criptografia do lado do cliente com o Amazon Redshift. A criptografia do lado do servidor é transparente para o Amazon Redshift.
## Criptografia do lado do servidor
A criptografia do lado do servidor é a criptografia de dados em repouso, ou seja, o Amazon S3 criptografa seus dados à medida que os carrega e os descriptografa para você quando você os acessa. Quando você carrega tabelas usando um comando COPY, não há diferença na maneira como você carrega de objetos criptografados ou não criptografados do lado do servidor no Amazon S3. Para obter mais informações sobre a criptografia do lado do servidor, consulte [Usar criptografia do lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) no *Guia do usuário do Amazon Simple Storage Service*.
## Criptografia do lado do cliente
Na criptografia no lado do cliente, seu aplicativo cliente gerencia a criptografia de seus dados, chaves de criptografia e ferramentas relacionadas. Você pode fazer upload de dados para um bucket do Amazon S3 usando criptografia do lado do cliente e, em seguida, carregar os dados usando o comando COPY com a opção ENCRYPTED e uma chave de criptografia privada para fornecer maior segurança.
Você criptografa seus dados usando criptografia de envelope. Com *criptografia de envelope*, seu aplicativo cuida de toda criptografia exclusivamente. Suas chaves de criptografia privadas e seus dados não criptografados nunca são enviados para a AWS, por isso é muito importante que você gerencie com segurança suas chaves de criptografia. Se você perder suas chaves de criptografia, não poderá descriptografar seus dados e não poderá recuperar suas chaves de criptografia da AWS. A criptografia de envelope alia a performance da criptografia simétrica rápida ao mesmo tempo com a maior segurança que o gerenciamento com chaves assimétricas oferece. Uma chave simétrica de uso único (a chave simétrica de envelope) é gerada por seu cliente de criptografia Amazon S3 para criptografar seus dados. Portanto, essa chave é criptografada por sua chave raiz e armazenada com seus dados no Amazon S3. Quando o Amazon Redshift acessa seus dados durante um carregamento, a chave simétrica criptografada é recuperada e descriptografada com sua chave real e, em seguida, os dados são descriptografados.
Para trabalhar com dados criptografados do lado do cliente do Amazon S3 no Amazon Redshift, siga as etapas descritas em [Proteger dados usando criptografia do lado do cliente](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html) no *Guia do usuário do Amazon Simple Storage Service*, com os demais requisitos que você usa:
+ **Criptografia simétrica ** A classe `AmazonS3EncryptionClient` do SDK for Java da AWS usa criptografia de envelope, descrita anteriormente, que é baseada na criptografia de chave simétrica. Use esta classe para criar um cliente Amazon S3 para carregar dados criptografados do lado do cliente.
+ **Uma chave mestra simétrica AES de 256 bits:** uma chave primária criptografa a chave de envelope. Você transmite a chave raiz à sua instância da classe `AmazonS3EncryptionClient`. Salve esta chave, pois você precisará dela para copiar dados no Amazon Redshift.
+ **Metadados de objeto para armazenar chave de envelope criptografada** – Por padrão, o Amazon S3 armazena a chave de envelope como metadados de objeto para a classe `AmazonS3EncryptionClient`. A chave de envelope criptografada que é armazenada como metadados de objeto é usada durante o processo de descriptografia.
**nota**
Se você receber uma mensagem de erro de criptografia quando usar a API de criptografia pela primeira vez, sua versão do JDK pode ter um arquivo de políticas de jurisdição JCE (Java Cryptography Extension) que limita o tamanho máximo da chave para transformações de criptografia e descriptografia para 128 bits. Para obter informações sobre como resolver esse problema, acesse [Especificar a criptografia do lado do cliente usando o AWS SDK para Java](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryptionUpload.html) no *Guia do usuário do Amazon Simple Storage Service*.
Para obter informações sobre como carregar arquivos criptografados do lado do cliente em suas tabelas do Amazon Redshift usando o comando COPY, consulte [Carregar arquivos de dados criptografados do Amazon S3](c_loading-encrypted-files.md).
## Exemplo: upload de dados criptografados no lado do cliente
Para obter um exemplo de como usar o AWS SDK para Java para carregar dados criptografados do lado do cliente, acesse [Proteger dados usando criptografia do lado do cliente](https://docs.aws.amazon.com/AmazonS3/latest/userguide/encrypt-client-side-symmetric-master-key.html) no *Guia do usuário do Amazon Simple Storage Service*.
A segunda opção mostra as escolhas que você deve fazer durante a criptografia do lado do cliente para que os dados possam ser carregados no Amazon Redshift. Especificamente, o exemplo mostra o uso de metadados de objeto para armazenar a chave de envelope criptografada e o uso de uma chave raiz simétrica AES de 256 bits.
Este exemplo fornece código de exemplo usando o AWS SDK para Java para criar uma chave raiz simétrica AES de 256 bits e salvá-la em um arquivo. Em seguida, o exemplo faz upload de um objeto no Amazon S3 usando um cliente de criptografia do S3 que inicialmente criptografa dados de amostra no lado do cliente. O exemplo também baixa objeto e verifica se os dados são os mesmos.
# Verificação da presença dos arquivos corretos no bucket
Depois de carregar seus arquivos para o bucket do Amazon S3, recomendamos listar o conteúdo do bucket para verificar se todos os arquivos corretos estão presentes e se nenhum arquivo indesejado está presente. Por exemplo, se o bucket `amzn-s3-demo-bucket` tiver um arquivo chamado `venue.txt.back`, esse arquivo será carregado, talvez involuntariamente, pelo seguinte comando:
```
COPY venue FROM 's3://amzn-s3-demo-bucket/venue' … ;
```
Se você quiser controlar especificamente quais arquivos são carregados, você pode usar um arquivo manifesto para listar explicitamente os arquivos de dados. Para obter mais informações sobre o uso de um arquivo manifesto, consulte a opção [copy_from_s3_manifest_file](copy-parameters-data-source-s3.md#copy-manifest-file) para o comando COPY e [Uso de um manifesto para especificar arquivos de dados](r_COPY_command_examples.md#copy-command-examples-manifest) nos exemplos de COPY.
Para obter mais informações sobre como listar o conteúdo do bucket, consulte [Listagem de chaves de objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ListingKeysUsingAPIs.html) no *Guia do desenvolvedor do Amazon S3*.
# Usando o comando COPY para carregar do Amazon S3
Use o comando [COPY](r_COPY.md) para carregar uma tabela em paralelo a partir de arquivos de dados no Amazon S3. Você pode especificar os arquivos a serem carregados usando um prefixo de objeto do Amazon S3 ou usando um arquivo manifesto.
A sintaxe para especificar os arquivos a serem carregados usando um prefixo é a seguinte:
```
COPY FROM 's3:///'
authorization;
```
O arquivo manifesto é um arquivo em formato JSON que lista os arquivos de dados a serem carregados. A sintaxe para especificar os arquivos a serem carregados usando um arquivo manifesto é a seguinte:
```
COPY FROM 's3:///'
authorization
MANIFEST;
```
A tabela a ser carregada já deve existir no banco de dados. Para obter informações sobre como criar uma tabela, consulte [CRIAR TABELA](r_CREATE_TABLE_NEW.md) na referência do SQL.
Os valores para *autorização* fornecem a autorização da AWS de que o Amazon Redshift precisa para acessar objetos do Amazon S3. Para obter informações sobre as permissões necessárias, consulte [Permissões do IAM para COPY, UNLOAD e CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions). O método preferido de autenticação é especificar o parâmetro IAM\$1ROLE e fornecer o nome de recurso da Amazon (ARN) para uma função do IAM com as permissões necessárias. Para obter mais informações, consulte [Controle de acesso com base em função](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based) .
Para autenticação usando o parâmetro IAM\$1ROLE, substitua ** e ** conforme exibido na sintaxe a seguir.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
O seguinte exemplo mostra a autenticação usando uma função do IAM.
```
COPY customer
FROM 's3://amzn-s3-demo-bucket/mydata'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Para obter mais informações sobre outras opções de autorização, consulte [Parâmetros de autorização](copy-parameters-authorization.md)
Se você quiser validar seus dados sem realmente carregar a tabela, use a opção NOLOAD com o comando [COPY](r_COPY.md).
O seguinte exemplo mostra as primeiras linhas de dados delimitados por pipe em um arquivo chamado `venue.txt`.
```
1|Toyota Park|Bridgeview|IL|0
2|Columbus Crew Stadium|Columbus|OH|0
3|RFK Stadium|Washington|DC|0
```
Antes de enviar o arquivo para o Amazon S3, divida o arquivo em vários arquivos para que o comando COPY possa carregá-lo usando o processamento paralelo. O número de arquivos deve ser um múltiplo do número de fatias em seu cluster. Divida seus arquivos de dados de carregamento para que os arquivos tenham o mesmo tamanho aproximado, entre 1 MB e 1 GB após a compactação. Para obter mais informações, consulte [Carregar dados de arquivos compactados e não compactados](t_splitting-data-files.md).
Por exemplo, o arquivo `venue.txt` pode ser dividido em quatro arquivos, da seguinte forma:
```
venue.txt.1
venue.txt.2
venue.txt.3
venue.txt.4
```
O seguinte comando COPY carrega a tabela VENUE usando os dados delimitados por pipe nos arquivos de dados com o prefixo “local” no bucket do Amazon S3 `amzn-s3-demo-bucket`.
**nota**
O bucket `amzn-s3-demo-bucket` do Amazon S3 nos exemplos a seguir não existe. Para uma amostra dos comandos COPY que usam dados reais em um bucket existente do Amazon S3, consulte [Carregar dados de amostra](https://docs.aws.amazon.com/redshift/latest/gsg/cm-dev-t-load-sample-data.html).
```
COPY venue FROM 's3://amzn-s3-demo-bucket/venue'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|';
```
Se nenhum objeto Amazon S3 com o prefixo “local” existir, o carregamento falhará.
**Topics**
+ [Uso de um manifesto para especificar arquivos de dados](loading-data-files-using-manifest.md)
+ [Carregar arquivos de dados compactados do Amazon S3](t_loading-gzip-compressed-data-files-from-S3.md)
+ [Carregar dados de largura fixa do Amazon S3](t_loading_fixed_width_data.md)
+ [Carregar dados multibyte do Amazon S3](t_loading_unicode_data.md)
+ [Carregar arquivos de dados criptografados do Amazon S3](c_loading-encrypted-files.md)
# Uso de um manifesto para especificar arquivos de dados
Você pode usar um manifesto para garantir que o comando COPY carregue todos os arquivos necessários, e somente os arquivos necessários, para um carregamento de dados. Você pode usar um manifesto para carregar vários arquivos de buckets diferentes ou arquivos que não compartilham o mesmo prefixo. Em vez de fornecer um caminho de objeto para o comando COPY, você fornece o nome de um arquivo de texto em formato JSON que lista explicitamente os arquivos a serem carregados. O URL no manifesto deve especificar o nome de bucket e o caminho de objeto completo para o arquivo, e não apenas um prefixo.
Para obter mais informações sobre arquivos manifesto, consulte o exemplo de COPY [Usar um manifesto para especificar arquivos de dados](r_COPY_command_examples.md#copy-command-examples-manifest).
O seguinte exemplo mostra o JSON para carregar arquivos de diferentes buckets e com nomes de arquivos que começam com carimbos de data.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/2013-10-04-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/2013-10-05-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/2013-10-04-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/2013-10-05-custdata", "mandatory":true}
]
}
```
O sinalizador opcional `mandatory` especifica se COPY deve retornar um erro se o arquivo não for localizado. O padrão de `mandatory` é `false`. Independentemente de qualquer configuração obrigatória, COPY será encerrado se nenhum arquivo for encontrado.
O exemplo a seguir executa o comando COPY com o manifesto do exemplo anterior, chamado `cust.manifest`.
```
COPY customer
FROM 's3://amzn-s3-demo-bucket/cust.manifest'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MANIFEST;
```
## Uso de um manifesto criado por UNLOAD
Um manifesto criado por uma operação [UNLOAD](r_UNLOAD.md) usando o parâmetro MANIFEST pode ter chaves que não são necessárias para a operação COPY. Por exemplo, o manifesto `UNLOAD` a seguir inclui uma chave `meta` que é necessária para uma tabela externa do Amazon Redshift Spectrum e para o carregamento de arquivos de dados em um formato de arquivo `ORC` ou `Parquet`. A chave `meta` contém uma chave `content_length` com um valor que é o tamanho real do arquivo em bytes. A operação COPY requer somente a chave `url` uma chave `mandatory` opcional.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/unload/manifest_0000_part_00", "meta": { "content_length": 5956875 }},
{"url":"s3://amzn-s3-demo-bucket/unload/unload/manifest_0001_part_00", "meta": { "content_length": 5997091 }}
]
}
```
Para obter mais informações sobre arquivos manifesto, consulte [Uso de um manifesto para especificar arquivos de dados](r_COPY_command_examples.md#copy-command-examples-manifest).
# Carregar arquivos de dados compactados do Amazon S3
Para carregar arquivos de dados compactados usando gzip, lzop, ou bzip2, inclua a opção correspondente: GZIP, LZOP ou BZIP2.
Por exemplo, o seguinte comando carrega a partir de arquivos que foram compactados usando lzop.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/customer.lzo'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|' LZOP;
```
**nota**
Quando você compacta um arquivo de dados com compactação lzop e usa a opção *--filter*, não é possível usar o comando COPY.
# Carregar dados de largura fixa do Amazon S3
Arquivos de dados de largura fixa têm comprimentos uniformes para cada coluna de dados. Cada campo em um arquivo de dados de largura fixa tem exatamente o mesmo comprimento e posição. Para dados de caracteres (CHAR e VARCHAR) em um arquivo de dados de largura fixa, você deve incluir espaços em branco iniciais ou finais como espaços reservados para manter a largura uniforme. Para números inteiros, você deve usar zeros iniciais como espaços reservados. Um arquivo de dados de largura fixa não tem qualquer delimitador para separar colunas.
Para carregar um arquivo de dados de largura fixa em uma tabela existente, USE o parâmetro FIXEDWIDTH no comando COPY. As especificações de sua tabela devem corresponder ao valor de fixedwidth\$1spec para que os dados sejam carregados corretamente.
Para carregar dados de largura fixa de um arquivo para uma tabela, emita o seguinte comando:
```
COPY table_name FROM 's3://amzn-s3-demo-bucket/prefix'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
FIXEDWIDTH 'fixedwidth_spec';
```
O parâmetro *fixedwidth\$1spec* é uma string que contém um identificador para cada coluna e a largura de cada coluna, separados por um sinal de dois pontos. Os pares de **column:width** são delimitados por vírgulas. O identificador pode ser o que você escolher: números, letras ou uma combinação dos dois. O identificador não tem qualquer relação com a própria tabela, portanto a especificação deve conter as colunas na mesma ordem que a tabela.
Os dois exemplos a seguir mostram a mesma especificação, a primeira usando identificadores numéricos e a segunda usando identificadores de string:
```
'0:3,1:25,2:12,3:2,4:6'
```
```
'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6'
```
O seguinte exemplo exibe dados de amostra de largura fixa que poderiam ser carregados na tabela VENUE usando as especificações precedentes:
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica Ballpark Kansas City KS0
5 Gillette Stadium Foxborough MA68756
```
O seguinte comando COPY carrega este conjunto de dados na tabela VENUE:
```
COPY venue
FROM 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
FIXEDWIDTH 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
# Carregar dados multibyte do Amazon S3
Se seus dados incluem caracteres multibyte não ASCII (tal como caracteres chineses ou cirílicos), você deve carregar os dados em colunas VARCHAR. O tipo de dados VARCHAR é compatível com caracteres UTF-8 de quatro bytes, mas o tipo de dados CHAR aceita apenas caracteres ASCII de único byte. Você não pode carregar caracteres de cinco bytes ou mais nas tabelas do Amazon Redshift. Para obter mais informações sobre CHAR e VARCHAR, consulte [Tipos de dados](c_Supported_data_types.md).
Para verificar qual codificação um arquivo de entrada usa, use o comando * `file` * do Linux:
```
$ file ordersdata.txt
ordersdata.txt: ASCII English text
$ file uni_ordersdata.dat
uni_ordersdata.dat: UTF-8 Unicode text
```
# Carregar arquivos de dados criptografados do Amazon S3
Você pode usar o comando COPY para carregar arquivos de dados que foram carregados no Amazon S3 usando criptografia do lado do servidor, criptografia do lado do cliente ou ambos.
O comando COPY é compatível com os seguintes tipos de criptografia do Amazon S3:
+ Criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3)
+ Criptografia do lado do servidor com o AWS KMS keys (SSE-KMS)
+ Criptografia do lado do cliente usando uma chave raiz simétrica do lado do cliente
O comando COPY não é compatível com os seguintes tipos de criptografia do Amazon S3:
+ Criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C)
+ Criptografia do lado do cliente usando uma AWS KMS key
+ Criptografia do lado do cliente usando uma chave raiz assimétrica fornecida pelo cliente
Para obter mais informações sobre a criptografia do Amazon S3, consulte [ Proteger dados usando criptografia do lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) e [Proteger dados usando criptografia do lado do cliente](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html) no Guia do usuário do Amazon Simple Storage Service.
O comando [UNLOAD](r_UNLOAD.md) criptografa arquivos automaticamente usando SSE-S3. Você também pode descarregar usando SSE-KMS ou criptografia do lado do cliente com uma chave simétrica gerenciada pelo cliente. Para obter mais informações, consulte . [Descarregamento de arquivos de dados criptografados](t_unloading_encrypted_files.md)
O comando COPY automaticamente reconhece e carrega arquivos de dados criptografados usando SSE-S3 e SSE-KMS. Você pode carregar arquivos criptografados usando uma chave raiz simétrica do lado do cliente, especificando a opção ENCRYPTED e fornecendo a chave-valor. Para obter mais informações, consulte [Carregamento de dados criptografados para Amazon S3](t_uploading-encrypted-data.md).
Para carregar arquivos de dados criptografados do lado do cliente, forneça a chave-valor raiz usando o parâmetro MASTER\$1SYMMETRIC\$1KEY e inclua a opção ENCRYPTED.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/encrypted/customer'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MASTER_SYMMETRIC_KEY ''
ENCRYPTED
DELIMITER '|';
```
Para carregar arquivos de dados criptografados que estão compactados por gzip, lzop ou bzip2, inclua a opção GZIP, LZOP ou BZIP2 com a chave-valor raiz e a opção ENCRYPTED.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/encrypted/customer'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MASTER_SYMMETRIC_KEY ''
ENCRYPTED
DELIMITER '|'
GZIP;
```