Nozioni di base su Amazon Redshift Spectrum - Amazon Redshift
PrerequisitiCloudFormationNozioni di base su Redshift Spectrum gradualeFase 1: Creazione di un ruolo IAMFase 2: associazione del ruolo IAM al clusterFase 3: creazione di uno schema esterno e di una tabella esternaFase 4: Esecuzione di query sui dati in Amazon S3Avvia lo stack CloudFormation e quindi esegui una query sui dati

Amazon Redshift non supporterà più la creazione di nuove UDF Python a partire dal 1º novembre 2025. Se desideri utilizzare le UDF Python, creale prima di tale data. Le UDF Python esistenti continueranno a funzionare normalmente. Per ulteriori informazioni, consulta il post del blog.

Nozioni di base su Amazon Redshift Spectrum

In questo tutorial viene descritto come utilizzare Amazon Redshift Spectrum per eseguire le query sui dati direttamente dai file in Amazon S3. Se disponi già di un cluster e di un client SQL, puoi completare questo tutorial con un intervento minimo di impostazione.

Nota

Le query di Redshift Spectrum comportano dei costi supplementari. Quello relativo all'esecuzione delle query di esempio in questo tutorial è nominale. Per ulteriori informazioni sui prezzi, consulta Prezzi di Amazon Redshift Spectrum.

Prerequisiti

Per utilizzare Redshift Spectrum, è necessario disporre di un cluster Amazon Redshift e un client SQL connesso al cluster di modo che sia possibile eseguire i comandi SQL. Il cluster e i file di dati in Amazon S3 devono trovarsi nella stessa Regione AWS.

Per informazioni sulla creazione di un cluster Amazon Redshift, consulta la pagina Nozioni di base sui data warehouse con provisioning Amazon Redshift nella Guida alle operazioni di base di Amazon Redshift. Per informazioni sulle modalità di connessione a un cluster, consulta Connessione ai data warehouse Amazon Redshift nella Guida alle operazioni di base di Amazon Redshift.

In alcuni degli esempi che seguono, i dati di esempio si trovano nella regione Stati Uniti orientali (Virginia settentrionale) (us-east-1), quindi è necessario un cluster che si trova in us-east-1. In alternativa, puoi utilizzare Amazon S3 per copiare oggetti dati dai seguenti bucket e cartelle nel bucket nella Regione AWS in cui si trova il cluster:

  • s3://redshift-downloads/tickit/spectrum/customers/*

  • s3://redshift-downloads/tickit/spectrum/sales_partition/*

  • s3://redshift-downloads/tickit/spectrum/sales/*

  • s3://redshift-downloads/tickit/spectrum/salesevent/*

Esegui un comando Amazon S3 simile al seguente per copiare i dati di esempio che si trovano negli Stati Uniti orientali (Virginia settentrionale) nel tua Regione AWS. Prima di eseguire il comando, crea il bucket e le cartelle nel bucket in modo che corrispondano al comando di copia di Amazon S3. L'output del comando di copia di Amazon S3 conferma che i file vengono copiati nel nome_bucket nella Regione AWS desiderata.

aws s3 cp s3://redshift-downloads/tickit/spectrum/ s3://bucket-name/tickit/spectrum/ --copy-props none --recursive

Nozioni di base su Redshift Spectrum utilizzando AWS CloudFormation

In alternativa ai seguenti passaggi, è possibile accedere al modello Redshift Spectrum DataLake AWS CloudFormation per creare una pila con un bucket Amazon S3 che è possibile eseguire query. Per ulteriori informazioni, consulta Avvia lo stack AWS CloudFormation e quindi esegui query sui dati in Amazon S3.

Nozioni di base su Redshift Spectrum graduale

Per iniziare a utilizzare Amazon Redshift Spectrum, completare la seguente procedura:

Fase 1: Creazione di un ruolo IAM per Amazon Redshift

Il cluster deve disporre dell'autorizzazione per accedere al catalogo dati esterno in AWS Glue o Amazon Athena e ai file di dati in Amazon S3. Per concedere questa autorizzazione, fare riferimento a un ruolo AWS Identity and Access Management (IAM) associato al cluster. Per ulteriori informazioni sull'utilizzo di ruoli con Amazon Redshift, consultare Autorizzazione delle operazioni COPY e UNLOAD tramite ruoli IAM.

Nota

