CDP partie 2 : déploiement d'un environnement CDP Public Cloud sur AWS

La Cloudera Data Platform (CDP) Public Cloud constitue la base sur laquelle des lacs de données (Data Lake) complets sont créés.

Dans un article précédent, nous avons présenté la plateforme CDP. Cet article est le deuxième d’une série de six pour apprendre à construire des architectures big data de bout en bout avec CDP :

• CDP partie 1 : introduction à l’architecture Data Lakehouse avec CDP
• CDP partie 2 : déploiement d’un environnement CDP Public Cloud sur AWS
• CDP partie 3 : activation des Data Services en environnement CDP Public Cloud
• CDP partie 4 : gestion des utilisateurs sur CDP avec Keycloak
• CDP partie 5 : gestion des permissions utilisateurs sur CDP
• CDP partie 6 : cas d’usage bout en bout d’un Data Lakehouse avec CDP

Plus précisément, nous allons :

1. Créer un identifiant permettant à CDP de gérer des ressources sur AWS
2. Configurer une stack CloudFormation qui servira comme base à notre déploiement.
3. Déployer un environnement CDP comprenant un Data Lake sur AWS

La configuration et le déploiement peuvent être réalisés via les interfaces web de Cloudera et d’Amazon - généralement appelées console AWS ou console CDP - ou par leurs outils CLI respectifs. Nous couvrons les deux approches. Tout d’abord, nous montrons comment effectuer toutes les étapes préparatoires et le déploiement proprement dit avec les consoles. Ensuite, nous fournissons les commandes de la console pour effectuer les mêmes tâches à partir d’un terminal grâce aux CLI.

Avant de commencer, quelques remarques importantes :

1. Ce déploiement est basé sur la documentation AWS quickstart de Cloudera et vise à fournir un environnement utilisable aussi rapidement que possible. Il n’est pas optimisé pour une utilisation en production et ne convient pas non plus si vous souhaitiez utiliser des composants d’infrastructure déjà existants - tels que des VPC et des groupes de sous-réseaux - au lieu de ceux gérés par CDP.

2. Si vous décidez de suivre la procédure, sachez que CDP crée des ressources sur votre compte AWS qui engendrent des coûts. Vous trouverez une liste des ressources créées au cours de ce déploiement et une estimation approximative des coûts associés à la fin de l’article. Veillez à toujours supprimer les ressources sur le cloud qui ne sont plus utilisées afin d’éviter les coûts indésirables.

Ceci étant dit, commençons par configurer nos comptes CDP et AWS. Pour rappel, vous devez avoir au moins les privilèges Power User sur CDP et Administrator access sur AWS pour suivre la procédure.

Déployer à l’aide des interfaces Web CDP et AWS

Cette approche est recommandée si vous êtes novice en matière de CDP et/ou d’AWS. Elle est plus lente mais vous donne une meilleure idée des différentes étapes du processus de déploiement. Si vous n’avez pas installé et configuré les CLI CDP et AWS comme décrit dans la première partie de la série, vous n’avez pas d’autre option.

Si vous souhaitez aller plus vite et utiliser le terminal pour gérer votre déploiement, descendez jusqu’à la section Déployer à partir du terminal. Notez que vous devez toujours utiliser la console CDP pour créer vos informations d’identification CDP. Nous vous recommandons de suivre les étapes ci-dessous jusqu’au moment où vous copiez votre Amazon Resource Name (ARN) pour le rôle d’accès inter-comptes (Cross-account access role).

Créer un identifiant CDP

CDP Public Cloud crée et gère des ressources AWS en votre nom. Il est donc nécessaire de déléguer l’accès à votre compte AWS à travers un rôle d’accès inter-comptes (Cross-account access role). La première étape consiste à créer ce rôle pour votre compte AWS et à le stocker dans votre compte CDP en tant que justificatif d’identité.

• Pour commencer, connectez-vous à la console Cloudera et accédez à la Management console :

  

• Naviguez vers Shared Resources > Credentials et cliquez sur Create Credential en haut à droite :

  

• Dans le menu Create Credential, sélectionnez AWS, puis entrez un nom et éventuellement une description pour votre identifiant. Ce nom et cette description sont utilisés du côté CDP de votre architecture.

  

• Copiez la politique AWS IAM disponible sous Create Cross-account Access Policy. Veillez à sélectionner la version avec les permissions Default, et non celle avec les permissions Minimal.

• Dans un nouvel onglet du navigateur, accédez à Identity and Access Management (IAM) - Policies dans votre console AWS et cliquez sur Create Policy.

  

