Configurer AWS Redshift pour l’entreposage de données dans le cloud.

Dans ce tutoriel, je vais expliquer et guider comment configurer AWS Redshift pour utiliser l’entreposage de données en nuage. Redshift est un service d’entrepôt de données pétaoctets entièrement géré, introduit dans le cloud par Amazon Web Services. Il fonctionne en combinant une ou plusieurs collections de ressources informatiques appelées nœuds, organisées en un groupe, un cluster. Chaque cluster exécute un moteur Redshift et peut contenir une ou plusieurs bases de données. En gros, l’architecture peut être élaborée comme suit :

AWS Redshift

1. Comment cela fonctionne

En gros, Redshift est basé sur PostgreSQL comme moteur principal, donc la plupart des applications SQL peuvent fonctionner avec Redshift. Redshift peut aussi être intégré à un large éventail d’applications, notamment des outils de BI, d’analyse et ETL (Extract, Transform, Load) qui permettent aux analystes ou aux ingénieurs de travailler avec les données qu’il contient.

Lorsqu’un utilisateur configure un entrepôt de données Amazon Redshift, il dispose d’une topologie de base pour les opérations appelée cluster. Un cluster Redshift est composé d’un ou plusieurs nœuds de calcul. Si l’utilisateur choisit d’utiliser plus d’un nœud de calcul, Redshift démarre automatiquement un nœud maître. Ce nœud leader est configuré pour recevoir les demandes et les commandes du côté de l’exécution du client et n’est pas facturé par AWS.

Les applications clientes communiquent uniquement avec le nœud leader. Les nœuds de calcul sous le nœud leader sont transparents pour l’utilisateur. Lorsque les clients exécutent une requête, le nœud leader analyse la requête et crée un plan d’exécution optimal à exécuter sur les nœuds de calcul, en tenant compte de la quantité de données stockées sur chaque nœud.

Dans ce tutoriel, je vais te montrer comment installer et configurer Redhift pour notre propre utilisation. Dans cet exemple, je vais créer un compte et commencer avec le pack de niveau gratuit.

2. Phase de configuration

2.1 Conditions préalables

Avant de commencer à configurer un cluster Amazon Redshift, il faut remplir certaines conditions préalables.

Commence par t’inscrire sur AWS puis, une fois que c’est fait, va dans le service IAM pour créer un rôle que nous pourrions utiliser pour Redshift. Tu peux suivre la capture d’écran ci-dessous :

AWS Management Console

Créer un rôle

Redshift

Accès à Amazon S3

Ajoute les tags

Réviser les paramètres des rôles

Une fois que c’est fait, tu devrais obtenir une capture d’écran comme ci-dessous indiquant que le rôle a été créé avec succès.

Création d'un utilisateur Redshift

2.2 Mise en place de la configuration de Redshift

Les conditions préalables étant remplies, nous pouvons passer à la création de notre propre Cluster Redshift. Cherche les fonctions Redshift dans le volet de recherche et procède à partir de là. Tu trouveras ci-dessous des exemples de captures d’écran :

Trouver des services

Clique sur le bouton Créer un Cluster et procède avec les variables nécessaires, note que du côté des autorisations du Cluster, nous incluons notre rôle IAM que nous avons créé précédemment.

Créer un Cluster

Configuration des clusters

Paramètres et nom de la base de données

Cluster redshift créé avec succès

Permissions et aperçu du cluster

Une fois que c’est fait, tu devrais te retrouver dans le tableau de bord redshift comme ci-dessus. Pour ce tutoriel, nous allons désactiver la couche de sécurité du réseau en modifiant le groupe de sécurité. Pour ce faire, va en bas du tableau de bord et ajoute le port Redshift dans l’onglet Inbound. Tu trouveras ci-dessous un exemple :

Désactiver la sécurité du réseau

Une fois que tout est fait, tu devrais voir que le nouveau cluster que tu as créé est maintenant disponible pour être utilisé.

Le cluster est prêt à être utilisé

3. Phase de test

Maintenant, essayons d’accéder à notre entrepôt de données. Pour le tester, clique sur EDITOR dans le volet de gauche, inclus les variables nécessaires et clique sur Connect to database.

Teste la configuration de Redshift

Tu devrais être amené sur une page d’éditeur, commençons maintenant par créer notre propre schéma de test. Crée un schéma comme indiqué ci-dessous puis exécute-le.

Créer un schéma de base de données Redshift

Super, maintenant testons du côté local du client. Pour ce faire, tu dois obtenir une connexion JDBC ou ODBC du côté de Redshift. Pour obtenir cette information, clique sur le bouton Config dans le volet gauche du tableau de bord.

Choisis ton type de connexion préféré puis télécharge les bibliothèques nécessaires et copie l’URL comme indiqué dans l’exemple ci-dessous :