In alcuni casi è possibile migrare il catalogo dati di Athena a un catalogo dati AWS Glue. Questo è possibile se il cluster si trova in una regione AWS in cui è supportato AWS Glue e sono disponibili delle tabelle esterne Redshift Spectrum nel catalogo dati di Athena. Per utilizzare il catalogo dati AWS Glue con Redshift Spectrum, è possibile che sia necessario modificare le policy IAM. Per ulteriori informazioni, consultare Aggiornamento del catalogo dati AWS Glue nella Guida per l'utente di Athena.

Quando viene creato un ruolo per Amazon Redshift, scegliere uno dei seguenti approcci:

Come creare un ruolo IAM per Amazon Redshift

  1. Aprire la console IAM.

  2. Nel pannello di navigazione, selezionare Ruoli.

  3. Selezionare Create role (Crea ruolo).

  4. Scegliere Servizio AWS come entità attendibile, quindi scegliere Redshift come caso d'uso.

  5. In Caso d’uso per altri Servizi AWS scegli Redshift - Personalizzabile e quindi Avanti.

  6. Verrà visualizzata la pagina Allega la policy di autorizzazione. Scegliere AmazonS3ReadOnlyAccess e AWSGlueConsoleFullAccess, se si usa il Catalogo dati AWS Glue. Oppure scegliere AmazonAthenaFullAccess se si utilizza il catalogo dati di Athena. Scegli Next (Successivo).

    Nota

    La policy AmazonS3ReadOnlyAccess concede al cluster l'accesso in sola lettura a tutti i bucket Amazon S3. Per concedere l'accesso unicamente al bucket di dati di esempio AWS, creare una nuova policy e aggiungere le autorizzazioni seguenti.

    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": "arn:aws:s3:::redshift-downloads/*"
        }
    ]
}

  7. Per Role name (Nome ruolo), digitare un nome per il ruolo, ad esempio myspectrum_role.

  8. Esaminare le informazioni, quindi scegliere Create role (Crea ruolo).

  9. Nel riquadro di navigazione, seleziona Ruoli. Scegliere il nome del nuovo ruolo per visualizzare il riepilogo, quindi copiare il ruolo ARN visualizzato nel campo Role ARN (ARN ruolo). Questo valore è l'Amazon Resource Name (ARN) per il ruolo appena creato. Viene utilizzato quando si creano tabelle esterne per fare riferimento ai file di dati in Amazon S3.

Come creare un ruolo IAM per Amazon Redshift utilizzando un AWS Glue Data Catalog abilitato per AWS Lake Formation

  1. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione, selezionare Policy.

    Se è la prima volta che selezioni Policy, verrà visualizzata la pagina Benvenuto nelle policy gestite. Seleziona Inizia.

  3. Scegli Crea policy.

  4. Scegliere di creare la policy nella scheda JSON.

  5. Incollare nel documento di policy JSON seguente, che concede l'accesso al catalogo di dati ma nega le autorizzazioni di amministratore per Lake Formation.

    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "RedshiftPolicyForLF",
            "Effect": "Allow",
            "Action": [
                "glue:*",
                "lakeformation:GetDataAccess"
            ],
            "Resource": "*"
        }
    ]
}

  6. Una volta terminato, selezionare Review (Rivedi) per rivedere la policy. In Validatore di policy vengono segnalati eventuali errori di sintassi.

  7. Nella pagina Review policy (Rivedi policy), in Name (Nome) inserire myspectrum_policy per denominare la policy in fase di creazione. (Opzionale) Immettere una Description (descrizione). Consulta il Summary (Riepilogo) della policy per visualizzare le autorizzazioni concesse dalla policy. Seleziona Create policy (Crea policy) per salvare il proprio lavoro.

    Dopo aver creato la policy, è possibile fornire l'accesso agli utenti.

Per fornire l'accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:

  • Utenti e gruppi in AWS IAM Identity Center:

    Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina Create a permission set (Creazione di un set di autorizzazioni) nella Guida per l'utente di AWS IAM Identity Center.

  • Utenti gestiti in IAM tramite un provider di identità:

    Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina Create a role for a third-party identity provider (federation) della Guida per l'utente IAM.

  • Utenti IAM:

Come concedere le autorizzazioni SELECT nella tabella per eseguire le query del database Lake Formation

  1. Aprire la console Lake Formation all'indirizzo https://console.aws.amazon.com/lakeformation/.

  2. Nel menu di navigazione scegli Autorizzazioni data lake, quindi seleziona Concedi.

  3. Segui le istruzioni presenti in Granting table permissions using the named resource method nella Guida per gli sviluppatori di AWS Lake Formation. Inserisci le informazioni che seguono:

    • In Ruolo IAM, selezionare il ruolo IAM creato, myspectrum_role. Quando si esegue l'editori di query di Amazon Redshift, utilizzare il ruolo IAM per le autorizzazioni ai dati.

      Nota

      Per concedere l'autorizzazione SELECT nella tabella in un catalogo di dati abilitato per Lake Formation eseguire la query, procedere come segue:

      • Registrare il percorso dei dati in Lake Formation.

      • Concedere agli utenti le autorizzazioni per quel percorso in Lake Formation.

      • Le tabelle create sono disponibili nel percorso registrato in Lake Formation.

  4. Scegli Concessione.

Importante

Come best practice, concedere l'accesso solo agli oggetti Amazon S3 sottostanti attraverso le autorizzazioni Lake Formation. Per evitare un accesso non approvato, rimuovere qualsiasi autorizzazione concessa agli oggetti Amazon S3 al di fuori di Lake Formation. Se l'accesso agli oggetti Amazon S3 è stato effettuato prima della configurazione di Lake Formation, rimuovere qualsiasi autorizzazione di policy IAM o bucket configurata in precedenza. Per ulteriori informazioni consultare Aggiornamento delle autorizzazioni di AWS Glue al modello AWS Lake Formation e Autorizzazioni Lake Formation.

Fase 2: associazione del ruolo IAM al cluster

Ora si dispone di un ruolo IAM che autorizza Amazon Redshift ad accedere al catalogo dati esterno e ad Amazon S3 per tuo conto. A questo punto è necessario associare tale ruolo al proprio cluster Amazon Redshift.

Associare un ruolo IAM a un cluster

  1. Accedere alla Console di gestione AWS e aprire la console Amazon Redshift all'indirizzo https://console.aws.amazon.com/redshiftv2/.

  2. Dal menu di navigazione scegliere Clusters (Cluster), quindi scegliere il cluster da aggiornare.

  3. In Actions (Operazioni), scegliere Manage IAM roles (Gestisci ruoli IAM). Viene visualizzata la pagina IAM roles (Ruoli IAM).

  4. Scegliere Inserisci ARN e quindi inserire un ARN o un ruolo IAM, oppure scegliere un ruolo IAM dall'elenco. Quindi scegliere Add IAM role (Aggiungi ruolo IAM) per aggiungerlo all'elenco degli Attached IAM roles (Ruoli IAM collegati).

  5. Scegliere Done (Fatto) per associare il ruolo IAM al cluster. Il cluster viene modificare per completare la variazione.

Fase 3: creazione di uno schema esterno e di una tabella esterna

Creazione di tabelle esterne in uno schema esterno. Lo schema esterno fa riferimento a un database nel catalogo dati esterno e fornisce l'ARN del ruolo IAM che autorizza il tuo cluster ad accedere ad Amazon S3 per tuo conto. È possibile creare un database esterno in un catalogo dati Amazon Athena, AWS Glue Data Catalog o un metastore Apache Hive, come Amazon EMR. Per questo esempio, viene creato un database esterno in un catalogo dati Amazon Athena quando viene creato lo schema esterno di Amazon Redshift. Per ulteriori informazioni, consultare Schemi esterni in Amazon Redshift Spectrum.

Per creare uno schema esterno e una tabella esterna

  1. Per creare uno schema esterno, sostituire l'ARN del ruolo IAM nel comando seguente con l'ARN del ruolo creato nella fase 1. Quindi eseguire il comando nel proprio client SQL.

    create external schema myspectrum_schema 
from data catalog 
database 'myspectrum_db' 
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
create external database if not exists;

  2. Per creare una tabella esterna, eseguire il comando CREATE EXTERNAL TABLE seguente.

    Nota

    Il cluster e il bucket Amazon S3 devono trovarsi nella stessa Regione AWS. Per questo comando CREATE EXTERNAL TABLE di esempio, il bucket Amazon S3 con i dati di esempio si trova nella Regione AWS Stati Uniti orientali (Virginia settentrionale). Per visualizzare i dati di origine, scarica il file sales_ts.000.

    È possibile modificare questo esempio per eseguirlo in una Regione AWS diversa. Crea un bucket Amazon S3 nella Regione AWS desiderata. Copia i dati di vendita con un comando di copia di Amazon S3. Aggiorna quindi l'opzione relativa alla posizione del bucket nel comando di esempio CREATE EXTERNAL TABLE impostando il bucket in uso.

    aws s3 cp s3://redshift-downloads/tickit/spectrum/sales/ s3://bucket-name/tickit/spectrum/sales/ --copy-props none --recursive

    L'output del comando di copia di Amazon S3 conferma che il file è stato copiato nel bucket-name nella Regione AWS desiderata.

    copy: s3://redshift-downloads/tickit/spectrum/sales/sales_ts.000 to s3://bucket-name/tickit/spectrum/sales/sales_ts.000
    create external table myspectrum_schema.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
row format delimited
fields terminated by '\t'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales/'
table properties ('numRows'='172000');

Fase 4: Esecuzione di query sui dati in Amazon S3

Dopo aver creato le tabelle esterne, è possibile eseguire query utilizzando le stesse istruzioni SELECT utilizzate per eseguire query su altre tabelle Amazon Redshift. Queste query con istruzioni SELECT includono il join di tabelle, l'aggregazione di dati e il filtraggio di predicati.

Come eseguire query sui dati in Amazon S3

  1. Ottenere Il numero di righe nella tabella MYSPECTRUM_SCHEMA.SALES. 

    select count(*) from myspectrum_schema.sales;
    count 
------
172462

  2. Come best practice, lasciare le tabelle dei fatti più grandi in Amazon S3 e le tabelle con dimensioni più piccole in Amazon Redshift. Se hai caricato i dati di esempio in Carica dati, nel database è disponibile una tabella denominata EVENT. Altrimenti, creare la tabella EVENT utilizzando il comando seguente.

    create table event(
eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp);

  3. Caricare la tabella EVENT sostituendo l'ARN del ruolo IAM nel seguente comando COPY con l'ARN del ruolo creato in Fase 1: Creazione di un ruolo IAM per Amazon Redshift. Facoltativamente è possibile scaricare e visualizzare i dati di origine perallevents_pipe.txt da un bucket Amazon S3 nella Regione AWS us-east-1.

    copy event from 's3://redshift-downloads/tickit/allevents_pipe.txt' 
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
delimiter '|' timeformat 'YYYY-MM-DD HH:MI:SS' region 'us-east-1';

    L'esempio seguente unisce mediante join la tabella esterna Amazon S3 MYSPECTRUM_SCHEMA.SALES alla tabella Amazon Redshift locale EVENT per calcolare le vendite totali per i 10 eventi principali.

    select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
    eventid | sum     
--------+---------
    289 | 51846.00
   7895 | 51049.00
   1602 | 50301.00
    851 | 49956.00
   7315 | 49823.00
   6471 | 47997.00
   2118 | 47863.00
    984 | 46780.00
   7851 | 46661.00
   5638 | 46280.00

  4. Visualizza il piano delle query per la query precedente. Tenere presente le fasi S3 Seq Scan, S3 HashAggregate e S3 Query Scan eseguite sui dati in Amazon S3.

    explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) 
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
    
QUERY PLAN                                                                                                                                                                                
-----------------------------------------------------------------------------
XN Limit  (cost=1001055770628.63..1001055770628.65 rows=10 width=31)                                                                                                                      
  ->  XN Merge  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                               
        Merge Key: sum(sales.derived_col2)                                                                                                                                                
        ->  XN Network  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                       
              Send to leader                                                                                                                                                              
              ->  XN Sort  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                    
                    Sort Key: sum(sales.derived_col2)                                                                                                                                     
                    ->  XN HashAggregate  (cost=1055770620.49..1055770620.99 rows=200 width=31)                                                                                           
                          ->  XN Hash Join DS_BCAST_INNER  (cost=3119.97..1055769620.49 rows=200000 width=31)                                                                             
                                Hash Cond: ("outer".derived_col1 = "inner".eventid)                                                                                                       
                                ->  XN S3 Query Scan sales  (cost=3010.00..5010.50 rows=200000 width=31)                                                                                  
                                      ->  S3 HashAggregate  (cost=3010.00..3010.50 rows=200000 width=16)                                                                                  
                                            ->  S3 Seq Scan myspectrum_schema.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT  (cost=0.00..2150.00 rows=172000 width=16)
                                                  Filter: (pricepaid > 30.00)                                                                                                             
                                ->  XN Hash  (cost=87.98..87.98 rows=8798 width=4)                                                                                                        
                                      ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=4)

Avvia lo stack AWS CloudFormation e quindi esegui query sui dati in Amazon S3

Dopo aver creato un cluster Amazon Redshift e connesso al cluster, puoi installare il modello Redshift Spectrum DataLake AWS CloudFormation e quindi eseguire query sui dati.

CloudFormation installa il modello DataLake Redshift Spectrum Getting Started e crea uno stack che include quanto segue:

  • Un ruolo denominato myspectrum_role associato al cluster Redshift

  • Uno schema esterno denominato myspectrum_schema

  • Una tabella esterna denominata sales in un bucket Amazon S3

  • Una tabella Redshift denominata event caricata con dati

Per lanciare lo stack DataLake CloudFormation Getting Started di Redshift Spectrum

  1. Scegliere Avvio dello stack CFN. La console CloudFormation si apre con il modello DataLake.yml selezionato.

    Puoi anche scaricare e personalizzare il modello CFN Getting Started DataLake CloudFormation di Redshift Spectrum, quindi aprire la console CloudFormation (https://console.aws.amazon.com/cloudformation) e creare uno stack con il modello personalizzato.

  2. Scegli Next (Successivo).

  3. In Parametri, inserisci il nome del cluster Amazon Redshift, il nome del database e il nome utente del database.

  4. Scegli Next (Successivo).

    Vengono visualizzate le opzioni della pila.

  5. Scegliere Successivo per accettare le impostazioni predefinite.

  6. Rivedere le informazioni e in Capabilities (Funzionalità), scegliere Riconosco che AWS CloudFormation può creare risorse IAM.

  7. Seleziona Crea stack.

Se si verifica un errore durante la creazione della pila, vedere le seguenti informazioni:

  • Visualizza la tabella Eventi di CloudFormation per informazioni che possono aiutarti a risolvere l'errore.

  • Elimina lo stack DataLake CloudFormation prima di riprovare l'operazione.

  • Assicurarsi di essere connesso al database Amazon Redshift.

  • Assicurati di aver inserito le informazioni corrette per il nome del cluster Amazon Redshift, il nome del database e il nome utente del database.

Eseguire query sui dati in Amazon S3

Richiedere tabelle esterne utilizzando le stesse istruzioni SELECT utilizzate per eseguire query su altre tabelle Amazon Redshift. Queste query con istruzioni SELECT includono il join di tabelle, l'aggregazione di dati e il filtraggio di predicati.

La seguente query restituisce il numero di righe nella tabella esternamyspectrum_schema.sales. 

select count(*) from myspectrum_schema.sales;
count 
------
172462

Effettuare il join di una tabella esterna con una tabella locale

L'esempio seguente unisce la tabella esterna myspectrum_schema.sales alla tabella locale event per calcolare le vendite totali per i 10 eventi principali.

select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
eventid | sum     
--------+---------
    289 | 51846.00
   7895 | 51049.00
   1602 | 50301.00
    851 | 49956.00
   7315 | 49823.00
   6471 | 47997.00
   2118 | 47863.00
    984 | 46780.00
   7851 | 46661.00
   5638 | 46280.00

Visualizzare il piano di query

Visualizza il piano delle query per la query precedente. Tenere presente le fasi S3 Seq Scan, S3 HashAggregate e S3 Query Scan eseguite nei dati in Amazon S3.

explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) 
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;

QUERY PLAN                                                                                                                                                                                
-----------------------------------------------------------------------------
XN Limit  (cost=1001055770628.63..1001055770628.65 rows=10 width=31)                                                                                                                      
  ->  XN Merge  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                               
        Merge Key: sum(sales.derived_col2)                                                                                                                                                
        ->  XN Network  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                       
              Send to leader                                                                                                                                                              
              ->  XN Sort  (cost=1001055770628.63..1001055770629.13 rows=200 width=31)                                                                                                    
                    Sort Key: sum(sales.derived_col2)                                                                                                                                     
                    ->  XN HashAggregate  (cost=1055770620.49..1055770620.99 rows=200 width=31)                                                                                           
                          ->  XN Hash Join DS_BCAST_INNER  (cost=3119.97..1055769620.49 rows=200000 width=31)                                                                             
                                Hash Cond: ("outer".derived_col1 = "inner".eventid)                                                                                                       
                                ->  XN S3 Query Scan sales  (cost=3010.00..5010.50 rows=200000 width=31)                                                                                  
                                      ->  S3 HashAggregate  (cost=3010.00..3010.50 rows=200000 width=16)                                                                                  
                                            ->  S3 Seq Scan spectrum.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT  (cost=0.00..2150.00 rows=172000 width=16)
                                                  Filter: (pricepaid > 30.00)                                                                                                             
                                ->  XN Hash  (cost=87.98..87.98 rows=8798 width=4)                                                                                                        
                                      ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=4)