• Collez le policy document que vous avez copié depuis la console CDP :

  

• Cliquez sur Next, ajoutez éventuellement des tags et cliquez à nouveau sur Next :

• Passez en revue le policy document, fournissez un nom et une description facultative. AWS affiche un message d’avertissement que vous pouvez ignorer. Cliquez sur Create policy.

  

• Restez dans votre console AWS IAM et naviguez jusqu’à Roles, puis sélectionnez Create role :

  

• Sous Trusted Entity Type, sélectionnez AWS Account. Sélectionnez Another AWS account ci-dessous et cochez l’option Require external ID :

  

• Retournez à votre console CDP et copiez le Service Manager Account ID et le External ID dans les champs correspondants sur AWS.

  

• Dans la console AWS IAM, cliquez sur Next après avoir collé les deux identifiants :

  

• Sous Permissions policies, trouvez la politique que vous avez créée plus tôt et cochez la case à gauche, puis cliquez sur Next :

  

• Sous Name, review, and create, entrez un nom et éventuellement une description pour votre rôle. Faites défiler vers le bas, ajoutez éventuellement des tags, puis cliquez sur Create :

  

• Recherchez le rôle que vous venez de créer dans la console AWS IAM :

  

• Copiez l’ARN du rôle que vous venez de créer :

  

• Retournez dans votre console CDP et collez l’ARN de votre rôle d’accès inter-comptes dans le champ correspondant, puis cliquez sur Create :

  

Félicitations, vous avez configuré votre justificatif d’identité pour gérer les ressources AWS à travers CDP.

Configurer une stack AWS CloudFormation

Ensuite, nous créons une stack CloudFormation. Cette stack va contenir les politiques IAM de base, les rôles et les profils d’instance qui sont utilisés par nos ressources CDP ainsi que la configuration de base de notre Data Lake.

• Pour commencer, téléchargez le modèle de stack CloudFormation fourni par Cloudera.

• Ensuite, accédez à votre console AWS et naviguez jusqu’au service CloudFormation.

• Important : Assurez-vous que vous êtes connecté à la région AWS dans laquelle vous souhaitez créer votre stack. Pour les besoins de ce tutoriel, nous restons dans la région EU Ireland (eu-west-1).

• Cliquez sur Create stack.

  

• Sélectionnez Template is ready et Upload template file, puis utilisez la boîte de dialogue pour uploader le modèle de stack que vous avez téléchargé précédemment. Lorsque vous avez terminé, cliquez sur Next.

  

• Configurez votre stack comme suit :

  1. Choisissez un nom de stack, par exemple my-cdp-stack
  2. Choisissez un bucket S3 et un répertoire pour stocker les sauvegardes, par exemple my-unique-cdp-bucket/backups
  3. Choisissez un bucket et un répertoire S3 pour stocker les logs, par exemple my-unique-cdp-bucket/logs
  4. Choisissez un bucket et un répertoire S3 pour stocker les données, par exemple my-unique-cdp-bucket/data
  5. Décidez d’un préfixe à utiliser pour toutes les ressources IAM générées par cette stack, par exemple cdp

  

N’oubliez pas que le nom de votre bucket S3 doit être unique au niveau mondial. Veillez à utiliser le même bucket pour les trois emplacements de stockage (/backups, /logs et /data).

• Cliquez sur Next, ajoutez éventuellement des tags pour votre stack, mais ne changez rien d’autre et cliquez à nouveau sur Next.

• Sous Review stack, faites défiler jusqu’en bas et confirmez que vous reconnaissez qu’AWS CloudFormation peut créer des ressources IAM avec des noms personnalisés. Cliquez sur Submit pour créer votre stack.

  

• Attendez que les éléments de votre stack soient créés. Un message vert CREATE COMPLETE s’affiche dans CloudFormation une fois que le processus s’est achevé avec succès.

  

Et c’est tout ! Vous disposez maintenant d’une stack sur laquelle vous pouvez déployer un environnement de cloud public CDP dans AWS.

Créer une paire de clés SSH

Lorsque vous créez votre environnement CDP, vous devez fournir une paire de clés SSH. Bien que vous ayez la possibilité de créer une nouvelle paire de clés lors de l’enregistrement de l’environnement, il est préférable de la créer à l’avance.

• Pour créer une nouvelle paire de clés SSH, accédez à votre console AWS et naviguez jusqu’à EC2 > Network & Security > Key Pairs. Assurez-vous d’être dans la région où vous souhaitez créer votre environnement et cliquez sur Create key pair :

  