Choisis le type de connexion

Ensuite, ouvre l’un de tes outils client SQL et saisis les variables de connexion nécessaires. Dans notre exemple, nous utilisons l’outil client SQL DBeaver que tu peux obtenir ici.

Client DBeaver Redshift

Ta connexion devrait réussir comme prévu. Si tu rencontres un problème d’authentification, vérifie ta configuration sous le groupe de sécurité AWS pour plus de détails.

Ensuite, créons un ensemble de tables sous notre schéma précédent nouvellement créé. Tu trouveras ci-dessous un exemple de création de table que nous allons exécuter dans notre cluster :

 SET search_path = imdb; 

create table users(
userid integer not null distkey sortkey,
username char(8),
firstname varchar(30),
lastname varchar(30),
city varchar(30),
state char(2),
email varchar(100),
phone char(14),
likesports boolean,
liketheatre boolean,
likeconcerts boolean,
likejazz boolean,
likeclassical boolean,
likeopera boolean,
likerock boolean,
likevegas boolean,
likebroadway boolean,
likemusicals boolean);

create table venue(
venueid smallint not null distkey sortkey,
venuename varchar(100),
venuecity varchar(30),
venuestate char(2),
venueseats integer);

create table category(
catid smallint not null distkey sortkey,
catgroup varchar(10),
catname varchar(10),
catdesc varchar(50));

create table date(
dateid smallint not null distkey sortkey,
caldate date not null,
day character(3) not null,
week smallint not null,
month character(5) not null,
qtr character(5) not null,
year smallint not null,
holiday boolean default('N'));

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);

create table listing(
listid integer not null distkey,
sellerid integer not null,
eventid integer not null,
dateid smallint not null sortkey,
numtickets smallint not null,
priceperticket decimal(8,2),
totalprice decimal(8,2),
listtime timestamp);

create table sales(
salesid integer not null,
listid integer not null distkey,
sellerid integer not null,
buyerid integer not null,
eventid integer not null,
dateid smallint not null sortkey,
qtysold smallint not null,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp);

Le résultat attendu sera affiché comme ci-dessous :-

Créer le schéma de la table

Table Schema part 2

Ensuite, essayons de télécharger des données échantillons dans notre entrepôt de données. Pour cet exemple, j’ai téléchargé un échantillon de données dans mon propre seau S3 puis j’ai utilisé le script ci-dessous pour copier les données du fichier S3 dans Redshift.

Téléchargement des données de test

 
copy sales from 's3://shahril-redshift01-abcde/sales_tab.txt'
iam_role 'arn:aws:iam::325581293405:role/shahril-redshift-s3-ro-role'
delimiter '\t' timeformat 'MM/DD/YYYY HH:MI:SS' region 'eu-west-1';

copy dates from 's3://shahril-redshift01-abcde/date2008_pipe.txt'
iam_role 'arn:aws:iam::325581293405:role/shahril-redshift-s3-ro-role'
delimiter '|' region 'eu-west-1';

Si tu rencontres un problème pendant le chargement, tu peux interroger la table du dictionnaire Redshift nommée stl_load_errors comme ci-dessous pour avoir une idée du problème.

 select * from stl_load_errors ; 

Test query

Enfin, une fois que tout est fait, tu devrais pouvoir extraire et manipuler les données à l’aide de n’importe quelle fonction SQL fournie. Tu trouveras ci-dessous quelques exemples de scripts de requêtes que j’ai utilisés pour notre exemple.

 
-- Get definition for the sales table.
SELECT *
FROM pg_table_def
WHERE tablename = 'sales';

-- Find total sales on each day
SELECT b.caldate days, sum(a.qtysold) FROM sales a, dates b
WHERE a.dateid = b.dateid
group by b.caldate ;

-- Find top 10 buyers by quantity.
SELECT firstname, lastname, total_quantity
FROM (SELECT buyerid, sum(qtysold) total_quantity
FROM sales
GROUP BY buyerid
ORDER BY total_quantity desc limit 10) Q, users
WHERE Q.buyerid = userid
ORDER BY Q.total_quantity desc;

-- Find events in the 99.9 percentile in terms of all time gross sales.
SELECT eventname, total_price
FROM (SELECT eventid, total_price, ntile(1000) over(order by total_price desc) as percentile
FROM (SELECT eventid, sum(pricepaid) total_price
FROM sales
GROUP BY eventid)) Q, event E
WHERE Q.eventid = E.eventid
AND percentile = 1
ORDER BY total_price desc;

Résultat du test

C’est parti ! Nous avons maintenant réussi à configurer notre propre cluster Redshift pour l’entreposage de données. Ensuite, nous allons voir comment combiner les données existantes dans Redshift Cluster avec n’importe quel fichier plat en utilisant Redshift Spectrum.

Vous aimerez aussi...