• Sous Create key pair, donnez un nom à votre paire de clés. Vous aurez besoin de ce nom plus tard lorsque vous créerez votre environnement. Choisissez RSA comme Key pair type et .pem comme Private key file format. Ajoutez éventuellement quelques tags et cliquez sur Create key pair.

  

Enregistrer un environnement CDP sur AWS

Une fois la configuration terminée, nous sommes enfin prêts à lancer notre environnement CDP sur AWS.

Avant de continuer, il est important de vous rappeler que les ressources lancées par CDP ne sont pas gratuites. Si vous décidez de suivre le processus, vous aurez des frais sur votre compte AWS. Chaque fois que vous vous entraînez avec un service cloud, assurez-vous de supprimer les ressources lorsque vous avez terminé.

• Pour commencer à déployer un environnement via la console CDP, naviguez vers Management Console > Environments et cliquez sur Register Environment :

  

  

• Dans la boîte de dialogue Register Environment, indiquez un nom et éventuellement une description pour votre environnement. Sélectionnez AWS comme fournisseur de cloud et choisissez l’identifiant que vous avez créé précédemment, puis cliquez sur Next :

  

• Fournissez un nom et sélectionnez une version d’exécutable pour votre Data Lake. Sélectionnez toujours la dernière version d’exécutable disponible, sauf si vous avez besoin d’une version antérieure.

  

• Sous Data Access and Audit, sélectionnez les rôles, les profils d’instance et les emplacements de stockage que vous avez créés lors de l’enregistrement de votre stack.

  

• Si vous ne vous souvenez pas des détails, consultez AWS CloudFormation. Il vous suffit de cliquer sur votre stack et de sélectionner l’onglet Parameters :

  

• Sous Scale, sélectionnez la configuration souhaitée pour votre Data Lake. Light Duty devrait suffire pour notre cas d’utilisation. Cliquez sur Next.

  

• Dans Region, Networking and Security, appliquez la configuration suivante :

  • Région : Sélectionnez la région AWS dans laquelle vous avez créé votre stack.

  • Network (Réseau) : Sélectionnez Create new network (Créer un nouveau réseau)

  • Veillez à activer Public Endpoint Access Gateway.

  

• Laissez la configuration du proxy sur le paramètre par défaut Do not use Proxy Configuration (Ne pas utiliser la configuration du proxy).

• Dans Security Access Settings, laissez le paramètre par défaut Create New Security Groups avec un accès CIDR de 0.0.0.0/0.

• Dans SSH Settings, choisissez Existing SSH public key et sélectionnez la clé que vous avez créée précédemment dans le menu déroulant.

  

• Ajoutez éventuellement quelques tags. Ces balises sont appliquées à toutes les ressources AWS créées au cours de cette étape. Nous vous recommandons de toujours étiqueter vos ressources pour faciliter leur contrôle et leur suppression. Lorsque vous avez terminé, cliquez sur Next.

• Sous Logger Instance Profile, entrez le [YOUR-PREFIX]-log-access-instance-profile ainsi que la base de l’emplacement S3 du journal et de la sauvegarde créés dans votre stack. Vérifiez votre console CloudFormation pour avoir les bons paramètres, en cas de doute.

  

• Cliquez sur Register Environment pour lancer la création de l’environnement.

Et c’est tout ! Vous avez maintenant lancé le déploiement d’un environnement CDP Public Cloud sur AWS. Surveillez votre progression à travers la console Cloudera :

Supprimer votre environnement CDP

Dès que vous n’utilisez plus votre environnement, vous devez le supprimer d’AWS afin d’éviter des coûts indésirables. Notez que votre stack de base et le bucket S3 que vous avez créé à travers CloudFormation restent, de sorte que vous pouvez redéployer votre environnement plus tard à partir de Enregistrer un environnement CDP sur AWS.

Pour supprimer votre environnement via la console Cloudera :

• Allez sur Environments dans la Cloudera Management Console. Cochez la case à côté de l’environnement que vous souhaitez supprimer et cliquez sur Delete Environment :

  

• Dans la boîte de dialogue de confirmation, saisissez le nom de la ressource que vous souhaitez supprimer et cochez les deux premières cases, puis cliquez sur Delete :

  

Sachez qu’il est possible que le processus de suppression de l’environnement ne s’achève pas avec succès. Vérifiez toujours deux fois dans votre console AWS que toutes les ressources gérées par CDP ont été supprimées de votre compte. Vous pouvez utiliser le service CloudFormation ou les étiquettes de ressources AWS (si vous les avez configurées lors du déploiement) pour rechercher les ressources gérées par CDP.

Déployer à partir du terminal

Le déploiement via le terminal est recommandé aux utilisateurs expérimentés qui souhaitent lancer leur environnement rapidement. Vous devez avoir les CDP CLI et AWS CLI installées sur votre système comme décrit dans la première partie de la série. Le logiciel jq est également nécessaire pour que les commandes ci-dessous fonctionnent.

L’ordre des opérations est la même que si vous déployez à travers l’interface web : Tout d’abord, créez un identifiant (ce qui nécessite l’utilisation de l’interface web), puis créez votre stack CloudFormation et votre paire de clés SSH avant de lancer votre environnement.

Enregistrez votre identifiant CDP

Utilisez l’interface web pour créer un “Cross-account access role” dans votre compte AWS comme décrit ci-dessus. Suivez les étapes jusqu’au moment où vous copiez l’ARN du rôle nouvellement créé, puis enregistrez-le dans CDP avec la commande suivante :

# Définissez l'ARN de votre rôle AWS
export CDP_AWS_CROSS_ACCOUNT_ROLE_ARN=[your-role-arn]

# Enregistrez vos informations d'identification CDP
export CDP_CREDENTIAL_NAME=${USER}-aws-credential
export CDP_CREDENTIAL_DESC="CDP AWS credential by ${USER}"

cdp environments create-aws-credential \
 --credential-name ${CDP_CREDENTIAL_NAME} \
 --role-arn ${CDP_AWS_CROSS_ACCOUNT_ROLE_ARN} \
 --description "${CDP_CREDENTIAL_DESC}"

Il n’y a pas de retour immédiat si vous avez réussi à créer votre justificatif d’identité. Pour valider la création de votre identifiant, utilisez cette commande :

# Valider l'existence d'un identifiant CDP
cdp environments list-credentials \
  --credential-name=${CDP_CREDENTIAL_NAME}

Créer une stack CloudFormation

L’étape suivante du processus de déploiement est la création d’une stack CloudFormation. Pour créer la stack via la CLI AWS sur la base du modèle fourni par Cloudera, utilisez les commandes suivantes :

# Télécharger et sauvegarder le modèle
curl \
  -o ~/aws-cdp-template.json \
  https://docs.cloudera.com/cdp-public-cloud/cloud/quickstart-files/cloud-formation-setup.json

# Définir des variables d'environnement supplémentaires
export CDP_BASE_STACK_NAME=aws-${USER}-env
export CDP_RESOURCE_PREFIX=cdp
export AWS_S3_BUCKET=cdp-${USER}-$RANDOM
export AWS_S3_BUCKET_DATA=${AWS_S3_BUCKET}/data
export AWS_S3_BUCKET_LOGS=${AWS_S3_BUCKET}/logs
export AWS_S3_BUCKET_BACKUPS=${AWS_S3_BUCKET}/backups

# Définir optionnellement une région. Si elle n'est pas définie, la commande suivante prendra par défaut eu-west-1.
export AWS_REGION=eu-west-1

# Créez votre stack AWS CloudFormation
aws cloudformation deploy \
  --template-file ~/aws-cdp-template.json \
  --stack-name ${CDP_BASE_STACK_NAME} \
  --parameter-overrides \
      StorageLocationBase=${AWS_S3_BUCKET_DATA} \
      LogsLocationBase=${AWS_S3_BUCKET_LOGS} \
      BackupLocationBase=${AWS_S3_BUCKET_BACKUPS} \
      prefix=${CDP_RESOURCE_PREFIX} \
  --region ${AWS_REGION:-eu-west-1} \
  --capabilities CAPABILITY_NAMED_IAM

La progression du processus de création des éléments de la stack est affichée dans votre terminal.

Créer une paire de clés SSH

Vous devez fournir une paire de clés SSH lorsque vous enregistrez votre environnement. Utilisez ces commandes pour créer une nouvelle paire de clés :

# Définissez un nom pour votre paire de clés
export AWS_SSH_KEY=aws-cdp-${USER}

# Créer la paire de clés et télécharger le fichier
aws ec2 create-key-pair \
  --key-name ${AWS_SSH_KEY} \
  --output text > /home/${USER}/.ssh/${AWS_SSH_KEY}.pem \
  --region ${AWS_REGION:-eu-west-1} \
  && chmod 400 /home/${USER}/.ssh/${AWS_SSH_KEY}.pem

Il n’y a pas d’information de retour si vous avez réussi à créer votre paire de clés. Utilisez cette commande pour valider la réussite de l’opération :

aws ec2 describe-key-pairs \
  --key-name {$AWS_SSH_KEY} \
  --region ${AWS_REGION:-eu-west-1}

Lancer votre environnement et votre Data Lake

Une fois la configuration terminée, vous êtes prêt à lancer votre environnement de cloud public CDP et votre Data Lake. Pour ce faire, trois étapes doivent être exécutées dans cet ordre :

1. Créer l’environnement CDP de base
2. Configurer les mappings de l’ID broker
3. Créer le Data Lake lui-même

Avant de commencer, assurons-nous que toutes les variables d’environnement sont disponibles dans la session shell actuelle :

# Nommage des ressources CDP
export CDP_ENV_NAME=aws-${USER}
export CDP_DATALAKE_NAME=aws-${USER}-datalake
export CDP_RESOURCE_PREFIX=$(aws cloudformation describe-stacks \
  --stack-name ${CDP_BASE_STACK_NAME:-aws-${USER}-env} \
  | jq -r '.Stacks[].Parameters[] | select (.ParameterKey=="prefix").ParameterValue')
export AWS_S3_BUCKET=$(aws cloudformation describe-stacks \
  --stack-name ${CDP_BASE_STACK_NAME:-aws-${USER}-env} \
  | jq -r '.Stacks[].Parameters[] | select(.ParameterKey=="StorageLocationBase").ParameterValue' \
  | grep -Po '[a-z0-9-]*(?=/)')
export AWS_S3_BUCKET_DATA=${AWS_S3_BUCKET}/data
export AWS_S3_BUCKET_LOGS=${AWS_S3_BUCKET}/logs
export AWS_S3_BUCKET_BACKUPS=${AWS_S3_BUCKET}/backups

# Profils AWS pour les instances et les rôles sur les ressources
export AWS_ACCOUNT_ID=$(aws sts get-caller-identity | grep -Po "(?<=\"Account\": \")[0-9]*")
export AWS_LOG_ACCESS_INSTANCE_PROFILE_ARN=arn:aws:iam::${AWS_ACCOUNT_ID}:instance-profile/${CDP_RESOURCE_PREFIX}-log-access-instance-profile
export AWS_DATA_ADMIN_ROLE_ARN=arn:aws:iam::${AWS_ACCOUNT_ID}:role/${CDP_RESOURCE_PREFIX}-datalake-admin-role
export AWS_DATA_ADMIN_INSTANCE_PROFILE_ARN=arn:aws:iam::${AWS_ACCOUNT_ID}:instance-profile/${CDP_RESOURCE_PREFIX}-data-access-instance-profile
export AWS_RANGER_AUDIT_ROLE_ARN=arn:aws:iam::${AWS_ACCOUNT_ID}:role/${CDP_RESOURCE_PREFIX}-ranger-audit-role

# Étiquetage des ressources AWS
export AWS_TAG_GENERAL_KEY=ENVIRONMENT_PROVIDER
export AWS_TAG_GENERAL_VALUE=CLOUDERA
export AWS_TAG_SERVICE_KEY=CDP_SERVICE
export AWS_TAG_SERVICE_ENVIRONMENT=CDP_ENVIRONMENT
export AWS_TAG_SERVICE_DATALAKE=CDP_DATALAKE

Commençons par créer notre environnement AWS :

# Cration de l'environnement de base
cdp environments create-aws-environment \
  --environment-name ${CDP_ENV_NAME:-aws-${USER}} \
  --credential-name ${CDP_CREDENTIAL_NAME:-${USER}-aws-credential} \
  --region ${AWS_REGION:-eu-west-1} \
  --security-access cidr=${CDP_SECURITY_ACCESS:-0.0.0.0/0} \
  --tags key=${AWS_TAG_GENERAL_KEY},value=${AWS_TAG_GENERAL_VALUE} key=${AWS_TAG_SERVICE_KEY},value=${AWS_TAG_SERVICE_ENVIRONMENT} \
  --endpoint-access-gateway-scheme ${CDP_GATEWAY_SCHEME:-PUBLIC} \
  --enable-tunnel \
  --authentication publicKeyId=${AWS_SSH_KEY:-aws-cdp-${USER}} \
  --log-storage storageLocationBase=s3a://${AWS_S3_BUCKET_LOGS},backupStorageLocationBase=s3a://${AWS_S3_BUCKET_BACKUPS},instanceProfile=${AWS_LOG_ACCESS_INSTANCE_PROFILE_ARN} \
  --network-cidr ${AWS_NETWORK_CIDR:-10.10.0.0/16} \
  --create-private-subnets \
  --no-create-service-endpoints \
  --free-ipa instanceCountByGroup=${CDP_IPA_INSTANCE_COUNT:-2}

Ensuite, nous définissons nos mappings d’ID broker :

# Configurer les mappings de l'ID broker 
cdp environments set-id-broker-mappings \
  --environment-name ${CDP_ENV_NAME:-aws-${USER}} \
  --data-access-role ${AWS_DATA_ADMIN_ROLE_ARN} \
  --ranger-audit-role ${AWS_RANGER_AUDIT_ROLE_ARN} \
  --set-empty-mappings

Enfin, nous créons le Data Lake :

# Création du Data Lake
cdp datalake create-aws-datalake \
  --datalake-name ${CDP_DATALAKE_NAME:-aws-${USER}-datalake} \
  --environment-name ${CDP_ENV_NAME:-aws-${USER}} \
  --cloud-provider-configuration instanceProfile=${AWS_DATA_ADMIN_INSTANCE_PROFILE_ARN},storageBucketLocation=s3a://${AWS_S3_BUCKET_DATA} \
  --tags key=${AWS_TAG_GENERAL_KEY},value=${AWS_TAG_GENERAL_VALUE} key=${AWS_TAG_SERVICE_KEY},value=${AWS_TAG_SERVICE_DATALAKE} \
  --scale ${CDP_DATALAKE_SCALE:-LIGHT_DUTY} \
  --runtime ${CDP_DATALAKE_RUNTIME:-7.2.15} \
  --no-enable-ranger-raz

Surveillez votre environnement et l’état de votre Data Lake avec les commandes suivantes :

# Vérification de l'état de l'environnement
cdp environments describe-environment \
  --environment-name ${CDP_ENV_NAME:-aws-${USER}} \
  | jq -r '.environment.status'

# Vérification de l'état du Data Lake
cdp datalake describe-datalake \
  --datalake-name ${CDP_DATALAKE_NAME:-aws-${USER}} \
  | jq -r '.datalake.status'

Si le déploiement a réussi, le statut de votre environnement est AVAILABLE, et le statut de votre Data Lake est RUNNING.

Décommission des ressources

Une fois que vous n’utilisez plus votre environnement, il est fortement recommandé de supprimer vos ressources AWS afin d’éviter des coûts inutiles. Exécutez la commande suivante pour supprimer votre environnement et toutes les ressources associées :

# Supprimer un environnement CDP et toutes les ressources associées
cdp environments delete-environment \
  --environment-name ${CDP_ENV_NAME:-aws-${USER}} \
  --cascading

Veillez à toujours vérifier que vos ressources ont été entièrement supprimées. La meilleure façon de vérifier que toutes les ressources ont été supprimées est de consulter votre console AWS CloudFormation.

Ressources et coûts

Bien que la documentation CDP Public Cloud de Cloudera soit exhaustive, la détermination des ressources créées dans le cadre de votre déploiement n’est pas une tâche triviale. D’après nos observations, le déploiement que nous décrivons dans cet article - avec une configuration Light Duty pour le Data Lake - crée les ressources suivantes :

Les coûts horaires et autres sont pour la région UE Irlande, et consultés en juin 2023. La tarification des ressources AWS varie selon les régions et peut évoluer dans le temps. Consultez la tarification AWS pour connaître les tarifs en vigueur dans votre région.

* La base fait référence aux ressources AWS créées sur votre compte par la stack CloudFormation initiale. Ces ressources restent sur votre compte, même si le déploiement est supprimé, jusqu’à ce que vous supprimiez la stack.

** Par instance EC2 en cours d’exécution, une adresse IP élastique est gratuite.

Certains coûts qui augmentent avec l’utilisation comme les coûts de transfert de données, et les coûts mensuels qui sont calculés au prorata sur une base horaire comme les coûts de stockage EBS, ne sont pas pris en compte. Ce déploiement de base a un coût horaire d’environ 1,17 $.

Prochaine étape : activer les Data Services

Bien sûr, il n’y a pas grand-chose que vous puissiez faire pour l’instant, avec votre tout nouvel environnement CDP Public Cloud. Afin de compléter et utiliser notre architecture bout-en-bout, nous allons nous pencher dans le chapitre suivant sur la manière d’activer des Data Services.