- The page you’re looking for does not exist. It may have been moved. You can follow one of the links in the navigation to the left.
-If you arrived on this page by clicking on a link, please notify the owner of the site that the link is broken. -If you typed the URL of this page manually, please double check that you entered the address correctly.
-This project showcases the integration of dbt with Teradata Vantage from an advanced user perspective. -If you are new to data engineering with dbt we recommend that you start with our introductory project.
-The advanced use cases showcased in the demo are the following:
-Incremental materializations
-Utility macros
-Optimizing table/view creations with Teradata-specific modifiers
-The application of these concepts is illustrated through the ELT process of teddy_retailers, a fictional store.
Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Python 3.7, 3.8, 3.9 or 3.10 installed.
-A database client for running database commands, an example of the configuration of one such client is presented in this tutorial..
-Clone the tutorial repository and cd into the project directory:
-git clone https://github.com/Teradata/teddy_retailers_dbt-dev teddy_retailers
-cd teddy_retailersCreate a new python environment to manage dbt and its dependencies. Confirm that the Python Version you are using to create the environment is within the supported versions listed above.
-python -m venv envActivate the python environment according to your operating system.
-source env/bin/activatefor Mac, Linux, or
-env\Scripts\activatefor Windows
-Install the dbt-teradata module. The core dbt module is included as a dependency so you don’t have to install it separately:
pip install dbt-teradataInstall the project’s dependencies dbt-utils and teradata-utils. This can be done through the following command:
dbt depsThe demo project assumes that the source data is already loaded into your data warehouse, this mimics the way that dbt is used in a production environment.
-To achieve this objective we provide public datasets available in Google Cload Platform (GCP), and scripts to load those datasets into your mock data warehouse.
Create or select a working database. The dbt profile in the project points to a database called teddy_retailers. You can change the schema value to point to an existing database in your Teradata Vantage instance or you can create the teddy_retailers database running the following script in your database client:
CREATE DATABASE teddy_retailers
-AS PERMANENT = 110e6,
- SPOOL = 220e6;Load Initial data set.
-To load the initial data set into the data warehouse, the required scripts are available in the references/inserts/create_data.sql path of the project.
-You can execute these scripts by copying and pasting them into your database client. For guidance on running these scripts in your specific case please consult your database client’s documentation.
We will now configure dbt to connect to your Vantage database.
-Create the file $HOME/.dbt/profiles.yml with the following content. Adjust <host>, <user>, <password> to match your Teradata Vantage instance.
-If you have already used dbt before in your environment you only need to add a profile for the project in your home’s directory .dbt/profiles.yml file.
-If the directory .dbt doesn’t exist in your system yet you will need to create it and add the profiles.yml to manage your dbt profiles.
teddy_retailers:
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- logmech: TD2
- schema: teddy_retailers
- tmode: ANSI
- threads: 1
- timeout_seconds: 300
- priority: interactive
- retries: 1
- target: devNow, that we have the profile file in place, we can validate the setup:
-dbt debugIf the debug command returned errors, you likely have an issue with the content of profiles.yml.
As mentioned, teddy_retailers is a fictional store.
-Through dbt driven transformations we transform source data ingested from the`teddy_retailers` transactional database into a star schema ready for analytics.
The source data consists of the following tables customers, orders, products, and order_products, according to the following Entity Relations Diagram:
-
-Using dbt, we leverage the source data tables to construct the following dimensional model, which is optimized for analytics tools.
-
-For Teddy Retailers, the orders and order_products sources are periodically updated by the organization’s ELT (Extract, Load, Transform) process.
The updated data only includes the latest changes rather than the entire dataset due to its large volume.
-To address this challenge, it is necessary to capture these incremental updates while preserving the previously available data.
-The schema.yml file in the project’s models directory specifies the sources for our models. These sources align with the data we loaded from GCP using our SQL scripts.
The staging area models are merely ingesting the data from each of the sources and renaming each field, if appropiate. -In the schema.yml of this directory we define basic integrity checks for the primary keys.
-The following advanced dbt concepts are applied in the models at this stage:
-The schema.yml file in this directory specifies that the materializations of the two models we are building are incremental.
-We employ different strategies for these models:
For the all_orders model, we utilize the delete+insert strategy. This strategy is implemented because there may be changes in the status of an order that are included in the data updates.
For the all_order_products model, we employ the default append strategy. This approach is chosen because the same combination of order_id and product_id may appear multiple times in the sources.
-This indicates that a new quantity of the same product has been added or removed from a specific order.
Within the all_order_products model, we have included an assertion with the help of a macro to test and guarantee that the resulting model encompasses a unique combination of order_id and product_id. This combination denotes the latest quantity of products of a specific type per order.
For both the all_order and all_order_products models, we have incorporated Teradata Modifiers to enhance tracking of these two core models.
-To facilitate collecting statistics, we have added a post_hook that instructs the database connector accordingly. Additionally, we have created an index on the order_id column within the all_orders table.
By executing dbt, we generate the dimensional model using the baseline data.
-dbt runThis will create both our core and dimensional models using the baseline data.
-You can find sample business intelligence queries in the references/query path of the project. These queries allow you to analyze the factual data based on dimensions such as customers, orders, and products.
The scripts for loading updates into the source data set can be found in the references/inserts/update_data.sql path of the project.
After updating the data sources, you can proceed with the aforementioned steps: running dbt, testing the data, and executing sample queries. This will allow you to visualize the variations and incremental updates in the data.
-In this tutorial, we explored the utilization of advanced dbt concepts with Teradata Vantage. -The sample project showcased the transformation of source data into a dimensional data mart. -Throughout the project, we implemented several advanced dbt concepts, including incremental materializations, utility macros, and Teradata modifiers.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
Configure policies with the necessary permissions to provide access to the AWS resources. If the account deploying workspace service does not have sufficient IAM permissions to create IAM roles or IAM policies, your organization administrator can define the roles and policies and pass them to the workspace service template.
-This article contains sample IAM policies required for a new IAM role.
-Configure these policies in the AWS console in Security & Identity > Identity & Access Management > Create Policy. For detailed instructions, see Creating roles and attaching policies (console) - AWS Identity and Access Management.
-The following JSON sample includes permissions needed to create AI Unlimited instances and grants workspace service the permissions to create cluster-specific IAM roles and policies for the engine.
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "iam:PassRole",
- "iam:AddRoleToInstanceProfile",
- "iam:CreateInstanceProfile",
- "iam:CreateRole",
- "iam:DeleteInstanceProfile",
- "iam:DeleteRole",
- "iam:DeleteRolePolicy",
- "iam:GetInstanceProfile",
- "iam:GetRole",
- "iam:GetRolePolicy",
- "iam:ListAttachedRolePolicies",
- "iam:ListInstanceProfilesForRole",
- "iam:ListRolePolicies",
- "iam:PutRolePolicy",
- "iam:RemoveRoleFromInstanceProfile",
- "iam:TagRole",
- "iam:TagInstanceProfile",
- "ec2:TerminateInstances",
- "ec2:RunInstances",
- "ec2:RevokeSecurityGroupEgress",
- "ec2:ModifyInstanceAttribute",
- "ec2:ImportKeyPair",
- "ec2:DescribeVpcs",
- "ec2:DescribeVolumes",
- "ec2:DescribeTags",
- "ec2:DescribeSubnets",
- "ec2:DescribeSecurityGroups",
- "ec2:DescribePlacementGroups",
- "ec2:DescribeNetworkInterfaces",
- "ec2:DescribeLaunchTemplates",
- "ec2:DescribeLaunchTemplateVersions",
- "ec2:DescribeKeyPairs",
- "ec2:DescribeInstanceTypes",
- "ec2:DescribeInstanceTypeOfferings",
- "ec2:DescribeInstances",
- "ec2:DescribeInstanceAttribute",
- "ec2:DescribeImages",
- "ec2:DescribeAccountAttributes",
- "ec2:DeleteSecurityGroup",
- "ec2:DeletePlacementGroup",
- "ec2:DeleteLaunchTemplate",
- "ec2:DeleteKeyPair",
- "ec2:CreateTags",
- "ec2:CreateSecurityGroup",
- "ec2:CreatePlacementGroup",
- "ec2:CreateLaunchTemplateVersion",
- "ec2:CreateLaunchTemplate",
- "ec2:AuthorizeSecurityGroupIngress",
- "ec2:AuthorizeSecurityGroupEgress",
- "secretsmanager:CreateSecret",
- "secretsmanager:DeleteSecret",
- "secretsmanager:DescribeSecret",
- "secretsmanager:GetResourcePolicy",
- "secretsmanager:GetSecretValue",
- "secretsmanager:PutSecretValue",
- "secretsmanager:TagResource"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}The following JSON sample includes the permissions needed to create AI Unlimited instances. If your account restrictions do not allow workspace service to create IAM roles and policies, then you must provide an IAM role with a policy to pass to the engine. In this case, you can use the following modified workspace service policy, which does not include permissions to create IAM roles or IAM policies.
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "iam:PassRole",
- "iam:AddRoleToInstanceProfile",
- "iam:CreateInstanceProfile",
- "iam:DeleteInstanceProfile",
- "iam:GetInstanceProfile",
- "iam:GetRole",
- "iam:GetRolePolicy",
- "iam:ListAttachedRolePolicies",
- "iam:ListInstanceProfilesForRole",
- "iam:ListRolePolicies",
- "iam:PutRolePolicy",
- "iam:RemoveRoleFromInstanceProfile",
- "iam:TagRole",
- "iam:TagInstanceProfile",
- "ec2:TerminateInstances",
- "ec2:RunInstances",
- "ec2:RevokeSecurityGroupEgress",
- "ec2:ModifyInstanceAttribute",
- "ec2:ImportKeyPair",
- "ec2:DescribeVpcs",
- "ec2:DescribeVolumes",
- "ec2:DescribeTags",
- "ec2:DescribeSubnets",
- "ec2:DescribeSecurityGroups",
- "ec2:DescribePlacementGroups",
- "ec2:DescribeNetworkInterfaces",
- "ec2:DescribeLaunchTemplates",
- "ec2:DescribeLaunchTemplateVersions",
- "ec2:DescribeKeyPairs",
- "ec2:DescribeInstanceTypes",
- "ec2:DescribeInstanceTypeOfferings",
- "ec2:DescribeInstances",
- "ec2:DescribeInstanceAttribute",
- "ec2:DescribeImages",
- "ec2:DescribeAccountAttributes",
- "ec2:DeleteSecurityGroup",
- "ec2:DeletePlacementGroup",
- "ec2:DeleteLaunchTemplate",
- "ec2:DeleteKeyPair",
- "ec2:CreateTags",
- "ec2:CreateSecurityGroup",
- "ec2:CreatePlacementGroup",
- "ec2:CreateLaunchTemplateVersion",
- "ec2:CreateLaunchTemplate",
- "ec2:AuthorizeSecurityGroupIngress",
- "ec2:AuthorizeSecurityGroupEgress",
- "secretsmanager:CreateSecret",
- "secretsmanager:DeleteSecret",
- "secretsmanager:DescribeSecret",
- "secretsmanager:GetResourcePolicy",
- "secretsmanager:GetSecretValue",
- "secretsmanager:PutSecretValue",
- "secretsmanager:TagResource"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}The following JSON sample includes the permissions needed to interact with the AWS Session Manager. If you use AWS Session Manager to connect to the instance, you must attach this policy to the IAM role.
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "ssm:DescribeAssociation",
- "ssm:GetDeployablePatchSnapshotForInstance",
- "ssm:GetDocument",
- "ssm:DescribeDocument",
- "ssm:GetManifest",
- "ssm:ListAssociations",
- "ssm:ListInstanceAssociations",
- "ssm:PutInventory",
- "ssm:PutComplianceItems",
- "ssm:PutConfigurePackageResult",
- "ssm:UpdateAssociationStatus",
- "ssm:UpdateInstanceAssociationStatus",
- "ssm:UpdateInstanceInformation"
- ],
- "Resource": "*",
- "Effect": "Allow"
- },
- {
- "Action": [
- "ssmmessages:CreateControlChannel",
- "ssmmessages:CreateDataChannel",
- "ssmmessages:OpenControlChannel",
- "ssmmessages:OpenDataChannel"
- ],
- "Resource": "*",
- "Effect": "Allow"
- },
- {
- "Action": [
- "ec2messages:AcknowledgeMessage",
- "ec2messages:DeleteMessage",
- "ec2messages:FailMessage",
- "ec2messages:GetEndpoint",
- "ec2messages:GetMessages",
- "ec2messages:SendReply"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}If you pass the Teradata AI Unlimited IAM role to a new engine instead of allowing the workspace service to create the cluster-specific role, you can use the following JSON sample as a starting point to create your policy.
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": "secretsmanager:GetSecretValue",
- "Effect": "Allow",
- "Resource": [
- "arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/*"
- ]
- }
- ]
-}When workspace service creates policies for the engine, they are restricted as follows:
-"Resource": ["arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/<CLUSTER_NAME>/<SECRET_NAME>"]If you provide an IAM role and policy, then you can’t predict the cluster name, and to avoid the situation, you can use wildcarding in the replacement policy, such as:
-"arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/*"
-or
-"arn:aws:secretsmanager:<REGION>:111111111111:secret:compute-engine/*"
-or
-"arn:aws:secretsmanager:us-west-2:111111111111:secret:compute-engine/*"With Teradata AI Unlimited, you can redeploy your engine for which the state needs to be persisted regardless of container, pod, or node crashes or terminations. This feature requires persistent storage, that is, storage that lives beyond the lifetime of the container, pod, or node. Teradata AI Unlimited uses the instance root volume of the instance to save data in the JupyterLab /userdata folder, workspace service database, and configuration files. The data persists if you shut down, restart, or snapshot and relaunch the instance. However, if the instance is terminated, your JupyterLab data and workspace service database are lost, and this could pose problems if running on-the-spot instances, which may be removed without warning. If you want a highly persistent instance, enable the UsePersistentVolume parameter to move the JupyterLab data and workspace service database to a separate volume.
The following recommended persistent volume flow remounts the volume and retains the data:
-Create a new deployment with UsePersistentVolume set as New and PersistentVolumeDeletionPolicy set as Retain.
In the stack outputs, note the volume-id for future use.
-Configure and use the instance until the instance is terminated.
-On the next deployment, use the following settings:
-UsePersistentVolume set as New
PersistentVolumeDeletionPolicy set as Retain
ExistingPersistentVolumeId set to the volume-id from the previous deployment
You can relaunch the template with the same configuration whenever you need to recreate the instance with the earlier data.
-Get started with Teradata AI Unlimited by running a simple workflow. See Run a Sample Workload in JupyterLab Using Teradata AI Unlimited.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
AI Unlimited JupyterLab supports the following magic commands in addition to the existing Teradata SQL Kernel magic commands. See Teradata JupyterLab Getting Started Guide.
-Description: One-time configuration to bind with the workspace service.
-Usage:
-%workspaces_config host=<RPC_Service_URL>, apikey=<Workspace_API_Key>, withtls=<T|F>Where:
-host: Name or IP address of the engine service.
-apikey: API Key value from the workspace service Profile page.
-[Optional] withTLS: If False (F), the default client-server communication does not use TLS.
-Output:
-Workspace configured for host=<RPC_Service_URL>-
Description: Create a new project. This command also creates a new repository with the project name in your GitHub account. The configurations are stored in the engine.yml file.
-Usage:
-%project_create project=<Project_Name>, env=<CSP>, team=<Project_Team>Where:
-project: Name of the project to be created.
-env: Cloud environment where the project is hosted. The value can be aws, azure, gcp, or vsphere. For the current release, AWS and Azure are supported.
-[Optional] team: Name of the team collaborating on the project.
-Output:
-Project <Project_Name> created-
Description: Delete a project.
-| - - | --Running this command removes the GitHub repository containing the objects created using Teradata AI Unlimited. - | -
Usage:
-%project_delete project=<Project_Name>, team=<Project_Team>Where:
-project: Name of the project to be deleted.
-[Optional] team: Name of the team collaborating on the project.
-Output:
-Project <Project_Name> deleted-
Description: List the details of the projects.
-Use the project parameter to get the details of a specific project. All the projects are listed if you run the command without any parameters.
-Usage:
-%project_list project=<Project_Name>Where:
-project: Name of the project to be listed.
-Output:
-
-Description: Create an authorization object to store object store credentials.
-You must create the authorization object before deploying the engine. The authorization details are retained and are included while redeploying the project. Optionally, you can create authorizations manually using the CREATE AUTHORIZATION SQL command after deploying the engine. In this case, the authorization details are not retained.
Usage:
-%project_auth_create project=<Project_Name>, name=<Auth_Name>, key=<Auth_Key>, secret=<Auth_Secret>, region=<ObjectStore_Region>, token= <Session_Token>, role=<Role>, ExternalID=<External_ID>Where:
-project: Name of the project.
-name: Authorization name for the object store.
-key: Authorization key of the object store.
-secret: Authorization secret access ID of the object store.
-region: Region of the object store; local for the local object store.
-[Optional] token: Session token for the object store access.
-[Optional] role: IAM users or service account to access AWS resources from an AWS account by assuming a role and its entitlements. The owner of the AWS resource defines the role. For example: arn:aws:iam::00000:role/STSAssumeRole.
-ExternalID: External ID used to access object store.
-Output:
-Authorization 'name' created-
Description: Update an object store authorization.
-Usage:
-%project_auth_update project=<Project_Name>, name=<Auth_Name>, key=<Auth_Key>, secret=<Auth_Secret>, region=<ObjectStore_Region>, token= <Session_Token>, role=<Role>, ExternalID=<External_ID>Where:
-project: Name of the project.
-name: Authorization name for the object store.
-key: Authorization key of the object store.
-[Optional] secret: Authorization secret access ID of the object store.
-[Optional] region: Region of the object store; local for the local object store.
-[Optional] token: Session token for the object store access.
-[Optional] role: IAM users or service account to access AWS resources from an AWS account by assuming a role and its entitlements. The owner of the AWS resource defines the role. For example: arn:aws:iam::00000:role/STSAssumeRole.
-ExternalID: External ID used to access object store.
-Output:
-Authorization 'name' updated-
Description: Remove an object store authorization.
-Usage:
-%project_auth_delete project=<Project_Name>, name=<Auth_Name>Where:
-project: Name of the project.
-name: Authorization name for the object store.
-Output:
-Authorization 'name' deleted-
Description: List object store authorizations that are created for a project.
-Usage:
-%project_auth_list project=<Project_Name>Where:
-project: Name of the project.
-Output:
-
-Description: Deploy an engine for the project. The deployment process takes a few minutes to complete. On successful deployment, a password is generated.
-Usage:
-%project_engine_deploy project=<Project_Name>, size=<Size_of_Engine>, node=<Number_of_Nodes>, subnet=<Subnet_id>, region=<Region>, secgroups=<Security_Group>, cidrs=<CIDR>Where:
-project: Name of the project.
-size: Size of the engine. The value can be:
-small
-medium
-large
-extralarge
-[Optional] node: Number of engine nodes to be deployed. The default value is 1.
-[Optional] subnet: Subnet used for the engine if there are no default values from the service.
-[Optional] region: Region used for the engine if there are no default values from service.
-[Optional] secgroups: List of security groups for the VPC in each region. If you don’t specify a security group, the engine is automatically associated with the default security group for the VPC.
-[Optional] cidr: List of CIDR addresses used for the engine.
-Output:
-Started deploying. -Success: Compute Engine setup, look at the connection manager-
-Description: Stop the engine after you’re done with your work.
-Usage:
-%project_engine_suspend <Project_Name>Where:
-project: Name of the project.
-Output:
-Started suspend. Success: connection removed -Success: Suspending Compute Engine-
Description: View the list of engines deployed for your project.
-Usage:
-%project_engine_list project=<Project_Name>Where:
-project: Name of the project.
-Output:
-
-Description: View the list of collaborators assigned to the project.
-Usage:
-%project_user_list project=<Project_Name>Where:
-[Optional] project: Name of the project.
-Output:
-
-Description: Back up your project metadata and object definition inside the engine.
-Usage:
-%project_backup project=<Project_Name>Where:
-project: Name of the project.
-Output:
-Backup of the object definitions created-
Description: Restore your project metadata and object definition from your GitHub repository.
-Usage:
-%project_restore project=<Project_Name>, gitref=<Git_Reference>Where:
-project: Name of the project.
-[Optional] gitref: Git reference.
-Output:
-Restore of the object definitions done-
Description: View the list of magics provided with AI-Unlimited-Teradata SQL CE Kernel.
-Usage:
-%helpAdditionally, you can see detailed help messages per command.
-Usage:
-%help <command>| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
The AWS CloudFormation template launches, configures, and runs the AWS compute, network, storage, and other services required to deploy workspace service and JupyterLab on AWS. -You can deploy the CloudFormation template using one of the following ways:
-There is no additional cost for downloading the workspace service; however, you are responsible for the cost of the AWS services or resources used while deploying the workspace service and engine. -The AWS CloudFormation template includes configuration parameters that you can customize. Some of these settings, such as instance type, affect the cost of deployment. For cost estimates, review the Marketplace agreement page.
-Open a terminal window and clone the Teradata AI Unlimited GitHub repository. This repository includes sample CloudFormation templates to deploy workspace service and JupyterLab.
-git clone https://github.com/Teradata/ai-unlimitedIf you don’t already have an AWS account, create one at https://aws.amazon.com by following the on-screen instructions.
-Make sure the account deploying workspace service has sufficient IAM permissions to create IAM roles or IAM policies. Contact your organization administrator if your account doesn’t have the required permission. See Control AWS Access and Permissions using Custom Permissions and Policies.
-Use the region selector in the navigation bar to choose the AWS region where you want to deploy the Teradata AI Unlimited workspace service.
-Generate a key pair to connect securely to your workspace service instance using SSH after it launches. See Amazon EC2 key pairs and Linux instances.
-| - - | --Alternatively, you can use AWS Session Manager to connect to the workspace service instances, in which case, you must attach the session-manager.json policy to the IAM role. See Control AWS Access and Permissions using Custom Permissions and Policies. If you don’t require host OS access, you can choose not to use either of these connection methods. - | -
This article requires an Amazon Machine Image (AMI) subscription for Teradata AI Unlimited running on AWS. Contact Teradata Support to obtain a license for Teradata AI Unlimited.
-To subscribe:
-Log on to your AWS account.
-Open the AWS Marketplace page for Teradata AI Unlimited and choose Continue.
-Review and accept the terms and conditions for the engine images.
- -Sign on to your AWS account on the AWS Console.
-Check the AWS Region displayed in the upper-right corner of the navigation bar and change it if necessary. Teradata recommends selecting a region closest to your primary work location.
-Go to CloudFormation > Create Stack. Select Create Stack and select With new resources (standard).
-Select Template is ready, and then upload one of the downloaded template files from the Teradata AI Unlimited GitHub repository:
-Workspaces Template: Deploys a single instance with Workspaces running in a container controlled by systemd.
-workspaces.yaml CloudFormation template
-parameters/workspaces.json parameter file
-Jupyter Template: Deploys a single instance with JupyterLab running in a container controlled by systemd.
-jupyter.yaml CloudFormation template
-parameters/jupyter.json parameter file
-All-In-One Template: Deploys a single instance with Workspaces and JupyterLab running on the same instance.
-all-in-one.yaml CloudFormation template
-parameters/all-in-one.json parameter file
-If you’re using this template, you can use the embedded JupyterLab service or connect to an external JupyterLab instance. When connecting to the embedded JupyterLab service, you must set the appropriate connection address in the JupyterLab notebook (for example, 127.0.0.1), and for external clients, you must set the appropriate public-private IP or DNS name.
-Review the parameters for the template. Provide values for the parameters that require input. For all other parameters, review the default settings and customize them as necessary. When you finish reviewing and customizing the parameters, choose Next.
-In the following tables, parameters are listed by category:
-AWS Instance and Network Settings
-| Parameter | -Description | -Required? | -Default | -Notes | -
|---|---|---|---|---|
InstanceType |
-The EC2 instance type that you want to use for the service. |
-Required with default |
-t3.small |
-Teradata recommends using the default instance type to save costs. |
-
RootVolumeSize |
-The size of the root disk you want to attach to the instance, in GB. |
-Required with default |
-8 |
-Supports values between 8 and 1000. |
-
TerminationProtection |
-Enable instance termination protection. |
-Required with default |
-false |
-- |
IamRole |
-Specifies whether CloudFormation should create a new IAM role or use an existing one. |
-Required with default |
-New |
-Supported options are: New or Existing -See Control AWS Access and Permissions using Custom Permissions and Policies. |
-
IamRoleName |
-The name of the IAM role to assign to the instance, either an existing IAM role or a newly created IAM role. |
-Optional with default |
-workspaces-iam-role |
-If naming a new IAM role, CloudFormation requires the CAPABILITY_NAMED_IAM capability. -Leave this blank to use an autogenerated name. |
-
IamPermissionsBoundary |
-The ARN of the IAM permissions boundary to associate with the IAM role assigned to the instance. |
-Optional |
-- | - |
AvailabilityZone |
-The availability zone to which you want to deploy the instance. |
-Required |
-- | The value must match the subnet, the zone of any pre-existing volumes, and the instance type must be available in the selected zone. |
-
LoadBalancing |
-Specifies whether the instance is accessed via an NLB. |
-Required with default |
-NetworkLoadBalancer |
-Supported options are: NetworkLoadBalancer or None |
-
LoadBalancerScheme |
-If a load balancer is used, this field specifies whether the instance is accessible from the Internet or only from within the VPC. |
-Optional with default |
-Internet-facing |
-The DNS name of an Internet-facing load balancer is publicly resolvable to the public IP addresses of the nodes. Therefore, Internet-facing load balancers can route requests from clients over the Internet. The nodes of an internal load balancer have only private IP addresses. The DNS name of an internal load balancer is publicly resolvable to the personal IP addresses of the nodes. Therefore, internal load balancers can route requests from clients with access to the VPC for the load balancer. |
-
Private |
-Specifies whether the service is deployed in a private network without public IPs. |
-Required |
-false |
-- |
Session |
-Specifies whether you can use the AWS Session Manager to access the instance. |
-Required |
-false |
-- |
Vpc |
-The network to which you want to deploy the instance. |
-Required |
-- | - |
Subnet |
-The subnetwork to which you want to deploy the instance. |
-Required |
-- | The subnet must reside in the selected availability zone. |
-
KeyName |
-The public/private key pair which allows you to connect securely to your instance after it launches. When you create an AWS account, this is the key pair you create in your preferred region. |
-Optional |
-- | Leave this field blank if you do not want to include the SSH keys. |
-
AccessCIDR |
-The CIDR IP address range that is permitted to access the instance. |
-Optional |
-- | Teradata recommends setting this value to a trusted IP range. -Define at least one of AccessCIDR, PrefixList, or SecurityGroup to allow inbound traffic unless you create custom security group ingress rules. |
-
PrefixList |
-The prefix list that you can use to communicate with the instance. |
-Optional |
-- | Define at least one of AccessCIDR, PrefixList, or SecurityGroup to allow inbound traffic unless you create custom security group ingress rules. |
-
SecurityGroup |
-The virtual firewall that controls inbound and outbound traffic to the instance. |
-Optional |
-- | SecurityGroup is implemented as a set of rules that specify which protocols, ports, and IP addresses or CIDR blocks are allowed to access the instance. -Define at least one of AccessCIDR, PrefixList, or SecurityGroup to allow inbound traffic unless you create custom security group ingress rules. |
-
UsePersistentVolume |
-Specifies whether you want to use persistent volume to store data. |
-Optional with default |
-None |
-Supported options are: new persistent volume, an existing one, or none, depending on your use case. |
-
PersistentVolumeSize |
-The size of the persistent volume that you can attach to the instance, in GB. |
-Required with default |
-8 |
-Supports values between 8 and 1000 |
-
ExistingPersistentVolumeId |
-The ID of the existing persistent volume that you can attach to the instance. |
-Required if UsePersistentVolume is set to Existing |
-- | The persistent volume must be in the same availability zone as the workspace service instance. |
-
PersistentVolumeDeletionPolicy |
-The persistent volume behavior when you delete the CloudFormations deployment. |
-Required with default |
-Delete |
-Supported options are: Delete, Retain, RetainExceptOnCreate, and Snapshot. |
-
LatestAmiId |
-The ID of the image that points to the latest version of AMI. This value is used for the SSM lookup. |
-Required with defaults |
-- | This deployment uses the latest ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2 image available. -IMPORTANT: Changing this value may break the stack. |
-
Workspace service parameters
-| Parameter | -Description | -Required? | -Default | -Notes | -
|---|---|---|---|---|
WorkspacesHttpPort |
-The port to access the workspace service UI. |
-Required with default |
-3000 |
-- |
WorkspacesGrpcPort |
-The port to access the workspace service API. |
-Required with default |
-3282 |
-- |
WorkspacesVersion |
-The version of the workspace service you want to deploy. |
-Required with default |
-latest |
-The value is a container version tag, for example, latest. |
-
JupyterLab parameters
-| Parameter | -Description | -Required? | -Default | -Notes | -
|---|---|---|---|---|
JupyterHttpPort |
-The port to access the JupyterLab service UI |
-Required with default |
-8888 |
-- |
JupyterToken |
-The token or password used to access JupyterLab from the UI |
-Required |
-- | The token must begin with a letter and contain only alphanumeric characters. The allowed pattern is ^[a-zA-Z][a-zA-Z0-9-]*. |
-
JupyterVersion |
-The version of JupyterLab you want to deploy. |
-Required with default |
-latest |
-The value is a container version tag, for example, latest. |
-
| - - | --If the account deploying workspace service does not have sufficient IAM permissions to create IAM roles or IAM policies, contact your cloud administrator. - | -
On the Options page, you can specify tags (key-value pairs) for resources in your stack, set permissions, set stack failure options, and set advanced options. When you’re done, choose Next.
-On the Review page, review and confirm the template settings. Under Capabilities, select the check box to acknowledge that the template will create IAM resources.
-Choose Create to deploy the stack.
-Monitor the status of the stack. When the status is CREATE_COMPLETE, the Teradata AI Unlimited workspace service is ready.
Use the URLs displayed in the Outputs tab for the stack to view the created resources.
-| - - | --If you have only deployed the workspace service, you must deploy an interface before running your workload. To deploy the interface locally on Docker, see Deploy a Teradata AI Unlimited Interface Using Docker. You can also use the Jupyter Template to deploy a single instance with JupyterLab running in a container controlled by systemd. - | -
Teradata AI Unlimited is ready!
-Get started with Teradata AI Unlimited by running a simple workflow. See Run a Sample Workload in JupyterLab Using Teradata AI Unlimited.
-Want to learn more about Teradata AI Unlimited-AWS IAM roles and policies? See Control AWS Access and Permissions using Custom Permissions and Policies.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
You can deploy a stack using the aws cloudformation create-stack or aws cloudformation deploy commands from the AWS CLI. The example in this section uses the create-stack command. See AWS CLI Command Reference documentation for the syntax differences between the create-stack and deploy commands.
Install and configure AWS CLI. See Get started with the AWS CLI.
-Make sure you have:
-Required AWS credentials.
-Necessary IAM permissions to create and manage resources. If you do not have the necessary permissions, contact your organization administrator to create all the specified roles.
-Required parameter files and CloudFormation templates. You can download the files from the AI Unlimited GitHub repository.
-Run the following command on the AWS CLI:
-aws cloudformation create-stack --stack-name all-in-one \
- --template-body file://all-in-one.yaml \
- --parameters file://test_parameters/all-in-one.json \
- --tags Key=ThisIsAKey,Value=AndThisIsAValue \
- --capabilities CAPABILITY_IAM CAPABILITY_NAMED_IAMNOTE:
-CAPABILITY_IAM is required if IamRole is set to New.
-CAPABILITY_NAMED_IAM is required if IamRole is set to New and IamRoleName is given a value.
-To use an existing role, see Control AWS Access and Permissions using Permissions and Policies.
-Run the following command on the AWS CLI:
-aws cloudformation delete-stack --stack-name <stackname>Run the following command on the AWS CLI:
-aws cloudformation delete-stack --stack-name <stackname>
-aws cloudformation describe-stacks --stack-name <stackname>
-aws cloudformation describe-stack-events --stack-name <stackname>
-aws cloudformation describe-stack-instance --stack-name <stackname>
-aws cloudformation describe-stack-resource --stack-name <stackname>
-aws cloudformation describe-stack-resources --stack-name <stackname>Run the following command on the AWS CLI:
-aws cloudformation describe-stacks --stack-name <stackname> --query 'Stacks[0].Outputs' --output tableGet started with Teradata AI Unlimited by running a simple workflow. See Run a Sample Workload in JupyterLab Using Teradata AI Unlimited.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
Teradata AI Unlimited is a self-service, on-demand platform that enables you to deploy and connect an SQL engine to your data lake. You can then run your workloads on a scalable AI Unlimited compute engine deployed on your preferred Cloud Service Provider (CSP). Using the engine, you can leverage the capabilities of a highly parallel database while eliminating the need for data management.
-Teradata AI Unlimited consists of the following components:
-Workspace service: An orchestration service that controls and manages Teradata AI Unlimited automation and deployments. It also controls the integration elements that provide a seamless user experience when running data-related projects. Workspace service includes a web-based UI that you can use to authorize the user and define your choice of CSP integrations.
-Interface: An environment to write and run data projects, connect to the Teradata system, and visualize data. You can use either JupyterLab or Workspace Client (workspacectl).
-Engine: A fully managed computational resource that you can use to run your data science and analytical workloads.
-You can deploy Teradata AI Unlimited components using one of the following options:
-Workspace service and JupyterLab running locally on Docker
-Workspace service on your Virtual Private Cloud (VPC) and JupyterLab running locally on Docker
-Workspace service and JupyterLab on the same instance on your VPC
-Workspace service and JupyterLab behind a Network Load Balancer
-For development or testing environments, you can deploy workspace service and JupyterLab using Docker. See Deploy and Setup Teradata AI Unlimited Workspace Service Using Docker. If you’re an enterprise user with access to cloud infrastructure, you can deploy workspace service and JupyterLab on your VPC. See Deploy Teradata AI Unlimited Workspace Service and Interface using AWS CloudFormation Template and Deploy Teradata AI Unlimited using Azure (Coming Soon).
-Want to deploy Teradata AI Unlimited locally using Docker? See Deploy and Setup Teradata AI Unlimited Workspace Service Using Docker.
-Want to deploy Teradata AI Unlimited on AWS using CloudFormation Template? See Deploy Teradata AI Unlimited Workspace Service and Interface using AWS CloudFormation Template.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
This document outlines the steps for deploying and setting up a Teradata AI Unlimited interface using Docker. You can use JupyterLab or workspace client as your Teradata AI Unlimited interface.
-You can deploy JupyterLab using:
-For information about workspace client, see Use Teradata AI Unlimited With Workspace Client.
-Pull the Docker image from the DockerHub at https://hub.docker.com/r/teradata/ai-unlimited-jupyter.
-Run the Docker image once you’ve set the JUPYTER_HOME variable.
| - - | --Modify the directories based on your requirements. - | -
docker run -detach \
- --env “accept_license=Y” \
- --publish 8888:8888 \
- --volume ${JUPYTER_HOME}:/home/jovyan/JupyterLabRoot \
- teradata/ai-unlimited-jupyter:latestThe command downloads and starts a JupyterLab container and publishes the ports needed to access it. -Connect to JupyterLab using the URL: http://localhost:8888 and enter the token when prompted. For detailed instructions, see Teradata Vantage™ Modules for Jupyter Installation Guide or Use Vantage from a Jupyter Notebook.
-With Docker Compose, you can easily configure, install, and upgrade your Docker-based JupyterLab installation.
-Install Docker Compose. See https://docs.docker.com/compose/install/.
-Create a jupyter.yml file.
-version: "3.9"
-
-services:
- jupyter:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: jupyter
- image: ${JUPYTER_IMAGE_NAME:-teradata/ai-unlimited-jupyter}:${JUPYTER_IMAGE_TAG:-latest}
- environment:
- accept_license: "Y"
- ports:
- - 8888:8888
- volumes:
- - ${JUPYTER_HOME:-./volumes/jupyter}:/home/jovyan/JupyterLabRoot/userdata
- networks:
- - td-ai-unlimited
-
-networks:
- td-ai-unlimited:Go to the directory where the jupyter.yml file is located and start JupyterLab.
-docker compose -f jupyter.yml upOnce the JupyterLab server is initialized and started, you can connect to JupyterLab using the URL: http://localhost:8888 and enter the token when prompted. For detailed instructions, see Teradata Vantage™ Modules for Jupyter Installation Guide or Use Vantage from a Jupyter Notebook.
-Congrats! You’re all set up to use Teradata AI Unlimited.
-Get started with Teradata AI Unlimited by running a simple workflow. See Run a Sample Workload in JupyterLab Using Teradata AI Unlimited.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
This document outlines the steps for deploying and setting up Teradata AI Unlimited workspace service using Docker.
-You can install the workspace service using:
-To use Teradata AI Unlimited with the workspace client, see Use Teradata AI Unlimited With Workspace Client.
-Make sure you have the following:
-GitHub account: If you don’t already have a GitHub account, create one at https://github.com/.
-CSP account: You can host the engine on AWS or Azure.
-Sign up for an AWS Free Tier account at https://aws.amazon.com/free/. To set up AWS CLI, see https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html.
-Sign up for an Azure free account at https://azure.microsoft.com/en-us/free. Install Azure CLI and configure the credentials on the machine running workspace service. See https://learn.microsoft.com/en-us/cli/azure/get-started-with-azure-cli.
-Docker: To download and install Docker, see https://docs.docker.com/docker-for-windows/install/.
-The Docker image is a monolithic image of the workspace service running the necessary services in a single container.
-Pull the docker image from Docker Hub.
-docker pull teradata/ai-unlimited-workspacesBefore proceeding, make sure to:
-Copy and retain the CSP environment variables from your AWS Console.
-AWS: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_SESSION_TOKEN
Azure: ARM_SUBSCRIPTION_ID, ARM_CLIENT_ID, and ARM_CLIENT_SECRET
For information on obtaining environment variables using Azure CLI, see Azure Authentication.
-Set the environment variable, WORKSPACES_HOME, to the directory where the configuration and data files are located. Make sure that the directory exists, and that appropriate permission is granted. If you don’t set WORKSPACES_HOME, the default location is ./volumes/workspaces.
| Local Location | -Container Location | -Usage | -
|---|---|---|
$WORKSPACES_HOME |
-/etc/td |
-Stores data and configuration |
-
$WORKSPACES_HOME/tls |
-/etc/td/tls |
-Stores cert files |
-
Run the Docker image once you’ve set the WORKSPACES_HOME variable.
| - - | --Modify the directories based on your requirements. - | -
docker run -detach \
- --env accept_license="Y" \
- --env AWS_ACCESS_KEY_ID="${AWS_ACCESS_KEY_ID}" \
- --env AWS_SECRET_ACCESS_KEY="${AWS_SECRET_ACCESS_KEY}" \
- --env AWS_SESSION_TOKEN="${AWS_SESSION_TOKEN}" \
- --publish 3000:3000 \
- --publish 3282:3282 \
- --volume ${WORKSPACES_HOME}:/etc/td \
- teradata/ai-unlimited-workspaces:latest| - - | --For Azure, Teradata recommends deploying workspace service using Docker Compose. - | -
The command downloads and starts a workspace service container and publishes the ports needed to access it. Once the workspace service server is initialized and started, you can access it using the URL: http://<ip_or_hostname>:3000/.
-With Docker Compose, you can easily configure, install, and upgrade your Docker-based workspace service installation.
-Install Docker Compose. See https://docs.docker.com/compose/install/.
-Create a workspaces.yml file.
-| - - | --The following example uses a local volume to store your CSP credentials. You can create a separate YAML file containing CSP environment variables and run the Docker Compose file. For other options, see AI Unlimited GitHub: Install AI Unlimited Using Docker Compose. - | -
version: "3.9"
-
-services:
- workspaces:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: workspaces
- image: ${WORKSPACES_IMAGE_NAME:-teradata/ai-unlimited-workspaces}:${WORKSPACES_IMAGE_TAG:-latest}
- command: workspaces serve -v
- restart: unless-stopped
- ports:
- - "443:443/tcp"
- - "3000:3000/tcp"
- - "3282:3282/tcp"
- environment:
- accept_license: "Y"
- TZ: ${WS_TZ:-UTC}
- volumes:
- - ${WORKSPACES_HOME:-./volumes/workspaces}:/etc/td
- - ${WORKSPACES_AWS_CONFIG:-~/.aws}:/root/.aws
-
- networks:
- - td-ai-unlimitedversion: "3.9"
-
-services:
- workspaces:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: workspaces
- image: ${WORKSPACES_IMAGE_NAME:-teradata/ai-unlimited-workspaces}:${WORKSPACES_IMAGE_TAG:-latest}
- command: workspaces serve -v
- restart: unless-stopped
- ports:
- - "443:443/tcp"
- - "3000:3000/tcp"
- - "3282:3282/tcp"
- environment:
- accept_license: "Y"
- TZ: ${WS_TZ:-UTC}
- volumes:
- - ${WORKSPACES_HOME:-./volumes/workspaces}:/etc/td
- - ${WS_HOME:-~/.azure}:/root/.azure
-
- networks:
- - td-ai-unlimitedGo to the directory where the workspaces.yml file is located and start the workspace service.
-docker compose -f workspaces.yamlOnce the workspace service server is initialized and started, you can access it using the URL: http://<ip_or_hostname>:3000/.
-Workspace service uses the GitHub OAuth App to authorize users and manage the project state. To authorize the workspace service to save your project instance configuration, use the Client ID and Client secret key generated during the GitHub OAuth App registration. The project instance configuration values are maintained in your GitHub repositories and you can view them on the Workspace service Profile page.
-First-time users must complete the following steps before proceeding. If you are unsure about your VPC configuration or permissions, contact your organization administrator.
-Log on to your GitHub account and create an OAuth App. See GitHub Documentation.
-While registering the OAuth App, type the following workspace service URLs in the URL fields:
-Homepage URL: http://<ip_or_hostname>:3000/
-Authorization callback URL: http://<ip_or_hostname>:3000/auth/github/callback
-Copy and retain the Client ID and Client secret key.
-To set up the workspace service, do the following:
-Access workspace service using the URL: http://<ip_or_hostname>:3000/.
-
-Apply the following general service configuration under Setup.
-| Setting | -Description | -Required? | -
|---|---|---|
Service Base URL |
-[Non-Editable] The root URL of the service. |
-Yes |
-
Git Provider |
-The provider for Git integration. Currently, Teradata AI Unlimited supports GitHub and GitLab. |
-Yes |
-
Service Log Lev |
-The level of logging. |
-Yes |
-
Engine IP Network Type |
-The type of network assigned to an engine instance, which can be either public or private. Select the Private option if you’re deploying the engine in the same VPC as the workspace service. |
-Yes |
-
Use TLS |
-Indicates if TLS support is enabled. If your instance is only accessible from within a private network and to trusted users, you can ignore the default value. Teradata recommends enabling the TLS option for sensitive data, public networks, and compliance requirements. |
-Yes |
-
Service TLS Certification |
-The server certificate to authenticate the server identity. |
-No |
-
Service TLS Certificate Key |
-The server certificate key. |
-No |
-
To use a self-signed certificate for Service Base URL, select GENERATE TLS. A certificate and private key are generated and displayed in the respective fields.
-Select Save Changes.
-Apply the following settings under your choice of Cloud Integrations: CSP.
-| Setting | -Description | -Required? | -
|---|---|---|
Default Region |
-The region where you want to deploy the engine. Teradata recommends choosing the region closest to your primary work location. |
-Yes |
-
Default Subnet |
-The subnet that provides the engine instance with a route to an internet gateway. If you don’t specify a subnet, the engine is automatically associated with the default subnet. |
-Yes |
-
Default IAM Role |
-The default IAM identity that determines what a user can and cannot do in AWS. When a default IAM role is assigned to a user or resource, the user or resource automatically assumes the role and gains the permissions granted to the role. |
-No |
-
Resource Tag |
-The key-value pair applied to a resource to hold metadata about that resource. With a resource tag, you can quickly identify, organize, and manage the resources you use in your environment. |
-No |
-
Default CIDRs |
-The list of Classless Inter-Domain Routing (CIDR) addresses used for the engine. Use CIDR to allocate IP addresses flexibly and efficiently in your network. If you don’t specify a CIDR, the engine is automatically associated with the default CIDR. |
-No |
-
Default Security Groups |
-The list of security groups for the VPC in each region. If you don’t specify a security group, the engine is automatically associated with the default security group for the VPC. |
-No |
-
Role Prefix |
-The string of characters prepended to the name of a role. You can use a role prefix to organize and manage roles and to enforce naming conventions. |
-No |
-
Permission Boundary |
-The maximum permissions an IAM entity can have regardless of the permissions defined in the identity-based policy. You can define and manage the user permissions and roles and enforce compliance requirements. |
-No |
-
Select Save Changes.
-Apply the following settings under Git Integrations.
-| Setting | -Description | -Required? | -
|---|---|---|
GitHub Client ID |
-The Client ID you received from GitHub on creating your OAuth App. |
-Yes |
-
GitHub Client Secret |
-The Client secret ID you received from GitHub on creating your OAuth App. |
-Yes |
-
Auth Organization |
-The name of the GitHub organization account that you use to collaborate with your team. |
-No |
-
GitHub Base URL |
-The base URL of your GitHub account. The URL may vary based on your account type. For example, https://github.company.com/ for GitHub Enterprise account. |
-No |
-
Select Authenticate. You are redirected to GitHub.
-Log on with your GitHub credentials to authorize workspace service.
-After authentication, you are redirected to the Workspace service Profile page, and an API Key is generated. You can use the API Key to make requests to the workspace service.
-| - - | --A new API Key is generated each time you connect to workspace service. - | -
Teradata AI Unlimited workspace service is ready!
-Connect workspace service to a Teradata AI Unlimited Interface and deploy an engine. See Deploy a Teradata AI Unlimited Interface Using Docker.
-Interested in learning how Teradata AI Unlimited can help you with real-life use cases? Coming soon! Keep watching this space for the GitHub link.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
This document walks you through a simple workflow where you can use JupyterLab to:
-Deploy on-demand, scalable compute
-Connect to your external data source
-Run the workload
-Suspend the compute
-Deploy and configure Teradata AI Unlimited Workspaces and JupyterLab. See Deploy and Setup Teradata AI Unlimited Workspace Service Using Docker and Deploy a Teradata AI Unlimited Interface Using Docker.
-Copy and retain the following:
-CSP environment variables from your Console. See Environment Variables.
-API Key from workspace service.
-Run %help or %help <command> for details on any magic command. See Teradata AI Unlimited JupyterLab Magic Command Reference for more details.
Connect to JupyterLab using the URL: http://localhost:8888 and enter the token when prompted.
-Connect to the workspace service using the API Key.
-%workspaces_config host=<ip_or_hostname>, apikey=<API_Key>, withtls=FCreate a new project.
-| - - | --Currently, Teradata AI Unlimited supports AWS and Azure. - | -
%project_create project=<Project_Name>, env=<CSP>, team=<Project_Team>[Optional] Create an authorization object to store the CSP credentials.
-Replace ACCESS_KEY_ID, SECRET_ACCESS_KEY, and REGION with your values.
%project_auth_create name=<Auth_Name>, project=<Project_Name>, key=<ACCESS_KEY_ID>, secret=<SECRET_ACCESS_KEy>, region=<REGION>Deploy an engine for the project.
-Replace the <Project_Name> to a name of your choice. The size parameter value can be small, medium, large, or extralarge. The default size is small.
-%project_engine_deploy name=<Project_Name>, size=<Size_of_Engine>The deployment process takes a few minutes to complete. On successful deployment, a password is generated.
-Establish a connection to your project.
-%connect <Project_Name>When a connection is established, the interface prompts you for a password. Enter the password generated in the previous step.
-Run the sample workload.
-| - - | --Make sure that you do not have tables named SalesCenter or SalesDemo in the selected database. - | -
Create a table to store the sales center data.
-First, drop the table if it already exists. The command fails if the table does not exist.
-DROP TABLE SalesCenter;
-CREATE MULTISET TABLE SalesCenter ,NO FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO
- (
- Sales_Center_id INTEGER NOT NULL,
- Sales_Center_Name VARCHAR(255) CHARACTER SET LATIN NOT CASESPECIFIC)
-NO PRIMARY INDEX ;Load data into the SalesCenter table using the %dataload magic command.
%dataload DATABASE=<Project_Name>, TABLE=SalesCenter, FILEPATH=notebooks/sql/data/salescenter.csv| - - | --Unable to locate the salescenter.csv file? Download the file from GitHub Demo: Charting and Visualization Data. - | -
Verify that the data was inserted.
-SELECT * FROM SalesCenter ORDER BY 1Create a table with the sales demo data.
-DROP TABLE SalesDemo;
-CREATE MULTISET TABLE SalesDemo ,NO FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO
- (
- Sales_Center_ID INTEGER NOT NULL,
- UNITS DECIMAL(15,4),
- SALES DECIMAL(15,2),
- COST DECIMAL(15,2))
-NO PRIMARY INDEX ;Load data into the SalesDemo table using the %dataload magic command.
%dataload DATABASE=<Project_Name>, TABLE=SalesDemo, FILEPATH=notebooks/sql/data/salesdemo.csv| - - | --Unable to locate the salesdemo.csv file? Download the file from GitHub Demo: Charting and Visualization Data. - | -
Verify that the sales demo data was inserted successfully.
-SELECT * FROM SalesDemo ORDER BY salesOpen the Navigator for your connection and verify that the tables were created. Run a row count on the tables to verify that the data was loaded.
-Use charting magic to visualize the result.
-Provide X and Y axes for your chart.
-%chart sales_center_name, sales, title=Sales DataDrop the tables.
-DROP TABLE SalesCenter;
-DROP TABLE SalesDemo;Back up your project metadata and object definitions in your GitHub repository.
-%project_backup project=<Project_Name>Suspend the engine.
-%project_engine_suspend project=<Project_Name>Congrats! You’ve successfully run your first use case in JupyterLab.
-Interested in exploring advanced use cases? Coming soon! Keep watching this space for the GitHub link.
-Learn about the magic commands available in JupyterLab. See Teradata AI Unlimited JupyterLab Magic Command Reference.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This product is in preview and is subject to change. If you’re interested in learning more about this offering, contact Teradata Support. - | -
Workspace Client (workspacectl) is a command line interface (CLI) for Teradata AI Unlimited. This document provides step-by-step instructions to install workspacectl. In this document, you can find all the necessary information and guidance on the CLI commands, allowing you to navigate the command line quickly and efficiently. For the current release, you can only connect to the workspace service and manage the engine using workspacectl. Teradata recommends using JupyterLab as the Teradata AI Unlimited interface for data exploration.
-Make sure you have:
-Installed, configured, and set up workspace service using the steps outlined in Deploy and Setup Teradata AI Unlimited Workspace Service Using Docker.
-Copied and retained the AWS environment variables and API Key.
-Download the workspacectl executable file from https://downloads.teradata.com/download/tools/ai-unlimited-ctl.
-| - - | --Workspacectl supports all major operating systems. - | -
Open the terminal window and run the workspacectl file.
- -
-Configure workspace service using the API Key.
-workspacesctl workspaces configCreate a new project.
-workspacesctl project create <Project_Name> -e <CSP> --no-tlsDeploy an engine for the project.
-workspacesctl project engine deploy <Project_Name> -t <Size_of_Engine> --no-tlsRun a sample workload.
-Manage your project and engine.
-Backup your project.
-workspacesctl project backup <Project_Name> --no-tlsSuspend the engine.
-workspacesctl project engine suspend <Project_Name> --no-tlsFor a supported list of commands, see Workspaces CLI Reference.
-Description: One-time configuration to bind CLI with the workspace service. Go to the Workspace service Profile page and copy the API Key.
-Usage:
-workspacesctl workspaces configFlags:
--h, --help: List the details of the command.
Output:
-
-Follow the prompts to choose the workspace service endpoint and API Key.
-Description: View the list of users set up for Teradata AI Unlimited on GitHub.
-Usage:
-workspacesctl workspaces user list --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-
-Description: Create a project in Teradata AI Unlimited. The command also creates a corresponding GitHub repository for the project.
-Usage:
-workspacesctl project create <Project_Name> -e <CSP> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
-| Flag | -Type | -Description | -Required? | -
|---|---|---|---|
|
-String |
-The environment where the project engine is hosted. Values: aws, azure, or gcloud. Currently, Teradata AI Unlimited supports aws and azure. |
-Yes |
-
|
-String |
-The path to manifest the yaml file to be used for the input. |
-No |
-
|
-String |
-The team assigned to the project. |
-No |
-
|
-- | List the details of the command. |
-No |
-
Output:
-
-Description: View the list of all projects set up in Teradata AI Unlimited.
-Usage:
-workspacesctl project list --no-tlsor
-workspacesctl project list <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-
-Description: Delete a project in Teradata AI Unlimited.
-Usage:
- workspacesctl project delete <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-| - - | --The output is in YAML format. - | -
-Description: View the list of collaborators assigned to the project in GitHub.
-Usage:
-workspacesctl project user list <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-
-Description: Back up the engine object definitions to the GitHub repository assigned for the project.
-Usage:
-workspacesctl project backup <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-| - - | --The output is in YAML format. - | -
-Description: Restore all engine object definitions from the project GitHub repository.
-Usage:
-workspacesctl project restore <Project_Name> --no-tlsor
-workspacesctl project restore <Project_Name> --gitref <git_reference> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
-| Flag | -Type | -Description | -Required? | -
|---|---|---|---|
|
-String |
-Tag, SHA, or branch name. |
-No |
-
|
-- | List the details of the command. |
-No |
-
Output:
-| - - | --The output is in YAML format. - | -
-Description: Deploy an engine for the project.
-Usage:
-workspacesctl project engine deploy <Project_Name> -t small --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
-| Flag | -Type | -Description | -Required? | -
|---|---|---|---|
|
-Int |
-The number of engine nodes. The default value is 1. |
-No |
-
|
-String |
-The instance size of the engine. |
-No |
-
|
-String |
-The path to manifest the yaml file to use for the input. |
-No |
-
|
-String |
-The region for the deployment. |
-No |
-
|
-String |
-The subnet ID for the deployment. |
-No |
-
|
-- | List the details of the command. |
-No |
-
Description: Destroy the deployed engine and back up the object definitions created during the session.
-Usage:
-workspacesctl project engine suspend <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-| - - | --The output is in YAML format. - | -
-Description: View the detailed information about the engine for a project. The command displays the last state of the engine.
-Usage:
-workspacesctl project engine list <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-| - - | --The output is in YAML format. - | -
-Description: Create authorization for object store.
-Usage:
-workspacesctl project auth create <Project_Name> -n <Auth_Name> -a <Auth_Key> -s <Auth_Secret> -r <ObjectStore_Region> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
-| Flag | -Type | -Description | -Required? | -
|---|---|---|---|
|
-String |
-The authorization access key or ID. |
-Yes, if you’re not using the |
-
|
-String |
-The authorization name for the object store. |
-Yes, if you’re not using the |
-
|
-String |
-The path to manifest the yaml file to use for the input. |
-No |
-
|
-String |
-The region of the object store. |
-Yes |
-
-s, --secret string |
-String |
-The authorization secret access key of the object store. |
-Yes, if you’re not using the |
-
|
-- | List the details of the command. |
-No |
-
Output:
-| - - | --The output is in YAML format. - | -
-Description: List object store authorizations that are created for a project.
-Usage:
-workspacesctl project auth list <Project_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
--h, --help: List the details of the command.
Output:
-| - - | --The output is in YAML format. - | -
-Description: Delete object store authorizations that are created for a project.
-Usage:
-workspacesctl project auth delete <Project_Name> -n <Auth_Name> --no-tls| - - | -
-If your setup includes TLS configuration, you need not add the -no-tls parameter.
- |
-
Flags:
-| Flag | -Type | -Description | -Required? | -
|---|---|---|---|
|
-String |
-Name of the object store authorization to delete. |
-Yes |
-
|
-- | List the details of the command. |
-No |
-
Output:
-| - - | --The output is in YAML format. - | -
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This tutorial demonstrates how to use airflow with Teradata Vantage. Airflow will be installed on Ubuntu System.
-Ubuntu 22.x
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Python 3.8, 3.9, 3.10 or 3.11 installed.
-pip
-Set the AIRFLOW_HOME environment variable. Airflow requires a home directory and uses ~/airflow by default, but you can set a different location if you prefer. The AIRFLOW_HOME environment variable is used to inform Airflow of the desired location.
-export AIRFLOW_HOME=~/airflowInstall apache-airflow stable version 2.8.1 from PyPI repository.:
AIRFLOW_VERSION=2.8.2
-PYTHON_VERSION="$(python --version | cut -d " " -f 2 | cut -d "." -f 1-2)"
-CONSTRAINT_URL="https://raw.githubusercontent.com/apache/airflow/constraints-${AIRFLOW_VERSION}/constraints-${PYTHON_VERSION}.txt"
-pip install "apache-airflow==${AIRFLOW_VERSION}" --constraint "${CONSTRAINT_URL}"Install the Airflow Teradata provider stable version from PyPI repository.
-pip install "apache-airflow-providers-teradata"| - - | --For security reasons, the test connection functionality is disabled by default across Airflow UI, API and CLI. -The availability of the functionality can be controlled by the test_connection flag in the core section of the Airflow configuration ($AIRFLOW_HOME/airflow.cfg) or Define below environment variable before starting airflow server. -export AIRFLOWCORETEST_CONNECTION=Enabled - | -
Run Airflow Standalone
-airflow standaloneAccess the Airflow UI. Visit https://localhost:8080 in the browser and log in with the admin account details shown in the terminal.
-Teradata Connections may be defined in Airflow in the following ways:
-Using Airflow Web UI
-Using Environment Variable
-Open the Admin → Connections section of the UI. Click the Create link to create a new connection.
-
-Fill in input details in New Connection Page.
-
-Connection Id: Unique ID of Teradata Connection.
-Connection Type: Type of the system. Select Teradata.
-Database Server URL (required): Teradata instance hostname to connect to.
-Database (optional): Specify the name of the database to connect to
-Login (required): Specify the user name to connect.
-Password (required): Specify the password to connect.
-Click on Test and Save.
-Airflow connections may be defined in environment variables in either of one below formats.
-JSON format
-URI format
-| - - | --The naming convention is AIRFLOW_CONN_{CONN_ID}, all uppercase (note the single underscores surrounding CONN). -So if your connection id is teradata_conn_id then the variable name should be AIRFLOW_CONN_TERADATA_CONN_ID - | -
export AIRFLOW_CONN_TERADATA_CONN_ID='{
- "conn_type": "teradata",
- "login": "teradata_user",
- "password": "my-password",
- "host": "my-host",
- "schema": "my-schema",
- "extra": {
- "tmode": "TERA",
- "sslmode": "verify-ca"
- }
-}'export AIRFLOW_CONN_TERADATA_CONN_ID='teradata://teradata_user:my-password@my-host/my-schema?tmode=TERA&sslmode=verify-ca'Refer Teradata Hook for detailed information on Teradata Connection in Airflow.
-In Airflow, DAGs are defined as Python code.
-Create a DAG as a python file like sample.py under DAG_FOLDER - $AIRFLOW_HOME/files/dags directory.
-from datetime import datetime
-from airflow import DAG
-from airflow.providers.teradata.operators.teradata import TeradataOperator
-CONN_ID = "Teradata_TestConn"
-with DAG(
- dag_id="example_teradata_operator",
- max_active_runs=1,
- max_active_tasks=3,
- catchup=False,
- start_date=datetime(2023, 1, 1),
-) as dag:
- create = TeradataOperator(
- task_id="table_create",
- conn_id=CONN_ID,
- sql="""
- CREATE TABLE my_users,
- FALLBACK (
- user_id decimal(10,0) NOT NULL GENERATED ALWAYS AS IDENTITY (
- START WITH 1
- INCREMENT BY 1
- MINVALUE 1
- MAXVALUE 2147483647
- NO CYCLE),
- user_name VARCHAR(30)
- ) PRIMARY INDEX (user_id);
- """,
- )Airflow loads DAGs from Python source files, which it looks for inside its configured DAG_FOLDER - $AIRFLOW_HOME/files/dags directory.
-DAGs will run in one of two ways:
-1. When they are triggered either manually or via the API
-2. On a defined schedule, which is defined as part of the DAG
-example_teradata_operator is defined to trigger as manually. To define a schedule, any valid Crontab schedule value can be passed to the schedule argument.
with DAG(
- dag_id="my_daily_dag",
- schedule="0 0 * * *"
- ) as dag:This tutorial demonstrated how to use Airflow and the Airflow Teradata provider with a Teradata Vantage instance. The example DAG provided creates my_users table in the Teradata Vantage instance defined in Connection UI.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This guide includes content from both Microsoft and Teradata product documentation. - | -
This article describes the process to connect your Power BI Desktop to Teradata Vantage for creating reports and dramatic visualizations of your data. Power BI supports Teradata Vantage as a data source and can use the underlying data just like any other data source in Power BI Desktop.
-Power BI is a collection of software services, applications, and connectors that work together to turn your unrelated sources of data into coherent, visually immersive, and interactive insights.
-A Windows desktop application, called Power BI Desktop
-An online SaaS (Software as a Service) service, called the Power BI service
-Power BI mobile apps for Windows, iOS, and Android devices
-
-These three elements—Power BI Desktop, the Power BI service, and the mobile apps—are designed to let people create, share, and consume business insights in the way that serves them, or their role, most effectively.
-
-A fourth element, Power BI Report Server, allows you to publish Power BI reports to an on-premises report server, after creating them in Power BI Desktop.
-Power BI Desktop supports Vantage as a 3rd party data source not as a ‘native’ data source. Instead, published reports on Power BI service will need to use the on-premises data gateway component to access Vantage.
-This getting started guide will show you how to connect to a Teradata Vantage. Power BI Desktop Teradata connector uses the .NET Data Provider for Teradata. You need to install the driver on computers that use the Power BI Desktop. The .NET Data Provider for Teradata single installation supports both 32-bit or 64-bit Power BI Desktop application.
-You are expected to be familiar with Azure services, Teradata Vantage, and Power BI Desktop.
-You will need the following accounts and system.
-The Power BI Desktop is a free application for Windows. (Power BI Desktop is not available for Macs. You could run it in a virtual machine, such as Parallels or VMware Fusion, or in Apple’s Boot Camp, but that is beyond the scope of this article.)
-A Teradata Vantage instance with a user and password. The user must have permission to data that can be used by Power BI Desktop. Vantage must be accessible from Power BI Desktop.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
You can install Power BI Desktop from the Microsoft Store or download the installer and run it directly.
-Download and install the latest version of the .NET Data Provider for Teradata.
-Note that there are multiple files available for download. You want the file that starts with “tdnetdp”.
-Run Power BI Desktop, which has a yellow icon.
-
-If the opening (splash) screen is showing, click on Get data.
-
-Otherwise, if you are in the main form of Power BI, ensure that you are on the Home ribbon and click on Get data. Click on More….
-
-Click on Database on the left.
-Scroll the list on the right until you see Teradata database. Click on Teradata database, and then click on the Connect button.
-(“Teradata database” and “Teradata Vantage” are synonymous in this article.)
-
-In the window that appears, enter the name or IP address of your Vantage system into the text box. You can choose to Import data directly into Power BI data model, or connect directly to the data source using DirectQuery and click OK.
-
-(Click Advanced options to submit hand-crafted SQL statement.)
-For credentials, you have the option of connecting with your Windows login or Database username defined in Vantage, which is more common. Select the appropriate authentication method and enter in your username and password. Click Connect.
-You also have the option of authenticating with an LDAP server. This option is hidden by default.
-If you set the environment variable, PBI_EnableTeradataLdap, to true, then the LDAP authentication method will become available.
-
-Do note that LDAP is not supported with the on-premises data gateway, which is used for reports that are published to the Power BI service. If you need LDAP authentication and are using the on-premises data gateway, you will need to submit an incident to Microsoft and request support.
-Alternatively, you can configure Kerberos-based SSO from Power BI service to on-premise data sources like Teradata.
-Once you have connected to the Vantage system, Power BI Desktop remembers the credentials for future connections to the system. You can modify these credentials by going to File > Options and settings > Data source settings.
-The Navigator window appears after a successful connection. It displays the data available on the Vantage system. You can select one or more elements to use in Power BI Desktop.
-
-You preview a table by clicking on its name. If you want to load it into Power BI Desktop, ensure that you click the checkbox next to the table name.
-You can Load the selected table, which brings it into Power BI Desktop. You can also Edit the query, which opens a query editor so you can filter and refine the set of data you want to load.
-Edit may be called Transform data, depending upon the version of Power BI Desktop that you have.
-For information on joining tables, see Create and Manage Relationships in Power BI Desktop feature.
-To publish your report, click Publish on Home ribbon in Power BI Desktop.
-
-Power BI Desktop will prompt you to save your report. Choose My workspace and click Select.
-
-Once report has been published, click Got it to close. You may also click the link, which has the report name in the link.
-
-This is an example of a report created in Power BI Desktop.
-
-You can combine data from many sources with Power BI Desktop. Look at the following links for more information.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This article describes the process to share an Azure Blob Storage dataset from one user to another using Azure Data Share service and then query it with Teradata Vantage leveraging Native Object Store (NOS) capability. We will create and use a storage account and data share account for both users.
-This is a diagram of the workflow.
-
Azure Data Share enables organizations to simply and securely share data with multiple customers and partners. Both the data provider and data consumer must have an Azure subscription to share and receive data. Azure Data Share currently offers snapshot-based sharing and in-place sharing. Today, Azure Data Share supported data stores include Azure Blob Storage, Azure Data Lake Storage Gen1 and Gen2, Azure SQL Database, Azure Synapse Analytics and Azure Data Explorer. Once a dataset share has been sent using Azure Data Share, the data consumer is able to receive that data in a data store of their choice like Azure Blob Storage and then use Teradata Vantage to explore and analyze the data.
-For more information see documentation.
-Vantage is the modern cloud platform that unifies data warehouses, data lakes, and analytics into a single connected ecosystem.
-Vantage combines descriptive, predictive, prescriptive analytics, autonomous decision-making, ML functions, and visualization tools into a unified, integrated platform that uncovers real-time business intelligence at scale, no matter where the data resides.
-Vantage enables companies to start small and elastically scale compute or storage, paying only for what they use, harnessing low-cost object stores and integrating their analytic workloads.
-Vantage supports R, Python, Teradata Studio, and any other SQL-based tools. You can deploy Vantage across public clouds, on-premises, on optimized or commodity infrastructure, or as-a-service.
-Teradata Vantage Native Object Store (NOS) can be used to explore data in external object stores, like Azure Blob Storage, using standard SQL. No special object storage-side compute infrastructure is required to use NOS. You can explore data located in an Blob Storage container by simply creating a NOS table definition that points to your container. With NOS, you can quickly import data from Blob Storage or even join it other tables in the database.
-Alternatively, the Teradata Parallel Transporter (TPT) utility can be used to import data from Blob Storage to Teradata Vantage in bulk fashion. Once loaded, data can be efficiently queried within Vantage.
-For more information see documentation.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
An Azure account. You can start with a free account.
-An Azure Blob Storage account to store the dataset
-Once you have met the prerequisites, follow these steps:
-Create a Azure Blob Storage account and container
-Create a Data Share Account
-Create a share
-Accept and receive data using Data Share
-Configure NOS access to Blob Storage
-Query the dataset in Blob Storage
-Load data from Blob Storage into Vantage (optional)
-Open the Azure portal in a browser (Chrome, Firefox, and Safari work well) and follow the steps in create a storage account in a resource group called myProviderStorage_rg in this article.
-Enter a storage name and connectivity method. We will use myproviderstorage and public endpoint in this article.
-| - - | --We suggest that you use the same location for all services you create. - | -
Select Review + create, then Create.
-Go to resource and click Containers to create container.
-Click the + Container button.
-Enter a container name. We will use providerdata in this article.
-
Click Create.
-We will create a Data Share account for the provider sharing the dataset.
-Follow the Create an Azure Data Share Account steps to create resource in a resource group called myDataShareProvider_rg in this article.
-In Basics tab, enter a data share account name. We will use mydatashareprovider in this article.
-
| - - | --We suggest that you use the same location for all services you create. - | -
Select Review + create, then Create.
-When the deployment is complete, select Go to resource.
-Navigate to your Data Share Overview page and follow the steps in Create a share.
-Select Start sharing your data.
-Select + Create.
-In Details tab, enter a share name and share type. We will use WeatherData and Snapshot in this article.
-
| - - | -
- Snapshot share
-
-
-Choose snapshot sharing to provide copy of the data to the recipient. -
-
-Supported data store: Azure Blob Storage, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, Azure SQL Database, Azure Synapse Analytics (formerly SQL DW) - |
-
| - - | -
- In-place share
-
-
-Choose in-place sharing to provide access to data at its source. -
-
-Supported data store: Azure Data Explorer - |
-
Click Continue.
-In Datasets tab, click Add datasets
-Select Azure Blob Storage
-
Click Next.
-Enter Storage account providing the dataset. We will use myproviderstorage in this article.
-
Click Next.
-Double-click container to choose the dataset. We will use providerdata and onpoint_history_postal-code_hour.csv file in this article.
-
Figure 6 Select Storage container and dataset
-| - - | --Azure Data Share can share at the folder and file level. Use Azure Blob Storage resource to upload a file. - | -
Click Next.
-Enter a Dataset name that the consumer will see for the folder and dataset. We will use the default names but delete the providerdata folder this article. Click Add datasets.
-
Click Add datasets.
-
Click Continue.
-In Recipients tab, click Add recipient email address to send share notification.
-Enter email address for consumer.
-
| - - | --Set Share expiration for amount of time share is valid for consumer to accept. - | -
Click Continue.
-In Settings tab, set Snapshot schedule. We use default unchecked this article.
-
Click Continue.
-In Review + Create tab, click Create.
-
Your Azure Data Share has now been created and the recipient of your Data Share is now ready to accept your invitation.
-
In this article, the recipient/consumer is going to receive the data into their Azure Blob storage account.
-Similar to the Data Share Provider, ensure that all pre-requisites are complete for the Consumer before accepting a data share invitation.
-Azure Subscription: If you don’t have one, create a https://azure.microsoft.com/free/[free account] before you begin.
-Azure Blob Storage account and container: create resource group called myConsumerStorage_rg and create account name myconsumerstorage and container consumerdata.
-Azure Data Share account: create resource group called myDataShareConsumer_rg and create a data share account name called mydatashareconsumer to accept the data.
-Follow the steps in Accept and receive data using Azure Data Share.
-In your email, an invitation from Microsoft Azure with a subject titled "Azure Data Share invitation from yourdataprovider@domain.com. Click on the View invitation to see your invitation in Azure.
-
This action opens your browser to the list of Data Share invitations.
-
Select the share you would like to view. We will select WeatherData in this article.
-Under Target Data Share Account, select the Subscription and Resource Group that you would like to deployed your Data Share into or you can create a new Data Share here.
-| - - | --f provider required a Terms of Use acceptance, a dialog box would appear and you’ll be required to check the box to indicate you agree to the terms of use. - | -
Enter the Resource group and Data share account. We will use myDataShareConsumer_rg and mydatashareconsumer account this article.
-
Select Accept and configure and a share subscription will be created.
-Select Datasets tab. Check the box next to the dataset you’d like to assign a destination to. Select + Map to target to choose a target data store.
-
Select a target data store type and path that you’d like the data to land in. We will use consumers Azure Blob Storage account myconsumerstorage and container consumerdata for our snapshot example in this article.
-| - - | --Azure Data Share provides open and flexible data sharing, including the ability to share from and to different data stores. Check supported data sources that can accept snapshot and in place sharing. - | -
Click on Map to target.
-Once mapping is complete, for snapshot-based sharing click on Details tab and click Trigger snapshot for Full or Incremental. We will select full copy since this is your first time receiving data from your provider.
-
When the last run status is successful, go to target data store to view the received data. Select Datasets, and click on the link in the Target Path.
-
Native Object Store (NOS) can directly read data in Azure Blob Storage, which allows you to explore and analyze data in Blob Storage without explicitly loading the data.
-A foreign table definition allows data in Blob Storage to be easily referenced within the Advanced SQL Engine and makes the data available in a structured, relational format.
-| - - | --NOS supports data in CSV, JSON, and Parquet formats. - | -
Login to your Vantage system with Teradata Studio.
-Create an AUTHORIZATION object to access your Blob Storage container with the following SQL command.
-CREATE AUTHORIZATION DefAuth_AZ
-AS DEFINER TRUSTED
-USER 'myconsumerstorage' /* Storage Account Name */
-PASSWORD '*****************' /* Storage Account Access Key or SAS Token */Replace the string for USER with your Storage Account Name.
-Replace the string for PASSWORD with your Storage Account Access Key or SAS Token.
-Create a foreign table definition for the CSV file on Blob Storage with the following SQL command.
-CREATE MULTISET FOREIGN TABLE WeatherData,
-EXTERNAL SECURITY DEFINER TRUSTED DefAuth_AZ (
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC,
- Payload DATASET INLINE LENGTH 64000 STORAGE FORMAT CSV
-)
-USING (
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata/')
-)| - - | --At a minimum, the foreign table definition must include a table name (WeatherData) and a location clause, which points to the object store data. - | -
The LOCATION requires a storage account name and container name. You will need to replace this with your own storage account and container name.
-If the object doesn’t have a standard extension (e.g. “.json”, “.csv”, “.parquet”), then the Location…Payload columns definition phrase is also needed, and the LOCATION phase need to include the file name. For example: LOCATION (AZ/<storage account name>.blob.core.windows.net/<container>/<filename>).
Foreign tables are always defined as No Primary Index (NoPI) tables.
-Run the following SQL command to query the dataset.
-SELECT * FROM WeatherData SAMPLE 10;The foreign table only contains two columns: Location and Payload. Location is the address in the object store system. The data itself is represented in the payload column, with the payload value within each record in the foreign table representing a single CSV row.
-
Run the following SQL command to focus on the data in the object.
-SELECT payload..* FROM WeatherData SAMPLE 10;
Views can simplify the names associated with the payload attributes, can make it easier to code SQL against the object data, and can hide the Location references in the foreign table.
-| - - | -
-Vantage foreign tables use the .. (double dot or double period) operator to separate the object name from the column name.
- |
-
Run the following SQL command to create a view.
-REPLACE VIEW WeatherData_view AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL(4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM WeatherData
-)Run the following SQL command to validate the view.
-SELECT * FROM WeatherData_view SAMPLE 10;
Now that you have created a view, you can easily reference the object store data in a query and combine it with other tables, both relational tables in Vantage as well as foreign tables in an object store. This allows you to leverage the full analytic capabilities of Vantage on 100% of the data, no matter where the data is located.
-Having a persistent copy of the Blob Storage data can be useful when repetitive access of the same data is expected. NOS does not automatically make a persistent copy of the Blob Storage data. Each time you reference a foreign table, Vantage will fetch the data from Blob Storage. (Some data may be cached, but this depends on the size of the data in Blob Storage and other active workloads in Vantage.)
-In addition, you may be charged network fees for data transferred from Blob Storage. If you will be referencing the data in Blob Storage multiple times, you may reduce your cost by loading it into Vantage, even temporarily.
-You can select among the approaches below to load the data into Vantage.
-You can use a single statement to both create the table and load the data. You can choose the desired attributes from the foreign table payload and what they will be called in the relational table.
-A CREATE TABLE AS … WITH DATA statement can be used with the foreign table definition as the source table.
-Run the following SQL command to create the relational table and load the data.
-CREATE MULTISET TABLE WeatherData_temp AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL(4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- WeatherData
- WHERE
- Postal_Code = '36101'
-)
-WITH DATA
-NO PRIMARY INDEXRun the following SQL command to validate the contents of the table.
-SELECT * FROM WeatherData_temp SAMPLE 10;
You can also use multiple statements to first create the relational table and then load the data. An advantage of this choice is that you can perform multiple loads, possibly selecting different data or loading in smaller increments if the object is very large.
-Run the following SQL command to create the relational table.
-CREATE MULTISET TABLE WeatherData_temp (
- Postal_code VARCHAR(10),
- Country CHAR(2),
- Time_Valid_UTC TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS',
- DOY_UTC INTEGER,
- Hour_UTC INTEGER,
- Time_Valid_LCL TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS',
- DST_Offset_Minutes INTEGER,
- Temperature_Air_2M_F DECIMAL(4,1),
- Temperature_Wetbulb_2M_F DECIMAL(3,1),
- Temperature_Dewpoint_2M_F DECIMAL(3,1),
- Temperature_Feelslike_2M_F DECIMAL(4,1),
- Temperature_Windchill_2M_F DECIMAL(4,1),
- Temperature_Heatindex_2M_F DECIMAL(4,1),
- Humidity_Relative_2M_Pct DECIMAL(3,1),
- Humdity_Specific_2M_GPKG DECIMAL(3,1),
- Pressure_2M_Mb DECIMAL(5,1),
- Pressure_Tendency_2M_Mb DECIMAL(2,1),
- Pressure_Mean_Sea_Level_Mb DECIMAL(5,1),
- Wind_Speed_10M_MPH DECIMAL(3,1),
- Wind_Direction_10M_Deg DECIMAL(4,1),
- Wind_Speed_80M_MPH DECIMAL(3,1),
- Wind_Direction_80M_Deg DECIMAL(4,1),
- Wind_Speed_100M_MPH DECIMAL(3,1),
- Wind_Direction_100M_Deg DECIMAL(4,1),
- Precipitation_in DECIMAL(3,2),
- Snowfall_in DECIMAL(3,2),
- Cloud_Cover_Pct INTEGER,
- Radiation_Solar_Total_WPM2 DECIMAL(5,1)
-)
-UNIQUE PRIMARY INDEX ( Postal_Code, Time_Valid_UTC )Run the following SQL to load the data into the table.
-INSERT INTO WeatherData_temp
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL (4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- WeatherData
- WHERE
- Postal_Code = '30301'Run the following SQL command to validate the contents of the table.
-SELECT * FROM WeatherData_temp SAMPLE 10;
An alternative to defining a foreign table is to use the READ_NOS table operator. This table operator allows you to access data directly from an object store without first creating a foreign table, or to view a list of the keys associated with all the objects specified by a Location clause.
You can use the READ_NOS table operator to explore the data in an object.
Run the following command to explore the data in an object.
- -The LOCATION requires a storage account name and container name. This is highlighted above in yellow. You will need to replace this with your own storage account and container name.
-Replace the string for ACCESS_ID with your Storage Account Name.
-Replace the string for ACCES_KEY with your Storage Account Access Key or SAS Token
-
You can also leverage the READ_NOS table operator to get the length (size) of the object.
-Run the following SQL command to view the size of the object.
-SELECT
- location(CHAR(120)), ObjectLength
-FROM
- READ_NOS (
- ON (SELECT CAST( NULL AS DATASET STORAGE FORMAT CSV))
- USING
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata')
- ACCESS_ID('myconsumerstorage')
- ACCESS_KEY('*****')
- RETURNTYPE('NOSREAD_KEYS')
- ) AS THE_TABLE
-ORDER BY 1Replace the values for LOCATION, ACCESS_ID, and ACCESS_KEY.
-
You can substitute the NOS_READ table operator for a foreign table definition in the above section for loading the data into a relational table.
-CREATE MULTISET TABLE WeatherData_temp AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL (4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- READ_NOS (
- ON (SELECT CAST( NULL AS DATASET STORAGE FORMAT CSV))
- USING
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata')
- ACCESS_ID('myconsumerstorage')
- ACCESS_KEY('*****')
- ) AS THE_TABLE
- WHERE
- Postal_Code = '36101'
-)
-WITH DATA| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This quickstart details the process of ingesting and cataloging data from Teradata Vantage to Amazon S3 with AWS Glue.
-| - - | --For ingesting data to Amazon S3 when cataloging is not a requirement consider Teradata Write NOS capabilities. - | -
Access to an Amazon AWS account
-Access to a Teradata Vantage instance
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
A database client to send queries for loading the test data
-In your favorite database client run the following queries
-CREATE DATABASE teddy_retailers_inventory
-AS PERMANENT = 110e6;
-
-CREATE TABLE teddy_retailers_inventory.source_catalog AS
-(
- SELECT product_id, product_name, product_category, price_cents
- FROM (
- LOCATION='/s3/dev-rel-demos.s3.amazonaws.com/demo-datamesh/source_products.csv') as products
-) WITH DATA;
-
-CREATE TABLE teddy_retailers_inventory.source_stock AS
-(
- SELECT entry_id, product_id, product_quantity, purchase_price_cents, entry_date
- FROM (
- LOCATION='/s3/dev-rel-demos.s3.amazonaws.com/demo-datamesh/source_stock.csv') as stock
-) WITH DATA;In this section, we will cover in detail each of the steps below:
-Create an Amazon S3 bucket to ingest data
-Create an AWS Glue Catalog Database for storing metadata
-Store Teradata Vantage credentials in AWS Secrets Manager
-Create an AWS Glue Service Role to assign to ETL jobs
-Create a connection to a Teradata Vantage Instance in AWS Glue
-Create an AWS Glue Job
-Draft a script for automated ingestion and cataloging of Teradata Vantage data into Amazon S3
-In Amazon S3, select Create bucket.
-Assign a name to your bucket and take note of it.
-
-Leave all settings at their default values.
-Click on Create bucket.
-In AWS Glue, select Data catalog, Databases.
-Click on Add database.
-Define a database name and click on Create database.
-In AWS Secrets Manager, select Create new secret.
-The secret should be an Other type of secret with the following keys and values according to your Teradata Vantage Instance:
USER
-PASSWORD
-| - - | --In the case of ClearScape Analytics Experience, the user is always "demo_user," and the password is the one you defined when creating your ClearScape Analytics Experience environment. - | -
-Assign a name to the secret.
-The rest of the steps can be left with the default values.
-Create the secret.
-The role you create should have access to the typical permissions of a Glue Service Role, but also access to read the secret and S3 bucket you’ve created.
-In AWS, go to the IAM service.
-Under Access Management, select Roles.
In roles, click on Create role.
-In select trusted entity, select AWS service and pick Glue from the dropdown.
-In add permissions:
-Search for AWSGlueServiceRole.
Click the related checkbox.
-Search for SecretsManagerReadWrite.
Click the related checkbox.
-In Name, review, and create:
-Define a name for your role.
-
-Click on Create role.
Return to Access Management, Roles, and search for the role you’ve just created.
-Select your role.
-Click on Add permissions, then Create inline policy.
Click on JSON.
In the Policy editor, paste the JSON object below, substituting the name of the bucket you’ve created.
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Sid": "FullAccessToSpecificBucket",
- "Effect": "Allow",
- "Action": "s3:*",
- "Resource": [1
- "arn:aws:s3:::<bucket-name>",
- "arn:aws:s3:::<bucket-name>/*"
- ]
- }
- ]
-}
-Click Next.
-Assign a name to your policy.
-Click on Create policy.
In AWS Glue, select Data connections.
-Under Connectors, select Create connection.
Search for and select the Teradata Vantage data source.
-
-In the dialog box, enter the URL of your Teradata Vantage instance in JDBC format.
-| - - | -
-In the case of ClearScape Analytics Experience, the URL follows the following structure:
-jdbc:teradata://<URL Host>/DATABASE=demo_user,DBS_PORT=1025
- |
-
Select the AWS Secret created in the previous step.
-Name your connection and finish the creation process.
-
-In AWS Glue, select ETL Jobs and click on Script editor.
-Select Spark as the engine and choose to start fresh.
-Copy the following script into the editor.
-The script requires the following modifications:
-Substitute the name of your S3 bucket.
-Substitute the name of your Glue catalog database.
-If you are not following the example in the guide, modify the database name and the tables to be ingested and cataloged.
-For cataloging purposes, only the first row of each table is ingested in the example. This query can be modified to ingest the whole table or to filter selected rows.
-# Import section
-import sys
-from awsglue.transforms import *
-from awsglue.utils import getResolvedOptions
-from pyspark.context import SparkContext
-from awsglue.context import GlueContext
-from awsglue.job import Job
-from pyspark.sql import SQLContext
-
-# PySpark Config Section
-args = getResolvedOptions(sys.argv, ["JOB_NAME"])
-sc = SparkContext()
-glueContext = GlueContext(sc)
-spark = glueContext.spark_session
-job = Job(glueContext)
-job.init(args["JOB_NAME"], args)
-
-#ETL Job Parameters Section
-# Source database
-database_name = "teddy_retailers_inventory"
-
-# Source tables
-table_names = ["source_catalog","source_stock"]
-
-# Target S3 Bucket
-target_s3_bucket = "s3://<your-bucket-name>"
-
-#Target catalog database
-catalog_database_name = "<your-catalog-database-name>"
-
-
-# Job function abstraction
-def process_table(table_name, transformation_ctx_prefix, catalog_database, catalog_table_name):
- dynamic_frame = glueContext.create_dynamic_frame.from_options(
- connection_type="teradata",
- connection_options={
- "dbtable": table_name,
- "connectionName": "Teradata connection default",
- "query": f"SELECT TOP 1 * FROM {table_name}", # This line can be modified to ingest the full table or rows that fulfill an specific condition
- },
- transformation_ctx=transformation_ctx_prefix + "_read",
- )
-
- s3_sink = glueContext.getSink(
- path=target_s3_bucket,
- connection_type="s3",
- updateBehavior="UPDATE_IN_DATABASE",
- partitionKeys=[],
- compression="snappy",
- enableUpdateCatalog=True,
- transformation_ctx=transformation_ctx_prefix + "_s3",
- )
- # Dynamically set catalog table name based on function parameter
- s3_sink.setCatalogInfo(
- catalogDatabase=catalog_database, catalogTableName=catalog_table_name
- )
- s3_sink.setFormat("csv")
- s3_sink.writeFrame(dynamic_frame)
-
-
-# Job execution section
-for table_name in table_names:
- full_table_name = f"{database_name}.{table_name}"
- transformation_ctx_prefix = f"{database_name}_{table_name}"
- catalog_table_name = f"{table_name}_catalog"
- # Call your process_table function for each table
- process_table(full_table_name, transformation_ctx_prefix, catalog_database_name, catalog_table_name)
-
-job.commit()Assign a name to your script
-
-In Job details, Basic properties:
-Select the IAM role you created for the ETL job.
-For testing, select "2" as the Requested number of workers, this is the minimum allowed.
-
-In Advanced properties, Connections select your connection to Teradata Vantage.
| - - | --The connection created must be referenced twice, once in the job configuration, once in the script itself. - | -
-Click on Save.
Click on Run.
The ETL job takes a couple of minutes to complete, most of this time is related to starting the Spark cluster.
-After the job is finished:
-Go to Data Catalog, Databases.
-Click on the catalog database you created.
-In this location, you will see the tables extracted and cataloged through your Glue ETL job.
-
-All tables ingested are also present as compressed files in S3. Rarely, these files would be queried directly. Services such as AWS Athena can be used to query the files relying on the catalog metadata.
-In this quick start, we learned how to ingest and catalog data in Teradata Vantage to Amazon S3 with AWS Glue Scripts.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This how-to shows you how to add Teradata Extensions to a Jupyter Notebooks environment. A hosted version of Jupyter Notebooks integrated with Teradata Extensions and analytics tools is available for functional testing for free at https://clearscape.teradata.com. - | -
Teradata Jupyter extensions provide Teradata SQL kernel and several UI extensions to allow users to easily access and navigate Teradata database from Jupyter envioronment. Google Vertex AI is Google Cloud’s new unified ML platform. Vertex AI Workbench provides a Jupyter-base development environment for the entire data science workflow. This article describes how to integate our Jupyter extensions with Vertex AI Workbench so that Vertex AI users can take advantage of our Teradata extensions in their ML pipeline.
-Vertex AI workbench supports two types of notebooks: managed notebooks and user-managed notebooks. Here we will focus on user-managed notebooks. We will show two ways to integrate our Jupyter extensions with user-managed notebooks: use startup script to install our kernel and extensions or use custom container.
-Access to a Teradata Vantage instance
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Google Cloud account with Vertex AI enabled
-Google cloud storage to store startup scripts and Teradata Jupyter extension package
-There are two ways to run Teradata Jupyter Extensions in Vertex AI:
-These two integration methods are described below.
-When we create a new notebook instance, we can specify a startup script. This script runs only once after the instance is created. Here are the steps:
-Download Teradata Jupyter extensions package
-Go to Vantage Modules for Jupyter page to download the Teradata Jupyter extensions package bundle Linux version.
-Upload the package to a Google Cloud storage bucket
-Write a startup script and upload it to cloud storage bucket
-Below is a sample script. It fetches Teradata Jupyter extension package from cloud storage bucket and installs Teradata SQL kernel and extensions.
-#! /bin/bash
-
-cd /home/jupyter
-mkdir teradata
-cd teradata
-gsutil cp gs://teradata-jupyter/* .
-unzip teradatasql*.zip
-
-# Install Teradata kernel
-cp teradatakernel /usr/local/bin
-
-jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-# Install Teradata extensions
-pip install --find-links . teradata_preferences_prebuilt
-pip install --find-links . teradata_connection_manager_prebuilt
-pip install --find-links . teradata_sqlhighlighter_prebuilt
-pip install --find-links . teradata_resultset_renderer_prebuilt
-pip install --find-links . teradata_database_explorer_prebuilt
-
-# PIP install the Teradata Python library
-pip install teradataml
-
-# Install Teradata R library (optional, uncomment this line only if you use an environment that supports R)
-#Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"Create a new notebook and add the startup script from cloud storage bucket
-
It may take a few minutes for the notebook creation process to complete. When it is done, click on Open notebook.
Another option is to provide a custom container when creating a notebook.
-Download Teradata Jupyter extensions package
-Go to Vantage Modules for Jupyter page to download the Teradata Jupyter extensions package bundle Linux version.
-Copy this package to your work directory and unzip it
-Build custom Docker image
-The custom container must expose a service on port 8080. It is recommended to create a container derived from a Google Deep Learning Containers image, because those images are already configured to be compatible with user-managed notebooks.
-Below is a sample Dockerfile you can use to build a Docker image with Teradata SQL kernel and extensions installed:
-# Use one of the deep learning images as base image
-# if you need both Python and R, use one of the R images
-FROM gcr.io/deeplearning-platform-release/r-cpu:latest
-
-USER root
-
-##############################################################
-# Install kernel and copy supporting files
-##############################################################
-
-# Copy the kernel
-COPY ./teradatakernel /usr/local/bin
-
-RUN chmod 755 /usr/local/bin/teradatakernel
-
-# Copy directory with kernel.json file into image
-COPY ./teradatasql teradatasql/
-
-# Copy notebooks and licenses
-COPY ./notebooks/ /home/jupyter
-COPY ./license.txt /home/jupyter
-COPY ./ThirdPartyLicenses/ /home/jupyter
-
-# Install the kernel file to /opt/conda jupyter lab instance
-RUN jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-##############################################################
-# Install Teradata extensions
-##############################################################
-
-RUN pip install --find-links . teradata_preferences_prebuilt && \
- pip install --find-links . teradata_connection_manager_prebuilt && \
- pip install --find-links . teradata_sqlhighlighter_prebuilt && \
- pip install --find-links . teradata_resultset_renderer_prebuilt && \
- pip install --find-links . teradata_database_explorer_prebuilt
-
-# Give back ownership of /opt/conda to jovyan
-RUN chown -R jupyter:users /opt/conda
-
-# PIP install the Teradata Python libraries
-RUN pip install teradataml
-
-# Install Teradata R library (optional, include it only if you use a base image that supports R)
-RUN Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"In your work directory (where you unzipped Teradata Jupyter extensions package), run docker build to build the image:
docker build -f Dockerfile imagename:imagetag .Push the docker image to Google container registry or artifact registry
-Please refer to the following documentations to push docker image to registry:
-Create a new notebook
-In Environment section, set custom container field to the location of your newly created custom container:
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --This how-to shows you how to add Teradata Extensions to a Jupyter Notebooks environment. A hosted version of Jupyter Notebooks integrated with Teradata Extensions and analytics tools is available for functional testing for free at https://clearscape.teradata.com. - | -
Teradata Jupyter extensions provide Teradata SQL kernel and several UI extensions to allow users to easily access and navigate Teradata database from Jupyter envioronment. This article describes how to integate our Jupyter extensions with SageMaker notebook instance.
-Access to a Teradata Vantage instance
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
AWS account
-AWS S3 bucket to store lifecycle configuration scripts and Teradata Jupyter extension package
-SageMaker supports customization of notebook instances using lifecycle configuration scripts. Below we will demo how to use lifecycle configuration scripts to install our Jupyter kernel and extensions in a notebook instance.
-Download Teradata Jupyter extensions package
-Download Linux version from https://downloads.teradata.com/download/tools/vantage-modules-for-jupyter and upload it to an S3 bucket. This zipped package contains Teradata Jupyter kernel and extensions. Each extension has 2 files, the one with "_prebuilt" in the name is prebuilt extension which can be installed using PIP, the other one is source extension that needs to be installed using "jupyter labextension". It is recommended to use prebuilt extensions.
-Create a lifecycle configuration for notebook instance
-
Here are sample scripts that fetches the Teradata package from S3 bucket and installs Jupyter kernel and extensions. Note that on-create.sh creates a custom conda env that persists on notebook instance’s EBS volume so that the installation will not get lost after notebook restarts. on-start.sh installs Teradata kernel and extensions to the custom conda env.
-on-create.sh
-#!/bin/bash
-
-set -e
-
-# This script installs a custom, persistent installation of conda on the Notebook Instance's EBS volume, and ensures
-# that these custom environments are available as kernels in Jupyter.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-# Install a separate conda installation via Miniconda
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-mkdir -p "$WORKING_DIR"
-wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
-bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda"
-rm -rf "$WORKING_DIR/miniconda.sh"
-# Create a custom conda environment
-source "$WORKING_DIR/miniconda/bin/activate"
-KERNEL_NAME="teradatasql"
-
-PYTHON="3.8"
-conda create --yes --name "$KERNEL_NAME" python="$PYTHON"
-conda activate "$KERNEL_NAME"
-pip install --quiet ipykernel
-
-EOFon-start.sh
-#!/bin/bash
-
-set -e
-
-# This script installs Teradata Jupyter kernel and extensions.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-
-source "$WORKING_DIR/miniconda/bin/activate" teradatasql
-
-# fetch Teradata Jupyter extensions package from S3 and unzip it
-mkdir -p "$WORKING_DIR/teradata"
-aws s3 cp s3://sagemaker-teradata-bucket/teradatasqllinux_3.3.0-ec06172022.zip "$WORKING_DIR/teradata"
-cd "$WORKING_DIR/teradata"
-
-unzip -o teradatasqllinux_3.3.0-ec06172022.zip
-
-# install Teradata kernel
-cp teradatakernel /home/ec2-user/anaconda3/condabin
-jupyter kernelspec install --user ./teradatasql
-
-# install Teradata Jupyter extensions
-source /home/ec2-user/anaconda3/bin/activate JupyterSystemEnv
-
-pip install teradata_connection_manager_prebuilt-3.3.0.tar.gz
-pip install teradata_database_explorer_prebuilt-3.3.0.tar.gz
-pip install teradata_preferences_prebuilt-3.3.0.tar.gz
-pip install teradata_resultset_renderer_prebuilt-3.3.0.tar.gz
-pip install teradata_sqlhighlighter_prebuilt-3.3.0.tar.gz
-
-conda deactivate
-EOFCreate a notebook instance. Please select 'Amazon Linux 2, Jupyter Lab3' for Platform identifier and select the lifecycle configuration created in step 2 for Lifecycle configuration.
-
You might also need to add vpc, subnet and security group in 'Network' section to gain access to Teradata databases.
-Wait until notebook instance Status turns 'InService', click 'Open JupyterLab' to open the notebook.
-
Access the demo notebooks to get usage tips
-+
-
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This how-to describes the process to migrate data between Salesforce and Teradata Vantage. It contains two use cases:
-Retrieve customer information from Salesforce, and combine it with order and shipping information from Vantage to derive analytical insights.
-Update newleads table on Vantage with the Salesforce data, then add the new lead(s) back to Salesforce using AppFlow.
Amazon AppFlow transfers the customer account data from Salesforce to Amazon S3. Vantage then uses Native Object Store (NOS) read functionality to join the data in Amazon S3 with data in Vantage with a single query.
-The account information is used to update the newleads table on Vantage. Once the table is updated, Vantage writes it back to the Amazon S3 bucket with NOS Write. A Lambda function is triggered upon arrival of the new lead data file to convert the data file from Parquet format to CSV format, and AppFlow then inserts the new lead(s) back into Salesforce.
Amazon AppFlow is a fully managed integration service that enables users to securely transfer data between Software-as-a-Service (SaaS) applications like Salesforce, Marketo, Slack, and ServiceNow, and AWS services like Amazon S3 and Amazon Redshift. AppFlow automatically encrypts data in motion, and allows users to restrict data from flowing over the public internet for SaaS applications that are integrated with AWS PrivateLink, reducing exposure to security threats.
-As of today, Amazon AppFlow has 16 sources to choose from, and can send the data to four destinations.
-Teradata Vantage is the connected multi-cloud data platform for enterprise analytics, solving data challenges from start to scale.
-Vantage enables companies to start small and elastically scale compute or storage, paying only for what they use, harnessing low-cost object stores and integrating their analytic workloads. Vantage supports R, Python, Teradata Studio, and any other SQL-based tools.
-Vantage combines descriptive, predictive, prescriptive analytics, autonomous decision-making, ML functions, and visualization tools into a unified, integrated platform that uncovers real-time business intelligence at scale, no matter where the data resides.
-Teradata Vantage Native Object Store (NOS) can be used to explore data in external object stores, like Amazon S3, using standard SQL. No special object storage-side compute infrastructure is required to use NOS. Users can explore data located in an Amazon S3 bucket by simply creating a NOS table definition that points to your bucket. With NOS, you can quickly import data from Amazon S3 or even join it with other tables in the Vantage database.
-You are expected to be familiar with Amazon AppFlow service and Teradata Vantage.
-You will need the following accounts, and systems:
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
An AWS account with the role that can create and run flows.
-An Amazon S3 bucket to store Salesforce data (i.e., ptctsoutput)
-An Amazon S3 bucket to store raw Vantage data (Parquet file) (i.e., vantageparquet). This bucket needs to have policy to allow Amazon AppFlow access
-An Amazon S3 bucket to store converted Vantage data (CSV file) (i.e., vantagecsv)
-A Salesforce account that satisfies the following requirements:
-Your Salesforce account must be enabled for API access. API access is enabled by default for Enterprise, Unlimited, Developer, and Performance editions.
-Your Salesforce account must allow you to install connected apps. If this is disabled, contact your Salesforce administrator. After you create a Salesforce connection in Amazon AppFlow, verify that the connected app named "Amazon AppFlow Embedded Login App" is installed in your Salesforce account.
-The refresh token policy for the "Amazon AppFlow Embedded Login App" must be set to "Refresh token is valid until revoked". Otherwise, your flows will fail when your refresh token expires.
-You must enable Change Data Capture in Salesforce to use event-driven flow triggers. From Setup, enter "Change Data Capture" in Quick Find.
-If your Salesforce app enforces IP address restrictions, you must whitelist the addresses used by Amazon AppFlow. For more information, see https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html[AWS IP address ranges] in the Amazon Web Services General Reference.
-If you are transferring over 1 million Salesforce records, you cannot choose any Salesforce compound field. Amazon AppFlow uses Salesforce Bulk APIs for the transfer, which does not allow transfer of compound fields.
-To create private connections using AWS PrivateLink, you must enable both "Manager Metadata" and "Manage External Connections" user permissions in your Salesforce account. Private connections are currently available in the us-east-1 and us-west-2 AWS Regions.
-Some Salesforce objects can’t be updated, such as history objects. For these objects, Amazon AppFlow does not support incremental export (the "Transfer new data only" option) for schedule-triggered flows. Instead, you can choose the "Transfer all data" option and then select the appropriate filter to limit the records you transfer.
-Once you have met the prerequisites, follow these steps:
-Create a Salesforce to Amazon S3 Flow
-Exploring Data using NOS
-Export Vantage Data to Amazon S3 using NOS
-Create an Amazon S3 to Salesforce Flow
-This step creates a flow using Amazon AppFlow. For this example, we’re using a Salesforce developer account to connect to Salesforce.
-Go to AppFlow console, sign in with your AWS login credentials and click Create flow. Make sure you are in the right region, and the bucket is created to store Salesforce data.
-
This step provides basic information for your flow.
-Fill in Flow name (i.e. salesforce) and Flow description (optional), leave Customize encryption settings (advanced) unchecked. Click Next.
-This step provides information about the source and destination for your flow. For this example, we will be using Salesforce as the source, and Amazon S3 as the destination.
-For Source name, choose Salesforce, then Create new connection for Choose Salesforce connection.
-
Use default for Salesforce environment and Data encryption. Give your connection a name (i.e. salesforce) and click Continue.
-
At the salesforce login window, enter your Username and Password. Click Log In
-
Click Allow to allow AppFlow to access your salesforce data and information.
-
Back at the AppFlow Configure flow window, use Salesforce objects, and choose Account to be the Salesforce object.
-
Use Amazon S3 as Destination name. Pick the bucket you created earlier where you want the data to be stored (i.e., ptctsoutput).
-
Flow trigger is Run on demand. Click Next.
-
This step determines how data is transferred from the source to the destination.
-Use Manually map fields as Mapping method
-For simplicity, choose Map all fields directly for Source to destination filed mapping.
-
Once you click on "Map all fields directly", all the fields will show under Mapped fields. Click on the checkbox for the field(s) you want to Add formula (concatenates), Modify values (mask or truncate field values), or Remove selected mappings.
-For this example, no checkbox will be ticked.
-For Validations, add in a condition to ignore the record that contains no "Billing Address" (optional). Click Next.
-
You can specify a filter to determine which records to transfer. For this example, add a condition to filter out the records that are deleted (optional). Click Next.
-
Review all the information you just entered. Modify if necessary. Click Create flow.
-A message of successful flow creation will be displayed with the flow information once the flow is created,
-
Click Run flow on the upper right corner.
-Upon completion of the flow run, message will be displayed to indicate a successful run.
-Message example:
-
Click the link to the bucket to view data. Salesforce data will be in JSON format.
-By default, Salesforce data is encrypted. We need to remove the encryption for NOS to access it.
-Click on the data file in your Amazon S3 bucket, then click the Properties tab.
-
Click on the AWS-KMS from Encryption and change it from AWS-KMS encryption to None. Click Save.
-
Native Object Store has built in functionalities to explore and analyze data in Amazon S3. This section lists a few commonly used functions of NOS.
-Foreign table allows the external data to be easily referenced within the Vantage Advanced SQL Engine and makes the data available in a structured relational format.
-To create a foreign table, first login to Teradata Vantage system with your credentials. Create AUTHORIZATION object with access keys for Amazon S3 bucket access. Authorization object enhances security by establishing control over who is allowed to use a foreign table to access Amazon S3 data.
-CREATE AUTHORIZATION DefAuth_S3
-AS DEFINER TRUSTED
-USER 'A*****************' /* AccessKeyId */
-PASSWORD '********'; /* SecretAccessKey */"USER" is the AccessKeyId for your AWS account, and "PASSWORD" is the SecretAccessKey.
-Create a foreign table against the JSON file on Amazon S3 using following command.
-CREATE MULTISET FOREIGN TABLE salesforce,
-EXTERNAL SECURITY DEFINER TRUSTED DefAuth_S3
-(
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC,
- Payload JSON(8388096) INLINE LENGTH 32000 CHARACTER SET UNICODE
-)
-USING
-(
- LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
-);At a minimum, the foreign table definition must include a table name and location clause (highlighted in yellow) which points to the object store data. The Location requires a top-level single name, referred to as a "bucket" in Amazon.
-If the file name doesn’t have standard extension (.json, .csv, .parquet) at the end, the Location and Payload columns definition is also required (highlighted in turquoise) to indicate the type of the data file.
-Foreign tables are always defined as No Primary Index (NoPI) tables.
-Once foreign table’s created, you can query the content of the Amazon S3 data set by doing "Select" on the foreign table.
-SELECT * FROM salesforce;
-SELECT payload.* FROM salesforce;The foreign table only contains two columns: Location and Payload. Location is the address in the object store system. The data itself is represented in the payload column, with the payload value within each record in the foreign table representing a single JSON object and all its name-value pairs.
-Sample output from "SELECT * FROM salesforce;".
-
Sample output form "SELECT payload.* FROM salesforce;".
-
JSON data may contain different attributes in different records. To determine the full list of possible attributes in a data store, use JSON_KEYS:
-|SELECT DISTINCT * FROM JSON_KEYS (ON (SELECT payload FROM salesforce)) AS j;Partial Output:
-
Views can simplify the names associated with the payload attributes, make it easier to code executable SQL against object store data, and hide the Location references in the foreign table to make it look like normal columns.
-Following is a sample create view statement with the attributes discovered from the JSON_KEYS table operator above.
-REPLACE VIEW salesforceView AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS VARCHAR(10)) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.LastActivityDate AS VARCHAR(50)) Last_Activity_Date
- FROM salesforce
-);SELECT * FROM salesforceView;Partial output:
-
READ_NOS table operator can be used to sample and explore a percent of the data without having first defined a foreign table, or to view a list of the keys associated with all the objects specified by a Location clause.
-SELECT top 5 payload.*
-FROM READ_NOS (
- ON (SELECT CAST(NULL AS JSON CHARACTER SET Unicode))
-USING
-LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
- ACCESS_ID ('A**********') /* AccessKeyId */
- ACCESS_KEY ('***********') /* SecretAccessKey */
- ) AS D
-GROUP BY 1;Output:
-
Foreign table can be joined with a table(s) in Vantage for further analysis. For example, ordering and shipping information are in Vantage in these three tables – Orders, Order_Items and Shipping_Address.
-DDL for Orders:
-CREATE TABLE Orders (
- Order_ID INT NOT NULL,
- Customer_ID VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC,
- Order_Status INT,
- -- Order status: 1 = Pending; 2 = Processing; 3 = Rejected; 4 = Completed
- Order_Date DATE NOT NULL,
- Required_Date DATE NOT NULL,
- Shipped_Date DATE,
- Store_ID INT NOT NULL,
- Staff_ID INT NOT NULL
-) Primary Index (Order_ID);DDL for Order_Items:
-CREATE TABLE Order_Items(
- Order_ID INT NOT NULL,
- Item_ID INT,
- Product_ID INT NOT NULL,
- Quantity INT NOT NULL,
- List_Price DECIMAL (10, 2) NOT NULL,
- Discount DECIMAL (4, 2) NOT NULL DEFAULT 0
-) Primary Index (Order_ID, Item_ID);DDL for Shipping_Address:
-CREATE TABLE Shipping_Address (
- Customer_ID VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC NOT NULL,
- Street VARCHAR(100) CHARACTER SET LATIN CASESPECIFIC,
- City VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC,
- State VARCHAR(15) CHARACTER SET LATIN CASESPECIFIC,
- Postal_Code VARCHAR(10) CHARACTER SET LATIN CASESPECIFIC,
- Country VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC
-) Primary Index (Customer_ID);And the tables have following data:
-Orders:
-
Order_Items:
-
Shipping_Address:
-
By joining the salesforce foreign table to the established database table Orders, Order_Items and Shipping_Address, we can retrieve customer’s order information with customer’s shipping information.
-SELECT
- s.payload.Id as Customer_ID,
- s.payload."Name" as Customer_Name,
- s.payload.AccountNumber as Acct_Number,
- o.Order_ID as Order_ID,
- o.Order_Status as Order_Status,
- o.Order_Date as Order_Date,
- oi.Item_ID as Item_ID,
- oi.Product_ID as Product_ID,
- sa.Street as Shipping_Street,
- sa.City as Shipping_City,
- sa.State as Shipping_State,
- sa.Postal_Code as Shipping_Postal_Code,
- sa.Country as Shipping_Country
-FROM
- salesforce s, Orders o, Order_Items oi, Shipping_Address sa
-WHERE
- s.payload.Id = o.Customer_ID
- AND o.Customer_ID = sa.Customer_ID
- AND o.Order_ID = oi.Order_ID
-ORDER BY 1;Results:
-
Having a persistent copy of the Amazon S3 data can be useful when repetitive access of the same data is expected. NOS foreign table does not automatically make a persistent copy of the Amazon S3 data. A few approaches to capture the data in the database are described below:
-A "CREATE TABLE AS … WITH DATA" statement can be used with the foreign table definition acting as the source table. Use this approach you can selectively choose which attributes within the foreign table payload that you want to include in the target table, and what the relational table columns will be named.
-CREATE TABLE salesforceVantage AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM salesforce)
-WITH DATA
-NO PRIMARY INDEX;SELECT* * FROM salesforceVantage; partial results:
An alternative to using foreign table is to use the READ_NOS table operator. This table operator allows you to access data directly from an object store without first building a foreign table. Combining READ_NOS with a CREATE TABLE AS clause to build a persistent version of the data in the database.
-CREATE TABLE salesforceReadNOS AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM READ_NOS (
- ON (SELECT CAST(NULL AS JSON CHARACTER SET Unicode))
- USING
- LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
- ACCESS_ID ('A**********') /* AccessKeyId */
- ACCESS_KEY ('***********') /* SecretAccessKey */
- ) AS D
-) WITH DATA;Results from the salesforceReadNOS table:
SELECT * FROM salesforceReadNOS;
Another way of placing Amazon S3 data into a relational table is by "INSERT SELECT". Using this approach, the foreign table is the source table, while a newly created permanent table is the table to be inserted into. Contrary to the READ_NOS example above, this approach does require the permanent table be created beforehand.
-One advantage of the INSERT SELECT method is that you can change the target table’s attributes. For example, you can specify that the target table be MULTISET or not, or you can choose a different primary index.
CREATE TABLE salesforcePerm, FALLBACK ,
-NO BEFORE JOURNAL,
-NO AFTER JOURNAL,
-CHECKSUM = DEFAULT,
-DEFAULT MERGEBLOCKRATIO,
-MAP = TD_MAP1
-(
- Customer_Id VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- Acct_Number VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Street VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_City VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_State VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Post_Code VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Country VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Phone VARCHAR(15) CHARACTER SET LATIN NOT CASESPECIFIC,
- Fax VARCHAR(15) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Street VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_City VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_State VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Post_Code VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Country VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Industry VARCHAR(50) CHARACTER SET LATIN NOT CASESPECIFIC,
- Description VARCHAR(200) CHARACTER SET LATIN NOT CASESPECIFIC,
- Num_Of_Employee INT,
- Priority VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Rating VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- SLA VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Type VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Website VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- Annual_Revenue VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Last_Activity_Date DATE
-) PRIMARY INDEX (Customer_ID);INSERT INTO salesforcePerm
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM salesforce;SELECT * FROM salesforcePerm;Sample results:
-
I have a newleads table with 1 row in it on Vantage system.
Note there’s no address information for this lead. Let’s use the account information retrieved from Salesforce to update newleads table
UPDATE nl
-FROM
- newleads AS nl,
- salesforceReadNOS AS srn
-SET
- Street = srn.Billing_Street,
- City = srn.Billing_City,
- State = srn.Billing_State,
- Post_Code = srn.Billing_Post_Code,
- Country = srn.Billing_Country
- WHERE Account_ID = srn.Acct_Number;Now the new lead has address information.
-
Write the new lead information into S3 bucket using WRITE_NOS.
-SELECT * FROM WRITE_NOS (
-ON (
- SELECT
- Account_ID,
- Last_Name,
- First_Name,
- Company,
- Cust_Title,
- Email,
- Status,
- Owner_ID,
- Street,
- City,
- State,
- Post_Code,
- Country
- FROM newleads
-)
-USING
- LOCATION ('/s3/vantageparquet.s3.amazonaws.com/')
- AUTHORIZATION ('{"Access_ID":"A*****","Access_Key":"*****"}')
- COMPRESSION ('SNAPPY')
- NAMING ('DISCRETE')
- INCLUDE_ORDERING ('FALSE')
- STOREDAS ('CSV')
-) AS d;Where Access_ID is the AccessKeyID, and Access_Key is the SecretAccessKey to the bucket.
-Repeat Step 1 to create a flow using Amazon S3 as source and Salesforce as destination.
-This step provides basic information for your flow.
-Fill in Flow name (i.e., vantage2sf) and Flow description (optional), leave Customize encryption settings (advanced) unchecked. Click Next.
-This step provides information about the source and destination for your flow. For this example, we will be using Amazon S3 as the source, and Salesforce as the destination.
-For Source details, choose Amazon S3, then choose the bucket where you wrote your CSV file to (i.e. vantagecsv)
-For Destination details, choose Salesforce, use the connection you created in Step 1 from the drop-down list for Choose Salesforce connection, and Lead as Choose Salesforce object.
-For Error handling, use the default Stop the current flow run.
-Flow trigger is Run on demand. Click Next.
-This step determines how data is transferred from the source to the destination.
-Use Manually map fields as Mapping method
-Use Insert new records (default) as Destination record preference
-For Source to destination filed mapping, use the following mapping
-
Click Next.
-You can specify a filter to determine which records to transfer. For this example, no filter is added. Click Next.
-Once you are done with the Salesforce data, to avoid incurring charges to your AWS account (i.e., AppFlow, Amazon S3, Vantage and VM) for the resources used, follow these steps:
-AppFlow:
-Delete the "Connections" you created for the flow
-Delete the flows
-Amazon S3 bucket and file:
-Go to the Amazon S3 buckets where the Vantage data file is stored, and delete the file(s)
-If there are no need to keep the buckets, delete the buckets
-Teradata Vantage Instance
-Stop/Terminate the instance if no longer needed
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This article describes the process to connect Teradata Vantage with Google Cloud Data Catalog using the Data Catalog Teradata Connector on GitHub, and then explore the metadata of the Vantage tables via Data Catalog.
-
Scrape: Connect to Teradata Vantage and retrieve all the available metadata
-Prepare: Transform metadata in Data Catalog entities and create Tags
-Ingest: Send the Data Catalog entities to the Google Cloud project
-Google Cloud Data Catalog is a fully managed data discovery and metadata management service. Data Catalog can catalog the native metadata on data assets. Data Catalog is serverless, and provides a central catalog to capture both technical metadata as well as business metadata in a structured format.
-Vantage is the modern cloud platform that unifies data warehouses, data lakes, and analytics into a single connected ecosystem.
-Vantage combines descriptive, predictive, prescriptive analytics, autonomous decision-making, ML functions, and visualization tools into a unified, integrated platform that uncovers real-time business intelligence at scale, no matter where the data resides.
-Vantage enables companies to start small and elastically scale compute or storage, paying only for what they use, harnessing low-cost object stores and integrating their analytic workloads.
-Vantage supports R, Python, Teradata Studio, and any other SQL-based tools. You can deploy Vantage across public clouds, on-premises, on optimized or commodity infrastructure, or as-a-service.
-See the documentation for more information on Teradata Vantage.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
A Google Service Account with Data Catalog Admin role
-A Cloud Console Project created for your account (i.e. partner-integration-lab)
-Billing enabled
-Google Cloud SDK installed and initialized
-Python installed
-Pip installed
-Enable Data Catalog APIs
-Install Teradata Data Catalog Connector
-Run
-Explore Teradata Vantage metadata with Data Catalog
-Logon to Google console, choose APIs & Services from the Navigation menu, then click on Library. Make sure your project is selected on the top menu bar.
-
Put Data Catalog in the search box and click on Google Cloud Data Catalog API, click ENABLE
-
A Teradata Data Catalog connector is available on GitHub. This connector is written in Python.
-Run following command to authorize gcloud to access the Cloud Platform with Google user credentials.
-
gcloud auth loginChoose your Google account when the Google login page opens up and click Allow on the next page.
-Next, set up default project if you haven’t already done so
-gcloud config set project <project id>We recommend you install the Teradata Data Catalog Connector in an isolated Python environment. To do so, install virtualenv first:
-Run in Powershell as Administrator:
-pip install virtualenv
-virtualenv --python python3.6 <your-env>
-<your-env>\Scripts\activatepip install virtualenv
-virtualenv --python python3.6 <your-env>
-source <your-env>/bin/activatepip install virtualenv
-virtualenv --python python3.6 <your-env>
-source <your-env>/bin/activateexport GOOGLE_APPLICATION_CREDENTIALS=<google_credentials_file>
-export TERADATA2DC_DATACATALOG_PROJECT_ID=<google_cloud_project_id>
-export TERADATA2DC_DATACATALOG_LOCATION_ID=<google_cloud_location_id>
-export TERADATA2DC_TERADATA_SERVER=<teradata_server>
-export TERADATA2DC_TERADATA_USERNAME=<teradata_username>
-export TERADATA2DC_TERADATA_PASSWORD=<teradata_password>Where <google_credential_file> is the key for your service account (json file).
Execute google-datacatalog-teradata-connector command to establish entry point to Vantage database.
google-datacatalog-teradata-connector \
- --datacatalog-project-id=$TERADATA2DC_DATACATALOG_PROJECT_ID \
- --datacatalog-location-id=$TERADATA2DC_DATACATALOG_LOCATION_ID \
- --teradata-host=$TERADATA2DC_TERADATA_SERVER \
- --teradata-user=$TERADATA2DC_TERADATA_USERNAME \
- --teradata-pass=$TERADATA2DC_TERADATA_PASSWORDSample output from the google-datacatalog-teradata-connector command:
-INFO:root: -==============Starting CLI=============== -INFO:root:This SQL connector does not implement the user defined datacatalog-entry-resource-url-prefix -INFO:root:This SQL connector uses the default entry resoure URL - -============Start teradata-to-datacatalog=========== - -==============Scrape metadata=============== -INFO:root:Scrapping metadata from connection_args - -1 table containers ready to be ingested... - -==============Prepare metadata=============== - ---> database: Gcpuser -37 tables ready to be ingested... - -==============Ingest metadata=============== - -DEBUG:google.auth._default:Checking /Users/Teradata/Apps/Cloud/GCP/teradata2dc-credentials.json for explicit credentials as part of auth process... -INFO:root:Starting to clean up the catalog... -DEBUG:google.auth.transport.requests:Making request: POST https://oauth2.googleapis.com/token -DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): oauth2.googleapis.com:443 -DEBUG:urllib3.connectionpool:https://oauth2.googleapis.com:443 "POST /token HTTP/1.1" 200 None -INFO:root:0 entries that match the search query exist in Data Catalog! -INFO:root:Looking for entries to be deleted... -INFO:root:0 entries will be deleted. - -Starting to ingest custom metadata... - -DEBUG:google.auth._default:Checking /Users/Teradata/Apps/Cloud/GCP/teradata2dc-credentials.json for explicit credentials as part of auth process... -INFO:root:Starting the ingestion flow... -DEBUG:google.auth.transport.requests:Making request: POST https://oauth2.googleapis.com/token -DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): oauth2.googleapis.com:443 -DEBUG:urllib3.connectionpool:https://oauth2.googleapis.com:443 "POST /token HTTP/1.1" 200 None -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_database_metadata -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_column_metadata -INFO:root:Entry Group created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata -INFO:root:1/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser -INFO:root: ^ [database] 34.105.107.155/gcpuser -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_database_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser/tags/CWHNiGQeQmPT -INFO:root:2/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories -INFO:root: ^ [table] 34.105.107.155/gcpuser/Categories -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories/tags/Ceij5G9t915o -INFO:root:38/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest -INFO:root: ^ [table] 34.105.107.155/gcpuser/tablesv_instantiated_latest -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest/tags/Ceij5G9t915o -INFO:root: -============End teradata-to-datacatalog============-
Go to Data Catalog console, click on the project (i.e. partner-integration-lab) under Projects. The Teradata tables are showing on the right panel.
-
Click on the table to your interest (i.e. CITY_LEVEL_TRANS), and you’ll see the metadata about this table:
-
Clean up metadata from Data Catalog. To do that, copy https://github.com/GoogleCloudPlatform/datacatalog-connectors-rdbms/blob/master/google-datacatalog-teradata-connector/tools/cleanup_datacatalog.py to local directory.
-Change directory to where the file is and then run following command:
-python cleanup_datacatalog.py --datacatalog-project-ids=$TERADATA2DC_DATACATALOG_PROJECT_ID| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This how-to will help you to integrate Amazon SageMaker with Teradata Vantage. The approach this guide explains is one of many potential approaches to integrate with the service.
-Amazon SageMaker provides a fully managed Machine Learning Platform. There are two use cases for Amazon SageMaker and Teradata:
-Data resides on Teradata Vantage and Amazon SageMaker will be used for both the Model definition and subsequent scoring. Under this use case Teradata will provide data into the Amazon S3 environment so that Amazon SageMaker can consume training and test data sets for the purpose of model development. Teradata would further make data available via Amazon S3 for subsequent scoring by Amazon SageMaker. Under this model Teradata is a data repository only.
-Data resides on Teradata Vantage and Amazon SageMaker will be used for the Model definition, and Teradata for the subsequent scoring. Under this use case Teradata will provide data into the Amazon S3 environment so that Amazon SageMaker can consume training and test data sets for the purpose of model development. Teradata will need to import the Amazon SageMaker model into a Teradata table for subsequent scoring by Teradata Vantage. Under this model Teradata is a data repository and a scoring engine.
-The first use case is discussed in this document.
-Amazon SageMaker consumes training and test data from an Amazon S3 bucket. This article describes how you can load Teradata analytics data sets into an Amazon S3 bucket. The data can then available to Amazon SageMaker to build and train machine learning models and deploy them into a production environment.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
IAM permission to access Amazon S3 bucket, and to use Amazon SageMaker service.
-An Amazon S3 bucket to store training data.
-Amazon SageMaker trains data from an Amazon S3 bucket. Following are the steps to load training data from Vantage to an Amazon S3 bucket:
-Go to Amazon SageMaker console and create a notebook instance. See Amazon SageMaker Developer Guide for instructions on how to create a notebook instance:
-
-Open your notebook instance:
-
-Start a new file by clicking on New → conda_python3:
-Install Teradata Python library:
-!pip install teradatamlIn a new cell and import additional libraries:
-import teradataml as tdml
-from teradataml import create_context, get_context, remove_context
-from teradataml.dataframe.dataframe import DataFrame
-import pandas as pd
-import boto3, osIn a new cell, connect to Teradata Vantage. Replace <hostname>, <database user name>, <database password> to match your Vantage environment:
create_context(host = '<hostname>', username = '<database user name>', password = '<database password>')Retrieve data rom the table where the training dataset resides using TeradataML DataFrame API:
-train_data = tdml.DataFrame('table_with_training_data')
-trainDF = train_data.to_pandas()Write data to a local file:
-trainFileName = 'train.csv'
-trainDF.to_csv(trainFileName, header=None, index=False)Upload the file to Amazon S3:
-bucket = 'sagedemo'
-prefix = 'sagemaker/train'
-
-trainFile = open(trainFileName, 'rb')
-boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, localFile)).upload_fileobj(trainFile)Select Training jobs on the left menu under Training, then click on Create training job:
-At the Create training job window, fill in the Job name (e.g. xgboost-bank) and Create a new role for the IAM role. Choose Any S3 bucket for the Amazon S3 buckets and Create role:
-Back in the Create training job window, use XGBoost as the algorithm:
-Use the default ml.m4.xlarge instance type, and 30GB of additional storage volume per instance. This is a short training job, shouldn’t take more than 10 minutes.
-Fill in following hyperparameters and leave everything else as default:
-num_round=100 -silent=0 -eta=0.2 -gamma=4 -max_depth=5 -min_child_weight=6 -subsample=0.8 -objective='binary:logistic'-
For Input data configuration, enter the Amazon S3 bucket where you stored your training data. Input mode is File. Content type is csv. S3 location is where the file uploaded to:
-For Output data configuration, enter path where the output data will be stored:
-Leave everything else as default, and click on “Create training job”. Detail instructions on how to configure the training job can be found in Amazon SageMaker Developer Guide.
-Once the training job’s created, Amazon SageMaker launches the ML instances to train the model, and stores the resulting model artifacts and other output in the Output data configuration (path/<training job name>/output by default).
After you train your model, deploy it using a persistent endpoint
-Select Models under Inference from the left panel, then Create model. Fill in the model name (e.g. xgboost-bank), and choose the IAM role you created from the previous step.
For Container definition 1, use 433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest as Location of inference code image. Location of model artifacts is the output path of your training job
-Leave everything else as default, then Create model.
Select the model you just created, then click on Create endpoint configuration:
-Fill in the name (e.g. xgboost-bank) and use default for everything else. The model name and training job should be automatically populated for you. Click on Create endpoint configuration.
Select Inference → Models from the left panel, select the model again, and click on Create endpoint this time:
-Fill in the name (e.g. xgboost-bank), and select Use an existing endpoint configuration:
-image::sagemaker-with-teradata-vantage/attach.endpoint.configuration.png[Attach endpoint configuration]
Select the endpoint configuration created from last step, and click on Select endpoint configuration:
-Leave everything else as default and click on Create endpoint.
Now the model is deployed to the endpoint and can be used by client applications.
-This how-to demonstrated how to extract training data from Vantage and use it to train a model in Amazon SageMaker. The solution used a Jupyter notebook to extract data from Vantage and write it to an S3 bucket. A SageMaker training job read data from the S3 bucket and produced a model. The model was deployed to AWS as a service endpoint.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Azure Machine Learning (ML) Studio is a collaborative, drag-and-drop tool you can use to build, test, and deploy predictive analytics solutions on your data. ML Studio can consume data from Azure Blob Storage. This getting started guide will show how you can copy Teradata Vantage data sets to a Blob Storage using ML Studio 'built-in' Jupter Notebook feature. The data can then be used by ML Studio to build and train machine learning models and deploy them into a production environment.
-
Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Azure subscription or create free account
-(Optional) Download AdventureWorks DW 2016 database (i.e. 'Training the Model' section)
-Restore and copy 'vTargetMail' table from SQL Server to Teradata Vantage
-During ML Studio workspace creation, you may need to create 'new' storage account unless you have one in current availability locations and choose DEVTEST Standard for Web service plan for this getting started guide. Logon to Azure portal, open your storage account and create a container if one does not exist already.
-
Copy your storage account name and key to notepad which we will use for Python3 Notebook to access your Azure Blob Storage account.
-
Finally, open Configuration property and set 'Secure transfer required' to Disabled to allow ML Studio Import Data module to access blob storage account.
-
To get the data to ML Studio, we first need to load data from Teradata Vantage to a Azure Blob Storage. We will create a ML Jupyter Notebook, install Python packages to connect to Teradata and save data to Azure Blob Storage,
-Logon to Azure portal, go to to your ML Studio workspace and Launch Machine Learning Studio and Sign In.
-You should see the following screen and click on Notebooks, ensure you are in the right region/ workspace and click on Notebook New
-
Choose Python3 and name your notebook instance
-
In your jupyter notebook instance, install Teradata Vantage Python package for Advanced Analytics:
-pip install teradataml| - - | --There is no validation between Microsoft Azure ML Studio and Teradata Vantage Python package. - | -
Install Microsoft Azure Storage Blob Client Library for Python:
-!pip install azure-storage-blobImport the following libraries:
-import teradataml as tdml
-from teradataml import create_context, get_context, remove_context
-from teradataml.dataframe.dataframe import DataFrame
-import pandas as pd
-from azure.storage.blob import (BlockBlobService)Connect to Teradata using command:
-create_context(host = '<hostname>', username = '<database user name>', password = '<password>')Retrieve Data using Teradata Python DataFrame module:
-train_data = DataFrame.from_table("<table_name>")Convert Teradata DataFrame to Panda DataFrame:
-trainDF = train_data.to_pandas()Convert data to CSV:
-trainDF = trainDF.to_csv(head=True,index=False)Assign variables for Azue Blob Storage account name, key and container name:
-accountName="<account_name>"
-accountKey="<account_key>"
-containerName="mldata"Upload file to Azure Blob Storage:
-blobService = BlockBlobService(account_name=accountName, account_key=accountKey)
-blobService.create_blob_from_text(containerNAme, 'vTargetMail.csv', trainDF)Logon to Azure portal, open blob storage account to view uploaded file:
-
We will use the existing Analyze data with Azure Machine Learning article to build a predictive machine learning model based on data from Azure Blob Storage. We will build a targeted marketing campaign for Adventure Works, the bike shop, by predicting if a customer is likely to buy a bike or not.
-The data is on Azure Blob Storage file called vTargetMail.csv which we copied in the section above.
1.. Sign into Azure Machine Learning studio and click on Experiments. -2.. Click +NEW on the bottom left of the screen and select Blank Experiment. -3.. Enter a name for your experiment: Targeted Marketing. -4.. Drag Import data module under Data Input and output from the modules pane into the canvas. -5.. Specify the details of your Azure Blob Storage (account name, key and container name) in the Properties pane.
-Run the experiment by clicking Run under the experiment canvas.
-
After the experiment finishes running successfully, click the output port at the bottom of the Import Data module and select Visualize to see the imported data.
-
To clean the data, drop some columns that are not relevant for the model. To do this:
-Drag Select Columns in Dataset module under Data Transformation < Manipulation into the canvas. Connect this module to the Import Data module.
-Click Launch column selector in Properties pane to specify which columns you wish to drop.
-
Exclude two columns: CustomerAlternateKey and GeographyKey.
-
We will split the data 80-20: 80% to train a machine learning model and 20% to test the model. We will make use of the "Two-Class" algorithms for this binary classification problem.
-Drag SplitData module into the canvas and connect with 'Select Columns in DataSet'.
-In the properties pane, enter 0.8 for Fraction of rows in the first output dataset.
-
Search and drag Two-Class Boosted Decision Tree module into the canvas.
-Search and drag Train Model module into the canvas and specify inputs by connecting it to the Two-Class Boosted Decision Tree (ML algorithm) and Split Data (data to train the algorithm on) modules.
-
Then, click Launch column selector in the Properties pane. Select the BikeBuyer column as the column to predict.
-
Now, we will test how the model performs on test data. We will compare the algorithm of our choice with a different algorithm to see which performs better.
-Drag Score Model module into the canvas and connect it to Train Model and Split Data modules.
-
Search and drag Two-Class Bayes Point Machine into the experiment canvas. We will compare how this algorithm performs in comparison to the Two-Class Boosted Decision Tree.
-Copy and Paste the modules Train Model and Score Model in the canvas.
-Search and drag Evaluate Model module into the canvas to compare the two algorithms.
-Run the experiment.
-
Click the output port at the bottom of the Evaluate Model module and click Visualize.
-
The metrics provided are the ROC curve, precision-recall diagram and lift curve. Looking at these metrics, we can see that the first model performed better than the second one. To look at the what the first model predicted, click on output port of the Score Model and click Visualize.
-
You will see two more columns added to your test dataset. -1. Scored Probabilities: the likelihood that a customer is a bike buyer. -2. Scored Labels: the classification done by the model - bike buyer (1) or not (0). This probability threshold for labeling is set to 50% and can be adjusted.
-Comparing the column BikeBuyer (actual) with the Scored Labels (prediction), you can see how well the model has performed. As next steps, you can use this model to make predictions for new customers and publish this model as a web service or write results back to SQL Data Warehouse.
-To learn more about building predictive machine learning models, refer to Introduction to Machine Learning on Azure.
-For large data set copies, consider using the Teradata Access Module for Azure that interfaces between the Teradata Parallel Transporter load/unload operators and Azure Blob Storage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/examples-configuration.html.
diff --git a/pr-preview/pr-204/connectors/database/reference.html b/pr-preview/pr-204/connectors/database/reference.html deleted file mode 100644 index f081ea1b5..000000000 --- a/pr-preview/pr-204/connectors/database/reference.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - -The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/reference.html.
diff --git a/pr-preview/pr-204/connectors/database/release-notes.html b/pr-preview/pr-204/connectors/database/release-notes.html deleted file mode 100644 index cec2a502b..000000000 --- a/pr-preview/pr-204/connectors/database/release-notes.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - -The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/release-notes.html.
diff --git a/pr-preview/pr-204/connectors/db/example-configuration.html b/pr-preview/pr-204/connectors/db/example-configuration.html deleted file mode 100644 index 971287125..000000000 --- a/pr-preview/pr-204/connectors/db/example-configuration.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - -The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/examples-configuration.html.
diff --git a/pr-preview/pr-204/connectors/db/reference.html b/pr-preview/pr-204/connectors/db/reference.html deleted file mode 100644 index f081ea1b5..000000000 --- a/pr-preview/pr-204/connectors/db/reference.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - -The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/reference.html.
diff --git a/pr-preview/pr-204/connectors/db/release-notes.html b/pr-preview/pr-204/connectors/db/release-notes.html deleted file mode 100644 index cec2a502b..000000000 --- a/pr-preview/pr-204/connectors/db/release-notes.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - -The page you requested has been relocated to https://quickstarts.teradata.com/mule-teradata-connector/release-notes.html.
diff --git a/pr-preview/pr-204/create-parquet-files-in-object-storage.html b/pr-preview/pr-204/create-parquet-files-in-object-storage.html deleted file mode 100644 index 66d2377e0..000000000 --- a/pr-preview/pr-204/create-parquet-files-in-object-storage.html +++ /dev/null @@ -1,2708 +0,0 @@ - - - - - -Native Object Storage (NOS) is a Vantage feature that allows you to query data stored in files such as CSV, JSON, and Parquet format datasets. -These datasets are located on external S3-compatible object storage such as AWS S3, Google GCS, Azure Blob or on-prem implementations. -It’s useful in scenarios where you want to explore data without building a data pipeline to bring it into Vantage. This tutorial demonstrates how to export data from Vantage to object storage using the Parquet file format.
-You need access to a Teradata Vantage instance. NOS is enabled in all Vantage editions from Vantage Express through Developer, DYI to Vantage as a Service starting from version 17.10.
-| - - | --This tutorial is based on s3 aws object storage. You will need your own s3 bucket with write permissions to complete the tutorial. - | -
| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
WRITE_NOS allows you to extract selected or all columns from a database table or from derived results and write to external object storage, such as Amazon S3, Azure Blob storage, Azure Data Lake Storage Gen2, and Google Cloud Storage. This functionality stores data in Parquet format.
You can find more documentation about WRITE_NOS functionality in the NOS documentation.
You will need access to a database where you can execute WRITE_NOS function. If you don’t have such a database, run the following commands:
CREATE USER db AS PERM=10e7, PASSWORD=db;
-
--- Don't forget to give the proper access rights
-GRANT EXECUTE FUNCTION on TD_SYSFNLIB.READ_NOS to db;
-GRANT EXECUTE FUNCTION on TD_SYSFNLIB.WRITE_NOS to db;| - - | --If you would like to learn more about setting up users and their privileges, checkout the NOS documentation. - | -
Let’s first create a table on your Teradata Vantage instance:
-CREATE SET TABLE db.parquet_table ,FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO,
- MAP = TD_MAP1
- (
- column1 SMALLINT NOT NULL,
- column2 DATE FORMAT 'YY/MM/DD' NOT NULL,
- column3 DECIMAL(10,2))
-PRIMARY INDEX ( column1 );Populate your table with example data:
-INSERT INTO db.parquet_table (1,'2022/01/01',1.1);
-INSERT INTO db.parquet_table (2,'2022/01/02',2.2);
-INSERT INTO db.parquet_table (3,'2022/01/03',3.3);Your table should now look like this:
-column1 column2 column3 -------- -------- ------------ - 1 22/01/01 1.10 - 2 22/01/02 2.20 - 3 22/01/03 3.30-
Create the parquet file with WRITE_NOS. Don’t forget to replace <BUCKET_NAME> with the name of your s3 bucket. Also,replace <YOUR-ACCESS-KEY-ID> and <YOUR-SECRET-ACCESS-KEY> with your access key and secret.
| - - | --Check your cloud provider docs how to create credentials to access object storage. For example, for AWS check out How do I create an AWS access key? - | -
SELECT * FROM WRITE_NOS (
-ON ( SELECT * FROM db.parquet_table)
-USING
-LOCATION('/s3/<BUCKET_NAME>.s3.amazonaws.com/parquet_file_on_NOS.parquet')
-AUTHORIZATION('{"ACCESS_ID":"<YOUR-ACCESS-KEY-ID>",
-"ACCESS_KEY":"<YOUR-SECRET-ACCESS-KEY>"}')
-STOREDAS('PARQUET')
-MAXOBJECTSIZE('16MB')
-COMPRESSION('SNAPPY')
-INCLUDE_ORDERING('TRUE')
-INCLUDE_HASHBY('TRUE')
-) as d;Now you have created a parquet file in your object storage bucket. Now to easily query your file you need to follow step number 4.
-Create a NOS-backed foreign table. Don’t forget to replace <BUCKET_NAME> with the name of your s3 bucket. Also,replace <YOUR-ACCESS-KEY-ID> and <YOUR-SECRET-ACCESS-KEY> with your access key and secret:
CREATE MULTISET FOREIGN TABLE db.parquet_table_to_read_file_on_NOS
-, EXTERNAL SECURITY DEFINER TRUSTED CEPH_AUTH,
-MAP = TD_MAP1
-(
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC
- , col1 SMALLINT
- , col2 DATE
- , col3 DECIMAL(10,2)
-
-)
-USING (
- LOCATION ('/s3/<BUCKET_NAME>.s3.amazonaws.com/parquet_file_on_NOS.parquet')
- AUTHORIZATION('{"ACCESS_ID":"<YOUR-ACCESS-KEY-ID>",
- "ACCESS_KEY":"<YOUR-SECRET-ACCESS-KEY>"}')
- STOREDAS ('PARQUET')
-)NO PRIMARY INDEX;Now you are ready to Query your parquet file on NOS, let’s try the following query:
-SELECT col1, col2, col3 FROM db.parquet_table_to_read_file_on_NOS;The data returned from the query should look something like this:
-col1 col2 col3 ------- -------- ------------ - 1 22/01/01 1.10 - 2 22/01/02 2.20 - 3 22/01/03 3.30-
In this tutorial we have learned how to export data from Vantage to a parquet file on object storage using Native Object Storage (NOS). NOS supports reading and importing data stored in CSV, JSON and Parquet formats. NOS can also export data from Vantage to object storage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This tutorial demonstrates how to use dbt (Data Build Tool) with Teradata Vantage. It’s based on the original dbt Jaffle Shop tutorial. A couple of models have been adjusted to the SQL dialect supported by Vantage.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Python 3.7, 3.8, 3.9, 3.10 or 3.11 installed.
-Clone the tutorial repository and cd into the project directory:
-git clone https://github.com/Teradata/jaffle_shop-dev.git jaffle_shop
-cd jaffle_shopCreate a new python environment to manage dbt and its dependencies. Activate the environment:
- -Install dbt-teradata module and its dependencies. The core dbt module is included as a dependency so you don’t have to install it separately:
pip install dbt-teradataWe will now configure dbt to connect to your Vantage database. Create file $HOME/.dbt/profiles.yml with the following content. Adjust <host>, <user>, <password> to match your Teradata instance.
| - - | -
- Database setup
-
-
-The following dbt profile points to a database called |
-
jaffle_shop:
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- logmech: TD2
- schema: jaffle_shop
- tmode: ANSI
- threads: 1
- timeout_seconds: 300
- priority: interactive
- retries: 1
- target: devNow, that we have the profile file in place, we can validate the setup:
-dbt debugIf the debug command returned errors, you likely have an issue with the content of profiles.yml.
jaffle_shop is a fictional e-commerce store. This dbt project transforms raw data from an app database into a dimensional model with customer and order data ready for analytics.
The raw data from the app consists of customers, orders, and payments, with the following entity-relationship diagram:
-
-dbt takes these raw data table and builds the following dimensional model, which is more suitable for analytics tools:
-
-In real life, we will be getting raw data from platforms like Segment, Stitch, Fivetran or another ETL tool. In our case, we will use dbt’s seed functionality to create tables from csv files. The csv files are located in ./data directory. Each csv file will produce one table. dbt will inspect the files and do type inference to decide what data types to use for columns.
Let’s create the raw data tables:
-dbt seedYou should now see 3 tables in your jaffle_shop database: raw_customers, raw_orders, raw_payments. The tables should be populated with data from the csv files.
Now that we have the raw tables, we can instruct dbt to create the dimensional model:
-dbt runSo what exactly happened here? dbt created additional tables using CREATE TABLE/VIEW FROM SELECT SQL. In the first transformation, dbt took raw tables and built denormalized join tables called customer_orders, order_payments, customer_payments. You will find the definitions of these tables in ./marts/core/intermediate.
-In the second step, dbt created dim_customers and fct_orders tables. These are the dimensional model tables that we want to expose to our BI tool.
dbt applied multiple transformations to our data. How can we ensure that the data in the dimensional model is correct? dbt allows us to define and execute tests against the data. The tests are defined in ./marts/core/schema.yml. The file describes each column in all relationships. Each column can have multiple tests configured under tests key. For example, we expect that fct_orders.order_id column will contain unique, non-null values. To validate that the data in the produced tables satisfies the test conditions run:
dbt testOur model consists of just a few tables. Imagine a scenario where where we have many more sources of data and a much more complex dimensional model. We could also have an intermediate zone between the raw data and the dimensional model that follows the Data Vault 2.0 principles. Would it not be useful, if we had the inputs, transformations and outputs documented somehow? dbt allows us to generate documentation from its configuration files:
-dbt docs generateThis will produce html files in ./target directory.
You can start your own server to browse the documentation. The following command will start a server and open up a browser tab with the docs' landing page:
-dbt docs serveThis tutorial demonstrated how to use dbt with Teradata Vantage. The sample project takes raw data and produces a dimensional data mart. We used multiple dbt commands to populate tables from csv files (dbt seed), create models (dbt run), test the data (dbt test), and generate and serve model documentation (dbt docs generate, dbt docs serve).
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This quickstart explains how to use Terraform to manage Airbyte data pipelines as code. Instead of manual configurations through the WebUI, we’ll use code to create and manage Airbyte resources. The provided example illustrates a basic ELT pipeline from Google Sheets to Teradata Vantage using Airbyte’s Terraform provider.
-The Airbyte Terraform provider is available for users on Airbyte Cloud, OSS & Self-Managed Enterprise.
-Watch this concise explanation of how this integration works:
-Terraform is a leading open-source tool in the Infrastructure as Code (IaC) space. It enables the automated provisioning and management of infrastructure, cloud platforms, and services via configuration files, instead of manual setup. Terraform uses plugins, known as Terraform providers, to communicate with infrastructure hosts, cloud providers, APIs, and SaaS platforms.
-Airbyte, the data integration platform, has a Terraform provider that communicates directly with Airbyte’s API. This allows data engineers to manage Airbyte configurations, enforce version control, and apply good data engineering practices within their ELT pipelines.
-Airbyte Cloud Account. Start with a 14-day free trial that begins after the first successful sync.
-Generate an Airbyte API Key by logging into the developer portal.
-Teradata Vantage Instance. You will need a database Host, Username, and Password for Airbyte’s Terraform configuration.
Source Data. For demonstration purposes we will use a sample Google Sheets. Make a copy of it into a personal Google worspace.
-Google Cloud Platform API enabled for your personal or organizational account. You’ll need to authenticate your Google account via OAuth or via Service Account Key Authenticator. In this example, we use Service Account Key Authenticator.
-Apply the respective commands to install Terraform on your Operating System. Find additional options on the Terraform site.
-First, install the HashiCorp tap, a repository of all Homebrew packages.
- brew tap hashicorp/tapNext, install Terraform with hashicorp/tap/terraform.
- brew install hashicorp/tap/terraformChocolatey is a free and open-source package management system for Windows. Install the Terraform package from the command-line.
- choco install terraformwget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
-echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
-sudo apt update && sudo apt install terraformPrepare the environment by creating a directory for the Terraform configuration and initialize two files: main.tf and variables.tf.
mkdir terraform_airbyte
-cd terraform_airbyte
-touch main.tf variables.tfDefine the data source, destination and connection within the main.tf file. Open the newly created main.tf file in Visual Studio Code or any preferred code editor.
If using Visual Studio Code, install HashiCorp Terraform Extensions to add autocompletion and syntax highlighting. You can also add Terraform by Anton Kulikov for configuration language support.
-
-Populate the main.tf file with the template provided.
-# Provider Configuration
-terraform {
- required_providers {
- airbyte = {
- source = "airbytehq/airbyte"
- version = "0.4.1" // Latest Version https://registry.terraform.io/providers/airbytehq/airbyte/latest
- }
- }
-}
-provider "airbyte" {
- // If running on Airbyte Cloud, generate & save the API key from https://portal.airbyte.com
- bearer_auth = var.api_key
-}
-# Google Sheets Source Configuration
-resource "airbyte_source_google_sheets" "my_source_gsheets" {
- configuration = {
- source_type = "google-sheets"
- credentials = {
- service_account_key_authentication = {
- service_account_info = var.google_private_key
- }
- }
- names_conversion = true,
- spreadsheet_id = var.spreadsheet_id
- }
- name = "Google Sheets"
- workspace_id = var.workspace_id
-}
-# Teradata Vantage Destination Configuration
-# For optional parameters visit https://registry.terraform.io/providers/airbytehq/airbyte/latest/docs/resources/destination_teradata
-resource "airbyte_destination_teradata" "my_destination_teradata" {
- configuration = {
- host = var.host
- password = var.password
- schema = "airbyte_td_two"
- ssl = false
- ssl_mode = {
- allow = {}
- }
- username = var.username
- }
- name = "Teradata"
- workspace_id = var.workspace_id
-}
-# Connection Configuration
-resource "airbyte_connection" "googlesheets_teradata" {
- name = "Google Sheets - Teradata"
- source_id = airbyte_source_google_sheets.my_source_gsheets.source_id
- destination_id = airbyte_destination_teradata.my_destination_teradata.destination_id
- schedule = {
- schedule_type = "cron" // "manual"
- cron_expression = "0 15 * * * ?" # This sets the data sync to run every 15 minutes of the hour
- }
- }Note that this example uses a cron expression to schedule the data transfer to run every 15 minutes past the hour.
-In our main.tf file we reference variables which are held in the variables.tf file, including the API key, workspace ID, Google Sheet id, Google private key and Teradata Vantage credentials. Copy the following template into the variables.tf file and populate with the appropriate configuration values in the default attribute.
#log in to https://portal.airbyte.com generate, save and populate the variable with an API key
-variable "api_key" {
- type = string
- default = ""
-}
-#workspace_id is found in the url to the Airbyte Cloud account https://cloud.airbyte.com/workspaces/<workspace_id>/settings/dbt-cloud
-variable "workspace_id" {
- type = string
- default = ""
-}
-
-#Google spreadsheet id and Google private key
-variable "spreadsheet_id" {
- type = string
- default = ""
-}
-variable "google_private_key" {
- type = string
- default = ""
-}
-# Teradata Vantage connection credentials
-variable "host" {
- type = string
- default = ""
- }
-variable "username" {
- type = string
- default = "demo_user"
- }
- variable "password" {
- type = string
- default = ""
- }Run terraform init pull down provider plugin from terraform provider page and initialize a working Terraform directory.
This command should only be run after writing a new Terraform configuration or cloning an existing one from version control.
-
-Run terraform plan to display the execution plan Terraform will use to create resource and make modifications to infrastructure.
For this example a plan for 3 new resources is created:
-Connection: # airbyte_connection.googlesheets_teradata will be created
-Destination: # airbyte_connection.googlesheets_teradata will be created
-Source: # airbyte_source_google_sheets.my_source_gsheets will be created
-
-Run terraform apply and yes to generate a plan and carry out the plan.
-The terraform.tfstate file is created after running terraform apply for the first time. This file tracks the status of all sources, destinations, and connections managed by Terraform. For subsequent executions of Terraform apply, Terraform compares the code in the main.tf file with the code stored in the tfstate file. If resources are added or removed in main.tf, Terraform automatically updates both deployment and the .tfstate file accordingly upon deployment. Do not modify this file by hand.
You now have a Source, Destination and Connection on Airbyte Cloud created and managed via Terraform.
-
-This tutorial demonstrates how to use dbt (Data Build Tool) to transform external data load through Airbyte (an Open-Source Extract Load tool) in Teradata Vantage.
-This tutorial is based on the original dbt Jaffle Shop tutorial with a small change, instead of using the dbt seed command, the Jaffle Shop dataset is loaded from Google Sheets into Teradata Vantage using Airbyte. Data loaded through airbyte is contained in JSON columns as can be seen in the picture below:
-Access to a Teradata Vantage Instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Sample data: The sample data Jaffle Shop Dataset can be found in Google Sheets.
-Reference dbt project repository: Jaffle Project with Airbyte.
-Python 3.7, 3.8, 3.9, 3.10 or 3.11 installed.
-Follow the steps in the Airbyte tutorial. Make sure you load data from the Jaffle Shop spreadsheet and not the default dataset referenced by the Airbyte tutorial. Also, set the Default Schema in the Teradata destination to airbyte_jaffle_shop.
| - - | -
-
-
-When you configure a Teradata destination in Airbyte, it will ask for a |
-
Clone the tutorial repository and change the directory to the project directory:
-+
-git clone https://github.com/Teradata/airbyte-dbt-jaffle
-cd airbyte-dbt-jaffleCreate a new python environment to manage dbt and its dependencies. Activate the environment:
-python3 -m venv env
-source env/bin/activate| - - | -
-
-
-You can activate the virtual environment in Windows by executing the corresponding batch file |
-
Install dbt-teradata module and its dependencies. The core dbt module is included as a dependency so you don’t have to install it separately:
pip install dbt-teradataInitialize a dbt project.
-dbt initThe dbt project wizard will ask you for a project name and database management system to use in the project. In this demo, we define the project name as dbt_airbyte_demo. Since we are using the dbt-teradata connector, the only database management system available is Teradata.
-
-Configure the profiles.yml file located in the $HOME/.dbt directory. If the profiles.yml file is not present, you can create a new one.
Adjust server, username, password to match your Teradata instance’s HOST, Username, Password respectively.
In this configuration, schema stands for the database that contains the sample data, in our case that is the default schema that we defined in Airbyte airbyte_jaffle_shop.
dbt_airbyte_demo:
- target: dev
- outputs:
- dev:
- type: teradata
- server: <host>
- schema: airbyte_jaffle_shop
- username: <user>
- password: <password>
- tmode: ANSIOnce the profiles.yml file is ready, we can validate the setup. Go to the dbt project folder and run the command:
dbt debugIf the debug command returned errors, you likely have an issue with the content of profiles.yml. If the setup is correct, you will get message All checks passed!
-jaffle_shop is a fictional restaurant that takes orders online. The data of this business consists of tables for customers, orders and `payments`that follow the entity relations diagram below:
-The data in the source system is normalized. A dimensional model based on the same data, more suitable for analytics tools, is presented below:
-
-| - - | -
-
-
-The complete dbt project encompassing the transformations detailed below is located at Jaffle Project with Airbyte. - |
-
The reference dbt project performs two types of transformations.
-First, it transforms the raw data (in JSON format), loaded from Google Sheets via Airbyte, into staging views. At this stage the data is normalized.
-Next, it transforms the normalized views into a dimensional model ready for analytics.
-The following diagram shows the transformation steps in Teradata Vantage using dbt:
-
-As in all dbt projects, the folder models contains the data models that the project materializes as tables, or views, according to the corresponding configurations at the project, or individual model level.
The models can be organized into different folders according to their purpose in the organization of the data warehouse/lake. Common folder layouts include a folder for staging, a folder for core, and a folder for marts. This structure can be simplified without affecting the workings of dbt.
In the original dbt Jaffle Shop tutorial the project’s data is loaded from csv files located in the ./data folder through dbt’s seed command. The seed command is commonly used to load data from tables, however, this command is not designed to perform data loading.
In this demo we are assuming a more typical setup in which a tool designed for data loading, Airbyte, was used to load data into the datawarehouse/lake. -Data loaded through Airbyte though is represented as raw JSON strings. From these raw data we are creating normalized staging views. We perform this task through the following staging models.
-The stg_customers model creates the normalized staging view for customers from the _airbyte_raw_customers table.
The stg_orders model creates the normalized view for orders from the _airbyte_raw_orders table
The stg_payments model creates the normalized view for payments from the _airbyte_raw_payments table.
| - - | -
-
-
-As the method of extracting JSON strings remains consistent across all staging models, we will provide a detailed explanation for the transformations using just one of these models as an example. - |
-
Below an example of transforming raw JSON data into a view through the stg_orders.sql model :
WITH source AS (
- SELECT * FROM {{ source('airbyte_jaffle_shop', '_airbyte_raw_orders')}}
-),
-
-flattened_json_data AS (
- SELECT
- _airbyte_data.JSONExtractValue('$.id') AS order_id,
- _airbyte_data.JSONExtractValue('$.user_id') AS customer_id,
- _airbyte_data.JSONExtractValue('$.order_date') AS order_date,
- _airbyte_data.JSONExtractValue('$.status') AS status
- FROM source
-)
-
-
-SELECT * FROM flattened_json_dataIn this model the source is defined as the raw table _airbyte_raw_orders.
This raw table columns contains both metadata, and the actual ingested data. The data column is called _airbyte_data.
This column is of Teradata JSON type. This type supports the method JSONExtractValue for retrieving scalar values from the JSON object.
-In this model we are retrieving each of the attributes of interest and adding meaningful aliases in order to materialize a view.
-Building a Dimensional Model is a two-step process:
-First, we take the normalized views in stg_orders, stg_customers, stg_payments and build denormalized intermediate join tables customer_orders, order_payments, customer_payments. You will find the definitions of these tables in ./models/marts/core/intermediate.
In the second step, we create the dim_customers and fct_orders models. These constitute the dimensional model tables that we want to expose to our BI tool. You will find the definitions of these tables in ./models/marts/core.
For executing the transformations defined in the dbt project we run:
-dbt runYou will get the status of each model as given below:
-
-To ensure that the data in the dimensional model is correct, dbt allows us to define and execute tests against the data.
-The tests are defined in ./models/marts/core/schema.yml and ./models/staging/schema.yml. Each column can have multiple tests configured under the tests key.
For example, we expect that fct_orders.order_id column will contain unique, non-null values.
To validate that the data in the produced tables satisfies the test conditions run:
-dbt testIf the data in the models satisfies all the test cases, the result of this command will be as below:
-
-Our model consists of just a few tables. In a scenario with more sources of data, and a more complex dimensional model, documenting the data lineage and what is the purpose of each of the intermediate models is very important.
-Generating this type of documentation with dbt is very straight forward.
-dbt docs generateThis will produce html files in the ./target directory.
You can start your own server to browse the documentation. The following command will start a server and open up a browser tab with the docs' landing page:
-dbt docs serveThis tutorial demonstrated how to use dbt to transform raw JSON data loaded through Airbyte into dimensional model in Teradata Vantage. The sample project takes raw JSON data loaded in Teradata Vantage, creates normalized views and finally produces a dimensional data mart. We used dbt to transform JSON into Normalized views and multiple dbt commands to create models (dbt run), test the data (dbt test), and generate and serve model documentation (dbt docs generate, dbt docs serve).
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This tutorial showcases how to use Airbyte to move data from sources to Teradata Vantage, detailing both the Airbyte Open Source and Airbyte Cloud options. This specific example covers replication from Google Sheets to Teradata Vantage.
-Source: Google Sheets
-Destination: Teradata Vantage
-
-Access to a Teradata Vantage Instance. This will be defined as the destination of the Airbyte connection. You will need a database Host, Username, and Password for Airbyte’s configuration.
| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Google Cloud Platform API enabled for your personal or organizational account. You’ll need to authenticate your Google account via OAuth or via Service Account Key Authenticator. In this example, we use Service Account Key Authenticator.
-Data from the source system. In this case, we use a sample spreadsheet from google sheets. The sample data is a breakdown of payrate by employee type.
-Create an account on Airbyte Cloud and skip to the instructions under the Airbyte Configuration section.
-Install Docker Compose to run Airbyte Open Source locally. Docker Compose comes with Docker Desktop. Please refer to docker docs for more details.
-Clone the Airbyte Open Source repository and go to the airbyte directory.
-
-git clone --depth 1 https://github.com/airbytehq/airbyte.git
-cd airbyteMake Sure to have Docker Desktop running before running the shell script run-ab-platform.
Run the shell script run-ab-platform as
./run-ab-platform.sh| - - | -
-
-
-You can run the above commands with |
-
Log in to the web app http://localhost:8000/ by entering the default credentials found in the .env file included in the repository.
BASIC_AUTH_USERNAME=airbyte
-BASIC_AUTH_PASSWORD=passwordWhen logging in for the first time, Airbyte will prompt you to provide your email address and specify your preferences for product improvements. Enter your preferences and click on "Get started."
-
-Once Airbyte Open Source is launched you will see a connections dashboard. If you launched Airbyte Open Source for the first time, it would not show any connections.
-You can either click "Create your first connection" or click on the top right corner to initiate the new connection workflow on Airbyte’s Connections dashboard.
-
-Airbyte will ask you for the Source, you can select from an existing source (if you have set it up already) or you can set up a new source, in this case we select Google Sheets.
For authentication we are using Service Account Key Authentication which uses a service account key in JSON format. Toggle from the default OAuth to Service Account Key Authentication. To authenticate your Google account via Service Account Key Authentication, enter your Google Cloud service account key in JSON format.
-Make sure the Service Account has the Project Viewer permission. If your spreadsheet is viewable by anyone with its link, no further action is needed. If not, give your Service account access to your spreadsheet.
Add the link to the source spreadsheet as Spreadsheet Link.
-| - - | -
-
-
-For more details, please refer Setting Google Sheets as Source Connector in Airbyte Open Source - |
-
Click Set up source, if the configuration is correct, you will get the message All connection tests passed!
Assuming you want to create a fresh new connection with Teradata Vantage, Select Teradata Vantage as the destination type under the "Set up the destination" section.
Add the Host, User, and Password. These are the same as the Host, Username, and Password respectively, used by your Clearscape Analytics Environment.
Provide a default schema name appropriate to your specific context. Here we have provided gsheet_airbyte_td.
| - - | -
-
-
-If you do not provide a |
-
-Click Set up destination, if the configuration is correct, you will get the message All connection tests passed!
| - - | -
-
-
-You might get a configuration check failed error. Make sure your Teradata Vantage instance is running properly before making a connection through Airbyte. - |
-
A namespace is a group of streams (tables) in a source or destination. A schema in a relational database system is an example of a namespace. In a source, the namespace is the location from where the data is replicated to the destination. In a destination, the namespace is the location where the replicated data is stored in the destination. -For more details please refer to Airbyte Namespace.
-
-In our example the destination is a database, so the namespace is the default schema gsheet_airbyte_td we defined when we configured the destination. The stream name is a table that is mirroring the name of the spreadsheet in the source, which is sample_employee_payrate in this case. Since we are using the single spreadsheet connector, it only supports one stream (the active spreadsheet).
Other type of sources and destinations might have a different layout. In this example, Google sheets, as source, does not support a namespace.
-In our example, we have used <destination schema> as the Namespace of the destination, this is the default namespace assigned by Airbyte based on the Default Schema we declared in the destination settings. The database gsheet_airbyte_td will be created in our Teradata Vantage Instance.
| - - | -
-
-
-We use the term "schema", as it is the term used by Airbyte. In a Teradata context the term "database" is the equivalent. - |
-
It shows how often data should sync to destination. You can select every hour, 2 hours, 3 hours etc. In our case we used every 24 hours.
-
-You can also use a Cron expression to specify the time when the sync should run. In the example below, we set the Cron expression to run the sync on every Wednesday at 12:43 PM (US/Pacific) time.
-
-Airbyte tracks synchronization attempts in the "Sync History" section of the Status tab.
-Next, you can go to the ClearScape Analytics Experience and run a Jupyter notebook, notebooks in ClearScape Analytics Experience are configured to run Teradata SQL queries, to verify if the database gsheet_airbyte_td, streams (tables) and complete data is present.
-%connect localSELECT DatabaseName, TableName, CreateTimeStamp, LastAlterTimeStamp
-FROM DBC.TablesV
-WHERE DatabaseName = 'gsheet_airbyte_td'
-ORDER BY TableName;DATABASE gsheet_airbyte_td;SELECT * FROM _airbyte_raw_sample_employee_payrate;The stream (table) name in destination is prefixed with _airbyte_raw_ because Normalization and Transformation are not supported for this connection, and we only have the raw table. Each stream (table) contains 3 columns:
_airbyte_ab_id: a uuid assigned by Airbyte to each event that is processed. The column type in Teradata is VARCHAR(256).
_airbyte_emitted_at: a timestamp representing when the event was pulled from the data source. The column type in Teradata is TIMESTAMP(6).
_airbyte_data: a json blob representing the event data. The column type in Teradata is JSON.
Here in the _airbyte_data column, we see 9 rows, the same as we have in the source Google sheet, and the data is in JSON format which can be transformed further as needed.
You can close the connection in Airbyte by disabling the connection. This will stop the data sync process.
-
-You can also delete the connection.
-
-This tutorial demonstrated how to extract data from a source system like Google sheets and use the Airbyte ELT tool to load the data into the Teradata Vantage Instance. We saw the end-to-end data flow and complete configuration steps for running Airbyte Open Source locally, and configuring the source and destination connections. We also discussed about the available data sync configurations based on replication frequency. We validated the results in the destination using Cloudscape Analytics Experience and finally we saw the methods to pause and delete the Airbyte connection.
-
- 
- ¿No encuentras lo que buscas?
- |
- - Contribuye o solicita un tema. - | -- Solicitar - Contribuir - | -
| - - | -
- Deprecation notice
-
-
-This how-to describes |
-
We often have a need to move large volumes of data into Vantage. Teradata offers Fastload utility that can efficiently load large amounts of data into Teradata Vantage. This how-to demonstrates how to use Fastload. In this scenario, we will load over 300k records, over 40MB of data, in a couple of seconds.
Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Download Teradata Tools and Utilities (TTU) - supported platforms: Windows, MacOS, Linux (requires registration).
-We will be working with the US tax fillings for nonprofit organizations. Nonprofit tax filings are public data. The US Internal Revenue Service publishes them in S3 bucket. Let’s grab a summary of filings for 2020: https://s3.amazonaws.com/irs-form-990/index_2020.csv. You can use your browser, wget or curl to save the file locally.
Let’s create a database in Vantage. Use your favorite SQL tool to run the following query:
-
- 
- 
- 
- 
- 
- CREATE DATABASE irs
-AS PERMANENT = 120e6, -- 120MB
- SPOOL = 120e6; -- 120MBWe will now run Fastload. Fastload is a command-line tool that is very efficient in uploading large amounts of data into Vantage. Fastload, in order to be fast, has several restrictions in place. It can only populate empty tables, no inserts to already populated tables are supported. It doesn’t support tables with secondary indices. Also, it won’t insert duplicate records, even if a table is a MULTISET table. For the full list of restrictions check out Teradata® Fastload Reference.
Fastload has its own scripting language. The language allows you to prepare the database with arbitrary SQL commands, declare the input source and define how the data should be inserted into Vantage. The tool supports both interactive and batch mode. In this section, we are going to use the interactive mode.
-Let’s start Fastload in the interactive mode:
fastloadFirst, let’s log in to a Vantage database. I’ve a Vantage Express running locally, so I’ll use localhost as the hostname and dbc for username and password:
LOGON localhost/dbc,dbc;Now, that we are logged in, I’m going to prepare the database. I’m switching to irs database and making sure that the target table irs_returns and error tables (more about error tables later) do not exist:
DATABASE irs;
-DROP TABLE irs_returns;
-DROP TABLE irs_returns_err1;
-DROP TABLE irs_returns_err2;I’ll now create an empty table that can hold the data elements from the csv file.
-CREATE MULTISET TABLE irs_returns (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
-)
-PRIMARY INDEX ( return_id );Now, that the target table has been prepared, we can start loading the data. ERRORFILES directive defines error files. The error files are really tables that Fastload creates. The first table contains information about data conversion and other issues. The second table keeps track of data uniqueness issues, e.g. primary key violations.
BEGIN LOADING irs_returns
- ERRORFILES irs_returns_err1, irs_returns_err2;We instruct Fastload to save a checkpoint every 10k rows. It’s useful in case we have to restart our job. It will be able to resume from the last checkpoint.
CHECKPOINT 10000;We also need to tell Fastload to skip the first row in the CSV file as start at record 2. That’s because the first row contains column headers.
RECORD 2;Fastload also needs to know that it’s a comma-separated file:
SET RECORD VARTEXT ",";DEFINE block specifies what columns we should expect:
DEFINE in_return_id (VARCHAR(19)),
- in_filing_type (VARCHAR(5)),
- in_ein (VARCHAR(19)),
- in_tax_period (VARCHAR(19)),
- in_sub_date (VARCHAR(22)),
- in_taxpayer_name (VARCHAR(100)),
- in_return_type (VARCHAR(5)),
- in_dln (VARCHAR(19)),
- in_object_id (VARCHAR(19)),DEFINE block also has FILE attribute that points to the file with the data. Replace FILE = /tmp/index_2020.csv; with your location of index_2020.csv file:
FILE = /tmp/index_2020.csv;Finally, we define the INSERT statement that will put data into the database and we close off LOADING block:
INSERT INTO irs_returns (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );
-END LOADING;Once the job has finished, we are logging off from the database to clean things up.
-LOGOFF;Here is what the entire script looks like:
-LOGON localhost/dbc,dbc;
-
-DATABASE irs;
-DROP TABLE irs_returns;
-DROP TABLE irs_returns_err1;
-DROP TABLE irs_returns_err2;
-
-CREATE MULTISET TABLE irs_returns (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
-)
-PRIMARY INDEX ( return_id );
-
-BEGIN LOADING irs_returns
- ERRORFILES irs_returns_err1, irs_returns_err2;
- CHECKPOINT 10000;
- RECORD 2;
- SET RECORD VARTEXT ",";
-
- DEFINE in_return_id (VARCHAR(19)),
- in_filing_type (VARCHAR(5)),
- in_ein (VARCHAR(19)),
- in_tax_period (VARCHAR(19)),
- in_sub_date (VARCHAR(22)),
- in_taxpayer_name (VARCHAR(100)),
- in_return_type (VARCHAR(5)),
- in_dln (VARCHAR(19)),
- in_object_id (VARCHAR(19)),
- FILE = /tmp/index_2020.csv;
-
- INSERT INTO irs_returns (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );
-END LOADING;
-
-LOGOFF;To run our example in batch mode, simply save all instructions in a single file and run:
-fastload < file_with_instruction.fastloadFastload vs. NOSIn our case, the file is in an S3 bucket. That means, that we can use Native Object Storage (NOS) to ingest the data:
--- create an S3-backed foreign table
-CREATE FOREIGN TABLE irs_returns_nos
- USING ( LOCATION('/s3/s3.amazonaws.com/irs-form-990/index_2020.csv') );
-
--- load the data into a native table
-CREATE MULTISET TABLE irs_returns_nos_native
- (RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME)
-AS (
- SELECT RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME FROM irs_returns_nos
-) WITH DATA
-NO PRIMARY INDEX;The NOS solution is convenient as it doesn’t depend on additional tools. It can be implemented using only SQL. It performs well, especially for Vantage deployments with a high number of AMPs as NOS tasks are delegated to AMPs and run in parallel. Also, splitting the data in object storage into multiple files may further improve performance.
-This how-to demonstrated how to ingest large amounts of data into Vantage. We loaded hundreds of thousands or records into Vantage in a couple of seconds using Fastload.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This post demonstrates how you can leverage any geographic dataset in GeoJson format and use it for geospatial analytics in Teradata Vantage, with just a few lines of code.
-Today we be gathering reference geographical data (official maps, points of interest, etc…) form public sources and use it to support our day to day analytics.
-You will learn two methods to get your GeoJson data into Teradata Vantage:
-Load it as a single document and use native ClearScape analytics functions to parse it into a table usable for analytics.
-Lightly transform it in native Python as we load it into Vantage to produce an analytics ready dataset.
-The first method is a straig forward ELT pattern for semi-structured format processing in Vantage with a single SQL statement, the second one involves some lightweight preparation in (pure) Python and may allow more flexibility (for example to add early quality checks or optimize the load of large documents).
-You will need:
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
A Python 3 interpreter
-A SQL Client
-Here we will load a GeoJson document as a single Character Large OBject (CLOB) into the Vantage Data Store and use a single SQL statement, backed by ClearScape Analytics native functions, to parse this document into a usable structure for geospatial analytics.
-The http://geojson.xyz/ website is a fantastic source for open geographical data in GeoJson format. We will load the "Populated Places" dataset that provides with a list of over 1000 significant world cities.
-Open you favourite Python 3 interpreter and make sure you have the following packages installed:
-wget
-teradatasql
-getpass
-Download and read the cities dataset:
-import wget
-world_cities=wget.download('https://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_50m_populated_places.geojson')
-with open(world_cities) as geo_json:
- jmap = jmap = geo_json.read()Modify this code as needed with your Vantage host name, user name and specify an advanced login mechanism if any (eg. LDAP, Kerberos…) with the logmech parameter if you need to. -All the connection parameters are documented on the teradatasql PyPi page there: https://pypi.org/project/teradatasql/
-The code below simply creates a Vantage connection, and opens a cursor creating a table and loading it with our file.
-import teradatasql
-import getpass
-tdhost='<Your-Vantage-System-HostName-Here>'
-tdUser='<Your-Vantage-User-Name-Here>'
-
-# Create a connection to Teradata Vantage
-con = teradatasql.connect(None, host=tdhost, user=tdUser, password=getpass.getpass())
-
-# Create a table named geojson_src and load the JSON map into it as a single CLOB
-with con.cursor () as cur:
- cur.execute ("create table geojson_src (geojson_nm VARCHAR(32), geojson_clob CLOB CHARACTER SET UNICODE);")
- r=cur.execute ("insert into geojson_src (?, ?)", ['cities',jmap])Now open your favourite SQL client and connect to your Vantage system.
-We will use ClearScape analytics JSON functions to parse our GeoJson document and extract the most relevant properties and the geometry itself (the coordinates of the city) for each feature (each feature representing a city in this example). -We then use the GeomFromGeoJSON function to cast our geometry as a native Vantage geometry data type (ST_GEOMETRY).
-For user convenience, will wrap all this SQL code in a view:
-REPLACE VIEW cities_geo AS
-SEL city_name, country_name, region_name, code_country_isoa3, GeomFromGeoJSON(geom, 4326) city_coord
-FROM JSON_Table
-(ON (
- SEL
- geojson_nm id
- ,cast(geojson_clob as JSON) jsonCol
- FROM geojson_src where geojson_nm='cities'
-)
-USING rowexpr('$.features[*]')
- colexpr('[ {"jsonpath" : "$.geometry",
- "type" : "VARCHAR(32000)"},
- {"jsonpath" : "$.properties.NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.SOV0NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.ADM1NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.SOV_A3",
- "type" : "VARCHAR(50)"}]')
-) AS JT(id, geom, city_name, country_name, region_name, code_country_isoa3);That’s all, you can now view the prepared geometry data as a table, ready to enrich your analytics:
-SEL TOP 5 * FROM cities_geo;Result:
-| city_name | -country_name | -region_name | -code_country_isoa3 | -city_coord | -
|---|---|---|---|---|
Potenza |
-Italy |
-Basilicata |
-ITA |
-POINT (15.798996495640267 40.642002130098206) |
-
Mariehamn |
-Finland |
-Finström |
-ALD |
-POINT (19.949004471869102 60.096996184895431) |
-
Ramallah |
-Indeterminate |
-- | PSE |
-POINT (35.206209378189556 31.902944751424059) |
-
Poitier |
-French Republic |
-Poitou-Charentes |
-FRA |
-POINT (0.333276528534554 46.583292255736581) |
-
Clermont-Ferrand |
-French Republic |
-Auvergne |
-FRA |
-POINT (3.080008095928406 45.779982115759424) |
-
Calculate the distance between two cities:
-SEL b.city_coord.ST_SphericalDistance(l.city_coord)
-FROM
-(SEL city_coord FROM cities_geo WHERE city_name='Bordeaux') b
-CROSS JOIN (SEL city_coord FROM cities_geo WHERE city_name='Lvov') lResult:
-city_coord.ST_SPHERICALDISTANCE(city_coord) |
-
1.9265006861079421e+06 |
-
The previous example demonstrated how to load a complete document as a large object into Teradata Vantage and use built in analytic functions to parse it into a usable dataset.
-This is convenient but limited: we need to parse this document every time we need to use it, as the original document is not directly usable for analytics, JSON documents are currently limited to 16MB in Vantage and it may be inconvenient to fix data quality or formatting issues within the document stored as a CLOB.
-In this example, we will parse our JSON document using the Python json package and load it as a table that can be used directly and efficiently for analysis.
-Python json and list manipulation functions, along with the Teradata SQL driver for Python make this process really simple and efficient.
-For this example, we will use the boundaries of the world countries available on https://datahub.io.
-Let’s get into it.
-Open you favourite Python 3 interpreter and make sure you have the following packages installed:
-wget
-teradatasql
-getpass
-import wget
-countries_geojson=wget.download('https://datahub.io/core/geo-countries/r/countries.geojson')import json -with open(countries_geojson) as geo_json: - countries_json = json.load(geo_json)
-The good thing about loading this JSON in memory, if you are using an interactive Python terminal, is that you can now explore the document to understand its structure. For example
-print(countries_json.keys())
-print(countries_json['type'])
-print(countries_json['features'][0]['properties'].keys())
-print(countries_json['features'][0]['geometry']['coordinates'])What we have here is a collection of GeoFeatures (as earlier).
-We will now lightly model this data in a Vantage table, for that:
-We will load each feature as a raw.
-We will extract the properties that look interesting for immediate analysis (in our example, the country name and ISO code).
-We will extract the geometry itself and load it as a separate column.
-To load a set of rows with a teradatasql cursor, we need to represent each row as an array (or tuples) of values, and the complete dataset as an array of all the row-arrays. -This is fairly easy to do as a list comprehension
-For example:
-[(f['properties']['ADMIN'], f['properties']['ISO_A3'], f['geometry']) for f in countries_json['features'][:1]]NB: Not featured here, but recommended for richer datasets, consider loading the entire and original feature payload as a separate column (this is a JSON document). This will allow you to go back to the original record and extract new properties that you may have missed during your first analysis but have become relevant, directly in SQL and without having to reload the file entirely.
-Modify this code as needed with your Vantage host name, user name and specify an advanced login mechanism if any (eg. LDAP, Kerberos…) with the logmech parameter if you need to. -All the connection parameters are documented on the teradatasql PyPi page there: https://pypi.org/project/teradatasql/
-The code below simply creates a Vantage connection, and opens a cursor creating a table and loading it with our list.
-import teradatasql
-import getpass
-tdhost='<Your-Vantage-System-HostName-Here>'
-tdUser='<Your-Vantage-User-Name-Here>'
-
-# Create a connection to Teradata Vantage
-con = teradatasql.connect(None, host=tdhost, user=tdUser, password=tdPassword)
-
-# Create a table and load our country names, codes, and geometries.
-with con.cursor () as cur:
- cur.execute ("create table stg_countries_map (country_nm VARCHAR(32), ISO_A3_cd VARCHAR(32), boundaries_geo CLOB CHARACTER SET UNICODE);")
- r=cur.execute ("insert into stg_countries_map (?, ?, ?)", [(f['properties']['ADMIN'], f['properties']['ISO_A3'], str(f['geometry'])) for f in countries_json['features']])The code below performs the table creation from the Python interpreter, you can also run the sql statement defined below in your prefered SQL client you might as well simply define this logic as a SQL view to avoid having to refresh this table.
-We will use ClearScape analytics the GeomFromGeoJSON function to cast our geometry as a native Vantage geometry data type (ST_GEOMETRY).
-# Now create our final reference table, casting the geometry CLOB as a ST_GEOMETRY object
-sql='''
-CREATE TABLE ref_countries_map AS
-(
-SEL
-ISO_A3_cd
-,country_nm
-,GeomFromGeoJSON(boundaries_geo, 4326) boundaries_geo
-FROM stg_countries_map
-) WITH DATA
-'''
-
-WITH con.cursor () AS cur:
- cur.execute (sql)That’s all, you may now query your tables using your favourite SQL client and Teradata’s excellent Geospatial data types and analytic functions.
-For example, using the two datasets we have loaded during this tutorial, check in what countries are
-SEL cty.city_name, cty.city_coord, ctry.country_nm
-FROM cities_geo cty
-LEFT JOIN ref_countries_map ctry
- ON ctry.boundaries_geo.ST_Contains(cty.city_coord)=1
-WHERE cty.city_name LIKE 'a%'city_name |
-city_coord |
-country_nm |
-
Acapulco |
-POINT (-99.915979046410712 16.849990864016206) |
-Mexico -Aosta |
-
POINT (7.315002595706176 45.737001067072299) |
-Italy -Ancona |
-POINT (13.499940550397127 43.600373554552903) |
-
Italy -Albany |
-POINT (117.891604776075155 -35.016946595501224) |
-Australia |
-
Note that none of the above code does not implement any control procedure or checks to, for example, manage the state of the target tables, manage locking, control error codes, etc… This is meant to be a demonstrations of the available features to acquire and use geospatial reference data.
-Consider using SQLAlchemy ORM if you are defining your pipeline in Python, dbt, or your favorite ELT and orchestration toolset to create your products you can operationalize.
-You now can know how to get any open geographic dataset and use it to augment your analytics with Teradata Vantage!
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
ClearScape AnalyticsTM is a powerful analytics engine in Teradata VantageCloud. It delivers breakthrough performance, value, and growth across the enterprise with the most powerful, open and connected AI/ML capabilities on the market. You can experience ClearClearScape AnalyticsTM and Teradata Vantage, in a non-production setting, through ClearScape Analytics Experience.
-In this how-to we will go through the steps for creating an environment in ClearScape Analytics Experience and access demos.
-
-Head over to ClearScape Analytics Experience and create a free account.
-
-Sign in to your ClearScape Analytics account to create an environment and access demos.
-
-Once signed in, click on CREATE ENVIRONMENT
-
-You will need to provide:
-| Variable | -Value | -
|---|---|
environment name |
-A name for your environment, e.g. "demo" |
-
database password |
-A password of your choice, this password will be assigned to |
-
Region |
-Select a region from the dropdown |
-
| - - | --Note down the database password. You will need it to connect to the database. - | -
-Click on CREATE button to complete the creation of your environment and now, you can see details of your environment.
-
-The ClearScape Analytics Experience environment includes a variety of demos that showcase how to use analytics to solve business problems across many industries.
To access demos, click on RUN DEMOS USING JUPYTER button. It will open a Jupyter environment in a new tab of your browser.
| - - | --You can find all the detail of demos on the demo index page. - | -
-In this quick start, we learned how to create an environment in ClearScape Analytics Experience and access demos.
-Teradata VantageCloud Lake is Teradata’s next-generation, cloud-native analytics and data platform. It provides lakehouse deployment patterns along with the ability to run independent elastic workloads using an object storage-centric design.
-It empowers organizations to unlock their data, activate analytics, and accelerate value. Customers can optimize their analytics environment using specially configured compute cluster resources that best accommodate their workload requirements.
-VantageCloud Lake provides all the benefits you’d expect in a cloud solution plus Teradata’s differentiated technology stack, including the industry-leading Analytics Database, ClearScape Analytics, and QueryGrid data fabric.
-| - - | --To get a VantageCloud Lake sign-on link and credentials, fill the contact form to reach out to Teradata team. - | -
Go to the URL provided by Teradata, for example, ourcompany.innovationlabs.teradata.com and sign on:
-Existing customers can use their organization admin username(email address) and password to sign on.
-New customer can sign on with their organization admin username (from welcome letter: email address) and the password you created.
-| - - | --Click here to reset the organization admin password. - | -
-The signing on takes you to VantageCloud Lake welcome page.
-
-The Welcome page has navigation menu that not only gives you a complete control of your environments but also provides you various necessary tools:
-
-Vantage - Home page of VantageCloud Lake portal
-Environments - Create your environments and see all the created environments
-Organization - View organizations configuration, manage Organization Admins and view the configuration and status of your account
-Consumption - Monitor how your organization consumes compute and storage resources
-Cost Calculator - Calculate the cost and consumption of your environment and whole organization.
-Queries - Inspect an environment’s queries to understand their efficiency.
-Editor - Create and run queries in an editor.
-Data Copy - Provision, configure and run data copy (also known as Data Mover) jobs from VantageCloud Lake Console.
-To create a primary cluster environment, click on "Environments" on the navigation menu. In a new opened view, click on "Create" button situated on the top right of the page.
-
-Fill out the Environment configuration fields:
-| Item | -Description | -
|---|---|
Environment name |
-A contextual name for new environment |
-
Region |
-The available region list was predetermined during the sales process. |
-
Package |
-There are two service packages available to select from: |
-
-| - - | --The Consumption estimates, to your right, provide guidance for configuring the environment. See Using the Consumption Estimates for more detail. - | -
Fill out the Primary cluster configuration fields:
-| Item | -Description | -||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Instance size |
-
-
-Select an instance size suitable for your use-case:
|
-||||||||||||||||||||||||||||||||
Instance count |
-
- 2 to 64 |
-||||||||||||||||||||||||||||||||
Instance storage |
-
- 1 to 72TB per instance - |
-
-Fill out the Database credential fields:
-| Item | -Description | -
|---|
-To quickly get started, you can select Use Defaults or define the additional option settings.
-
-| Item | -Description | -
|---|---|
AMPs per instance |
-Workload management |
-
AWS: Storage encryption |
-Configure encryption for customer data. See Finding the key ID and key ARN |
-
-Review all the information and click on CREATE ENVIRONMENT button.
-
-The deployment takes few minutes. Once complete, created environment can be found in Environments section as a card view(name of environment is quickstart_demo).
-
-The created environment is accessible through console only. To change that, click on created environment and go to SETTINGS tab.
-
-In the SETTINGS, select the Internet connection checkbox and provide the IP addresses in CIDR format (for example, 192.168.2.0/24 specifies all IP addresses in the range: 192.168.2.0 to 192.168.2.255) with which you would want to access your environment.
-| - - | --Find more information on setting up an internet connection here. - | -
-Click on the SAVE button situated on right top of the page to confirm changes.
Go back to the Environments section and check your environment card. It has Public internet access now.
-
-In this quick start we learned how to create an environment in VantageCloud Lake and allow it to be accessed from public internet.
-| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to shows how to gain access to a Teradata database by running it on your local machine. Once you finish the steps you will have a working Teradata Vantage Express database on your computer.
-| - - | --Starting with version 17.20, Vantage Express includes the following analytics packages: Vantage Analytics Library, Bring Your Own Model (BYOM), API Integration with AWS SageMaker. - | -
A Mac computer. Both Intel and M1/2 chips are supported.
-| - - | --Vantage Express runs on x86 architecture. When you run the VM on M1/2 chips, UTM has to emulate x86. This is significantly slower then virtualization. If you determine that Vantage Express on M1/M2 is too slow for your needs, consider running Vantage Express in the cloud: AWS, Azure, Google Cloud. - | -
30GB of disk space and enough CPU and RAM to be able to dedicate at least one core and 4GB RAM to the virtual machine.
-Admin rights to be able to install and run the software.
-| - - | --No admin rights on your local machine? Have a look at how to run Vantage Express in AWS, Azure, Google Cloud. - | -
The latest version of Vantage Express. If you have not used the Teradata downloads website before, you will need to register.
-The latest version of UTM.
-Install UTM by running the installer and accepting the default values.
-Go to the directory where you downloaded Vantage Express and unzip the downloaded file.
-Start UTM, click on the + sign and select Virtualize (for Intel Macs) or Emulate (for M1 Macs).
On Operating System screen select Other.
On Other screen select Skip ISO Boot.
On Hardware screen allocate at least 4GB of memory and at least 1 CPU core. We recommend 10GB RAM and 2 CPUs.
-On Storage screen accept the defaults by clicking Next.
On Shared Direct screen click Next.
On Summary screen check Open VM Settings and click Save.
Go through the setup wizard. You only need to adjust the following tabs:
-QEMU - disable UEFI Boot option
Network - expose ssh (22) and Vantage (1025) ports on the host computer:
-
-Map drives:
-Delete the default IDE Drive.
Map the 3 Vantage Express drives by importing the disk files from the downloaded VM zip file. Make sure you map them in the right order, -disk1, -disk2, -disk3 . The first disk is bootable and contains the database itself. Disks 2 and 3 are so called pdisks and contain data. As you import the files UTM will automatically convert them fro vmdk into qcow2 format. Make sure that each disk is configured using the IDE interface:
-Once you are done mapping all 3 drives, your configuration should look like this:
-
-Save the configuration and start the VM.
-Press ENTER to select the highlighted LINUX boot partition.
-On the next screen, press ENTER again to select the default SUSE Linux kernel.
-
-After completing the bootup sequence a terminal login prompt as shown in the screenshot below will appear. Don’t enter anything in the terminal. Wait till the system starts the GUI.
-
-After a while the following prompt will appear - assuming that you did not enter anything after the command login prompt above. Press okay button in the screen below.
-Once the VM is up, you will see its desktop environment. When prompted for username/password enter root for both.
-The database is configured to autostart with the VM. To confirm that the database has started go to the virtual desktop and start Gnome Terminal.
-In the terminal execute pdestate command that will inform you if Vantage has already started:
| - - | --To paste into Gnome Terminal press SHIFT+CTRL+V. - | -
watch pdestate -aYou want to wait till you see the following message:
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate returns when the database is still initializing.PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
Now that the database is up, go back to the virtual desktop and launch Teradata Studio Express.
-When you first start it you will be offered a tour. Once you close the tour, you will see a wizard window to add a new connection. Select Teradata:
-On the next screen, connect to the database on your localhost using dbc for the username and password:
-We will now run some queries in the VM. To avoid copy/paste issues between the host and the VM, we will open this quick start in the VM. Go to the virtual desktop, start Firefox and point it to this quick start.
-Once in Teradata Studio Express, go to Query Development perspective (go to the top menu and select Window → Query Development).
Connect using the previously created connection profile by double-clicking on Database Connections → New Teradata.
Using dbc user, we will create a new database called HR. Copy/paste this query and run it by hitting the run query button (
) or pressing F5 key:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
In this guide we have covered how to quickly create a working Teradata environment. We used Teradata Vantage Express in a VM running on VMware. In the same VM, we ran Teradata Studio Express to issue queries. We installed all software locally and didn’t have to pay for cloud resources.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to shows how to gain access to a Teradata database by running it on your local machine. Once you finish the steps you will have a working Teradata Vantage Express database on your computer.
-| - - | --Starting with version 17.20, Vantage Express includes the following analytics packages: Vantage Analytics Library, Bring Your Own Model (BYOM), API Integration with AWS SageMaker. - | -
A computer using one of the following operating systems: Windows 10, Linux or Intel-based MacOS.
-| - - | --For M1/M2 MacOS systems, see Run Vantage Express on UTM. - | -
30GB of disk space and enough CPU and RAM to be able to dedicate at least one core and 6GB RAM to the virtual machine.
-Admin rights to be able to install and run the software.
-The latest version of Vantage Express VirtualBox Open Virtual Appliance (OVA).
-| - - | --If you have not used the Teradata Downloads website before, you will need to register first. - | -
VirtualBox, version 6.1.
-| - - | -
-You can also install VirtualBox using brew and other package managers.
- |
-
Install VirtualBox by running the installer and accepting the default values.
-| - - | --VirtualBox includes functionality that requires elevated privileges. When you start VirtualBox for the first time, you will be asked to confirm this elevated access. You may also need to reboot your machine to activate the VirtualBox kernel plugin. - | -
Start VirtualBox.
-Go to File → Import Appliance… menu.
In File field, select the downloaded OVA file.
On the next screen, accept the defaults and click on Import.
Back in the main VirtualBox panel, start the Vantage Express appliance double clicking on VM Vantage 17.20.
-Press ENTER to select the highlighted LINUX boot partition.
-On the next screen, press ENTER again to select the default SUSE Linux kernel.
-
-After completing the bootup sequence a terminal login prompt as shown in the screenshot below will appear. Don’t enter anything in the terminal. Wait till the system starts the GUI.
-
-After a while the following prompt will appear - assuming that you did not enter anything after the command login prompt above. Press okay button in the screen below.
-Once the VM is up, you will see its desktop environment. When prompted for username/password enter root for both.
-The database is configured to autostart with the VM. To confirm that the database has started go to the virtual desktop and start Gnome Terminal.
-In the terminal execute pdestate command that will inform you if Vantage has already started:
| - - | --To paste into Gnome Terminal press SHIFT+CTRL+V. - | -
watch pdestate -aYou want to wait till you see the following message:
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate returns when the database is still initializing.PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
Now that the database is up, go back to the virtual desktop and launch Teradata Studio Express.
-When you first start it you will be offered a tour. Once you close the tour, you will see a wizard window to add a new connection. Select Teradata:
-On the next screen, connect to the database on your localhost using dbc for the username and password:
-Once in Teradata Studio Express, go to Query Development perspective (go to the top menu and select Window → Query Development).
Connect using the previously created connection profile by double-clicking on Database Connections → New Teradata.
Using dbc user, we will create a new database called HR. Copy/paste this query and run it by hitting the run query button () or pressing F5 key:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VirtualBox Guest Extensions is a piece of software that runs in a VM. It makes the VM run faster on VirtualBox. It also improves the resolution of the VM screen and its responsiveness to resizing. It implements two-way clipboard, and drag and drop between the host and the guest. VirtualBox Guest Extensions in the VM needs to match the version of your VirtualBox install. You will likely have to update VirtualBox Guest Extensions for optimal performance.
-To update VirtualBox Guest Extensions:
-Insert the VirtualBox Guest Extensions DVD by clicking on SATA Port 3: [Optical Drive] in Storage section:
-Back in the VM window, start the Gnome Terminal application.
Run the following command in the terminal:
-mount /dev/cdrom /media/dvd; /media/dvd/VBoxLinuxAdditions.runIn this guide we have covered how to quickly create a working Teradata environment. We used Teradata Vantage Express in a VM running on VMware. In the same VM, we ran Teradata Studio Express to issue queries. We installed all software locally and didn’t have to pay for cloud resources.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to shows how to gain access to a Teradata database by running it on your local machine. Once you finish the steps you will have a working Teradata Vantage Express database on your computer.
-| - - | --Starting with version 17.20, Vantage Express includes the following analytics packages: Vantage Analytics Library, Bring Your Own Model (BYOM), API Integration with AWS SageMaker. - | -
A computer using one of the following operating systems: Windows, Linux or Intel-based MacOS.
-| - - | --For M1/M2 MacOS systems, see Run Vantage Express on UTM. - | -
30GB of disk space and enough CPU and RAM to be able to dedicate at least one core and 6GB RAM to the virtual machine.
-Admin rights to be able to install and run the software.
-The latest version of Vantage Express. If you have not used the Teradata downloads website before, you will need to register.
-| - - | --Commercial organizations require commercial licenses to use VMware Workstation Player. If you don’t want to acquire VMware licenses you can run Vantage Express on VirtualBox. - | -
| - - | --VMware doesn’t offer VMware Workstation Player for MacOS. If you are on a Mac, you will need to install VMware Fusion instead. It’s a paid product but VMware offers a free 30-day trial. Alternatively, you can run Vantage Express on VirtualBox or UTM. - | -
On Windows, you will also need 7zip to unzip Vantage Express.
-Install VMware Player or VMware Fusion by running the installer and accepting the default values.
-If on Windows, install 7zip.
Go to the directory where you downloaded Vantage Express and unzip the downloaded file.
-Double-click on the .vmx file. This will start the VM image in VMware Player/Fusion.
Press ENTER to select the highlighted LINUX boot partition.
-On the next screen, press ENTER again to select the default SUSE Linux kernel.
-
-After completing the bootup sequence a terminal login prompt as shown in the screenshot below will appear. Don’t enter anything in the terminal. Wait till the system starts the GUI.
-
-After a while the following prompt will appear - assuming that you did not enter anything after the command login prompt above. Press okay button in the screen below.
-Once the VM is up, you will see its desktop environment. When prompted for username/password enter root for both.
-The database is configured to autostart with the VM. To confirm that the database has started go to the virtual desktop and start Gnome Terminal.
-In the terminal execute pdestate command that will inform you if Vantage has already started:
| - - | --To paste into Gnome Terminal press SHIFT+CTRL+V. - | -
watch pdestate -aYou want to wait till you see the following message:
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate returns when the database is still initializing.PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
Now that the database is up, go back to the virtual desktop and launch Teradata Studio Express.
-When you first start it you will be offered a tour. Once you close the tour, you will see a wizard window to add a new connection. Select Teradata:
-On the next screen, connect to the database on your localhost using dbc for the username and password:
-We will now run some queries in the VM. To avoid copy/paste issues between the host and the VM, we will open this quick start in the VM. Go to the virtual desktop, start Firefox and point it to this quick start.
-Once in Teradata Studio Express, go to Query Development perspective (go to the top menu and select Window → Query Development).
Connect using the previously created connection profile by double-clicking on Database Connections → New Teradata.
Using dbc user, we will create a new database called HR. Copy/paste this query and run it by hitting the run query button () or pressing F5 key:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
In this guide we have covered how to quickly create a working Teradata environment. We used Teradata Vantage Express in a VM running on VMware. In the same VM, we ran Teradata Studio Express to issue queries. We installed all software locally and didn’t have to pay for cloud resources.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
- 
- Didn’t find what you were looking for?
- |
- - Contribute or request a topic - | -- Request - Contribute - | -
This how-to goes through the installation of Teradata Studio and Teradata Studio Express on Apple Mac M1/M2 machines.
-Install and enable Rosetta binary translator. Follow the Apple Mac Rosetta Installation Guide.
-Download and Install a x86 64-bit based JDK 11 from your preferred vendor. For example, you can download x86 64-bit JDK 11 from Azul
-Download the latest Teradata Studio or Teradata Studio Express release from the Teradata Downloads page:
-Install the Teradata Studio/Teradata Studio Express. Refer to Teradata Studio and Teradata Studio Express Installation Guide for details.
-Apple has introduced ARM-based processors in Apple MAC M1/M2 machines. Intel x64-based applications won’t work by default on ARM-based processors. Teradata Studio or Teradata Studio Express also doesn’t work by default as the current Studio macOS build is an intel x64-based application. This how-to demonstrates how to install Intel x64-based JDK and Teradata Studio or Teradata Studio Express on Apple Mac M1/M2.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細については、Teradataサポートに連絡してください。 - | -
AWSリソースへのアクセスを提供するために必要な権限を持つポリシーを設定します。ワークスペース サービスをデプロイしているアカウントに、IAM ロールまたは IAM ポリシーを作成するための十分な IAM 権限がない場合、組織管理者はロールとポリシーを定義して、それらをワークスペース サービス テンプレートに付与することができます。
-この記事には、新しいIAMロールに必要なサンプルIAMポリシーが含まれています。
-これらのポリシーは、 Security & Identity > Identity & Access Management > Create Policyで設定します。詳細な手順については、 「ロールの作成とポリシーのアタッチ (コンソール) - AWS Identity and Access Management」 を参照してください。
-以下の JSON サンプルには、AI Unlimited インスタンスを作成するために必要な権限が含まれており、エンジン用のクラスタ固有の IAM ロールとポリシーを作成する権限をワークスペース サービスに付与します。
-
- 
- 
- 
- 
- 
- {
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "iam:PassRole",
- "iam:AddRoleToInstanceProfile",
- "iam:CreateInstanceProfile",
- "iam:CreateRole",
- "iam:DeleteInstanceProfile",
- "iam:DeleteRole",
- "iam:DeleteRolePolicy",
- "iam:GetInstanceProfile",
- "iam:GetRole",
- "iam:GetRolePolicy",
- "iam:ListAttachedRolePolicies",
- "iam:ListInstanceProfilesForRole",
- "iam:ListRolePolicies",
- "iam:PutRolePolicy",
- "iam:RemoveRoleFromInstanceProfile",
- "iam:TagRole",
- "iam:TagInstanceProfile",
- "ec2:TerminateInstances",
- "ec2:RunInstances",
- "ec2:RevokeSecurityGroupEgress",
- "ec2:ModifyInstanceAttribute",
- "ec2:ImportKeyPair",
- "ec2:DescribeVpcs",
- "ec2:DescribeVolumes",
- "ec2:DescribeTags",
- "ec2:DescribeSubnets",
- "ec2:DescribeSecurityGroups",
- "ec2:DescribePlacementGroups",
- "ec2:DescribeNetworkInterfaces",
- "ec2:DescribeLaunchTemplates",
- "ec2:DescribeLaunchTemplateVersions",
- "ec2:DescribeKeyPairs",
- "ec2:DescribeInstanceTypes",
- "ec2:DescribeInstanceTypeOfferings",
- "ec2:DescribeInstances",
- "ec2:DescribeInstanceAttribute",
- "ec2:DescribeImages",
- "ec2:DescribeAccountAttributes",
- "ec2:DeleteSecurityGroup",
- "ec2:DeletePlacementGroup",
- "ec2:DeleteLaunchTemplate",
- "ec2:DeleteKeyPair",
- "ec2:CreateTags",
- "ec2:CreateSecurityGroup",
- "ec2:CreatePlacementGroup",
- "ec2:CreateLaunchTemplateVersion",
- "ec2:CreateLaunchTemplate",
- "ec2:AuthorizeSecurityGroupIngress",
- "ec2:AuthorizeSecurityGroupEgress",
- "secretsmanager:CreateSecret",
- "secretsmanager:DeleteSecret",
- "secretsmanager:DescribeSecret",
- "secretsmanager:GetResourcePolicy",
- "secretsmanager:GetSecretValue",
- "secretsmanager:PutSecretValue",
- "secretsmanager:TagResource"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}以下の JSON サンプルには、AI Unlimited インスタンスの作成に必要な権限が含まれています。アカウントの制限により、ワークスペース サービスが IAM ロールとポリシーを作成できない場合は、エンジンに渡すポリシーを IAM ロールに付与する必要があります。この場合、以下の変更されたワークスペース サービス ポリシーを使用できます。これには、IAM ロールまたは IAM ポリシーを作成する権限が含まれていません。
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "iam:PassRole",
- "iam:AddRoleToInstanceProfile",
- "iam:CreateInstanceProfile",
- "iam:DeleteInstanceProfile",
- "iam:GetInstanceProfile",
- "iam:GetRole",
- "iam:GetRolePolicy",
- "iam:ListAttachedRolePolicies",
- "iam:ListInstanceProfilesForRole",
- "iam:ListRolePolicies",
- "iam:PutRolePolicy",
- "iam:RemoveRoleFromInstanceProfile",
- "iam:TagRole",
- "iam:TagInstanceProfile",
- "ec2:TerminateInstances",
- "ec2:RunInstances",
- "ec2:RevokeSecurityGroupEgress",
- "ec2:ModifyInstanceAttribute",
- "ec2:ImportKeyPair",
- "ec2:DescribeVpcs",
- "ec2:DescribeVolumes",
- "ec2:DescribeTags",
- "ec2:DescribeSubnets",
- "ec2:DescribeSecurityGroups",
- "ec2:DescribePlacementGroups",
- "ec2:DescribeNetworkInterfaces",
- "ec2:DescribeLaunchTemplates",
- "ec2:DescribeLaunchTemplateVersions",
- "ec2:DescribeKeyPairs",
- "ec2:DescribeInstanceTypes",
- "ec2:DescribeInstanceTypeOfferings",
- "ec2:DescribeInstances",
- "ec2:DescribeInstanceAttribute",
- "ec2:DescribeImages",
- "ec2:DescribeAccountAttributes",
- "ec2:DeleteSecurityGroup",
- "ec2:DeletePlacementGroup",
- "ec2:DeleteLaunchTemplate",
- "ec2:DeleteKeyPair",
- "ec2:CreateTags",
- "ec2:CreateSecurityGroup",
- "ec2:CreatePlacementGroup",
- "ec2:CreateLaunchTemplateVersion",
- "ec2:CreateLaunchTemplate",
- "ec2:AuthorizeSecurityGroupIngress",
- "ec2:AuthorizeSecurityGroupEgress",
- "secretsmanager:CreateSecret",
- "secretsmanager:DeleteSecret",
- "secretsmanager:DescribeSecret",
- "secretsmanager:GetResourcePolicy",
- "secretsmanager:GetSecretValue",
- "secretsmanager:PutSecretValue",
- "secretsmanager:TagResource"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}以下の JSON サンプルには、AWS Session Manager と対話するために必要な権限が含まれています。AWS Session Manager を使用してインスタンスに接続する場合は、このポリシーを IAM ロールに付与する必要があります。
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": [
- "ssm:DescribeAssociation",
- "ssm:GetDeployablePatchSnapshotForInstance",
- "ssm:GetDocument",
- "ssm:DescribeDocument",
- "ssm:GetManifest",
- "ssm:ListAssociations",
- "ssm:ListInstanceAssociations",
- "ssm:PutInventory",
- "ssm:PutComplianceItems",
- "ssm:PutConfigurePackageResult",
- "ssm:UpdateAssociationStatus",
- "ssm:UpdateInstanceAssociationStatus",
- "ssm:UpdateInstanceInformation"
- ],
- "Resource": "*",
- "Effect": "Allow"
- },
- {
- "Action": [
- "ssmmessages:CreateControlChannel",
- "ssmmessages:CreateDataChannel",
- "ssmmessages:OpenControlChannel",
- "ssmmessages:OpenDataChannel"
- ],
- "Resource": "*",
- "Effect": "Allow"
- },
- {
- "Action": [
- "ec2messages:AcknowledgeMessage",
- "ec2messages:DeleteMessage",
- "ec2messages:FailMessage",
- "ec2messages:GetEndpoint",
- "ec2messages:GetMessages",
- "ec2messages:SendReply"
- ],
- "Resource": "*",
- "Effect": "Allow"
- }
- ]
-}ワークスペース サービスにクラスタ固有のロールの作成を認証する代わりに、Teradata AI Unlimited IAM ロールを新しいエンジンに渡す場合は、以下の JSON サンプルを出発点としてポリシーを作成できます。
-{
- "Version": "2012-10-17",
- "Statement": [
- {
- "Action": "secretsmanager:GetSecretValue",
- "Effect": "Allow",
- "Resource": [
- "arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/*"
- ]
- }
- ]
-}ワークスペース サービスがエンジンのポリシーを作成する場合、ポリシーは以下のように制限されます。
-"Resource": ["arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/<CLUSTER_NAME>/<SECRET_NAME>"]IAM ロールとポリシーを指定する場合、クラスタ名を予測することはできません。この状況を回避するには、以下のような置換ポリシーでワイルドカードを使用できます。
-"arn:aws:secretsmanager:<REGION>:<ACCOUNT_ID>:secret:compute-engine/*"
-or
-"arn:aws:secretsmanager:<REGION>:111111111111:secret:compute-engine/*"
-or
-"arn:aws:secretsmanager:us-west-2:111111111111:secret:compute-engine/*"Teradata AI Unlimitedを使用すると、コンテナ、ポッド、またはノードのクラッシュや終了に関係なく、状態を持続させる必要があるエンジンを再デプロイできます。この機能には、永続的なストレージ、つまり、コンテナ、ポッド、またはノードの存続期間を超えて存続するストレージが必要です。Teradata AI Unlimited は、インスタンスのインスタンス ルート ボリュームを使用して、JupyterLab /userdata フォルダ、ワークスペース サービス データベース、および構成ファイルにデータを保存します。インスタンスをシャットダウン、再起動、またはスナップショットを作成して再起動しても、データは保持されます。ただし、インスタンスが終了すると、JupyterLabのデータとワークスペースサービスのデータベースが失われるため、その場でインスタンスを実行した場合に問題が発生する可能性があり、警告なしに削除される可能性があります。高度に永続的なインスタンスが必要な場合は、 UsePersistentVolume パラメータを有効にして、JupyterLab データとワークスペース サービス データベースを別のボリュームに移動します。
以下の推奨される永続ボリューム フローでは、ボリュームが再マウントされ、データが保持されます。
-UsePersistentVolume を New として、PersistentVolumeDeletionPolicy を Retainとして設定して、新しいデプロイメントを作成する。
スタック出力では、将来使用するためにvolume-idをメモする。
-インスタンスが終了するまで、インスタンスを構成して使用する。
-次回のデプロイでは、以下の設定を使用します。
-UsePersistentVolume を以下として設定 New
PersistentVolumeDeletionPolicy を以下として設定 Retain
ExistingPersistentVolumeId が以前のデプロイメントの volume-id に設定される
以前のデータでインスタンスを再作成する必要がある場合は、いつでも同じ設定でテンプレートを再起動できる。
-簡単なワークフローを実行して、Teradata AI Unlimited を開始します。Teradata AI Unlimitedを使用してJupyterLabでサンプルワークロードを実行する を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細については、Teradataサポートに連絡してください。 - | -
AI Unlimited JupyterLab は、既存の Teradata SQL Kernel マジック コマンドに加えて、以下のマジック コマンドをサポートします。 「 Teradata JupyterLab Getting Started Guide 」を参照してください。
-説明:ワークスペースサービスとバインドするための1回限りの設定。
-使用方法:
-%workspaces_config host=<RPC_Service_URL>, apikey=<Workspace_API_Key>, withtls=<T|F>構文規則：
-host: エンジン サービスの名前または IP アドレス。
-apikey: ワークスペース サービスの Profile ページからの API キー値。
-[オプション] withTLS: False (F) の場合、デフォルトのクライアント サーバー通信では TLS が使用されません。
-出力:
-Workspace configured for host=<RPC_Service_URL>-
説明:新しいプロジェクトを作成する。このコマンドは、GitHubアカウントにプロジェクト名を持つ新しいリポジトリも作成されます。設定は engine.yml ファイルに保存されます。
-使用方法:
-%project_create project=<Project_Name>, env=<CSP>, team=<Project_Team>構文規則：
-project: 作成されるプロジェクトの名前。
-env: プロジェクトがホストされるクラウド環境。値はaws、azure、gcp、またはvsphereを指定できます。現在のリリースでは、AWSとAzureがサポートされています。
-[オプション] team: プロジェクトで共同作業しているチームの名前。
-出力:
-Project <Project_Name> created-
説明:プロジェクトを削除する。
-| - - | --このコマンドを実行すると、Teradata AI Unlimitedを使用して作成されたオブジェクトを含むGitHubリポジトリが削除されます。 - | -
使用方法:
-%project_delete project=<Project_Name>, team=<Project_Team>構文規則：
-project: 削除されるプロジェクトの名前。
-[オプション] team: プロジェクトで共同作業しているチームの名前。
-出力:
-Project <Project_Name> deleted-
説明: プロジェクトの詳細をリストする。
-特定のプロジェクトの詳細を取得するには、project パラメータを使用します。パラメータを指定せずにコマンドを実行すると、すべてのプロジェクトがリストされます。
-使用方法:
-%project_list project=<Project_Name>構文規則：
-project: リストされるプロジェクトの名前。
-出力:
-
-説明: オブジェクト ストア認証情報を保存するための認証オブジェクトを作成する。
-エンジンをデプロイする前に、認証オブジェクトを作成する必要があります。認証の詳細は保持され、プロジェクトの再デプロイ時に組み込まれます。オプションで、エンジンのデプロイ後に CREATE AUTHORIZATION の SQL コマンドを使用して認証を手動で作成できます。この場合、認証の詳細は保持されません。
使用方法:
-%project_auth_create project=<Project_Name>, name=<Auth_Name>, key=<Auth_Key>, secret=<Auth_Secret>, region=<ObjectStore_Region>, token= <Session_Token>, role=<Role>, ExternalID=<External_ID>構文規則：
-project: プロジェクトの名前。
-name: オブジェクトストアの認証名。
-key: オブジェクト ストアの認証キー。
-secret: オブジェクト ストアの認証シークレット アクセス ID。
-region: オブジェクトストアのリージョン。 local はローカル オブジェクト ストアの場合です。
-[オプション] token: オブジェクト ストア アクセス用のセッション トークン。
-[オプション] role: ロールとその資格を引き受けることで、AWS アカウントから AWS リソースにアクセスするための IAM ユーザーまたはサービス アカウント。AWSリソースの所有者がロールを定義します。例: arn:aws:iam::00000:role/STSAssumeRole。
-ExternalID: オブジェクト ストアへのアクセスに使用される外部 ID。
-出力:
-Authorization 'name' created-
説明: オブジェクト ストアの認証を更新する。
-使用方法:
-%project_auth_update project=<Project_Name>, name=<Auth_Name>, key=<Auth_Key>, secret=<Auth_Secret>, region=<ObjectStore_Region>, token= <Session_Token>, role=<Role>, ExternalID=<External_ID>構文規則：
-project: プロジェクトの名前。
-name: オブジェクトストアの認証名。
-key: オブジェクト ストアの認証キー。
-[オプション] secret: オブジェクト ストアの認証シークレット アクセス ID。
-[オプション] region: オブジェクト ストアのリージョン。 local はローカル オブジェクト ストアの場合です。
-[オプション] token: オブジェクト ストア アクセス用のセッション トークン。
-[オプション] role: ロールとその資格を引き受けることで、AWS アカウントから AWS リソースにアクセスするための IAM ユーザーまたはサービス アカウント。AWSリソースの所有者がロールを定義します。例: arn:aws:iam::00000:role/STSAssumeRole。
-ExternalID: オブジェクト ストアへのアクセスに使用される外部 ID。
-出力:
-Authorization 'name' updated-
説明: オブジェクト ストアの認証を削除する。
-使用方法:
-%project_auth_delete project=<Project_Name>, name=<Auth_Name>構文規則：
-project: プロジェクトの名前。
-name: オブジェクトストアの認証名。
-出力:
-Authorization 'name' deleted-
説明: プロジェクトに対して作成されたオブジェクト ストア認証をリストする。
-使用方法:
-%project_auth_list project=<Project_Name>構文規則：
-project: プロジェクトの名前。
-出力:
-
-説明: プロジェクトのエンジンをデプロイする。デプロイのプロセスが完了するまでに数分かかります。デプロイメントが成功すると、パスワードが生成されます。
-使用方法:
-%project_engine_deploy project=<Project_Name>, size=<Size_of_Engine>, node=<Number_of_Nodes>, subnet=<Subnet_id>, region=<Region>, secgroups=<Security_Group>, cidrs=<CIDR>構文規則：
-project: プロジェクトの名前。
-size: エンジンのサイズ。値は以下のとおりです。
-small
-medium
-large
-extralarge
-[オプション] node: デプロイするエンジン ノードの数。デフォルト値は 1 です。
-[オプション] subnet: サービスからのデフォルト値がない場合にエンジンに使用されるサブネット。
-[オプション] region: サービスからのデフォルト値がない場合にエンジンに使用されるリージョン。
-[オプション]secgroups:各リージョンのVPCのセキュリティグループのリスト。セキュリティ グループを指定しない場合、エンジンは VPC のデフォルトのセキュリティ グループに自動的に関連付けられます。
-[オプション] cidr: エンジンに使用される CIDR アドレスのリスト。
-出力:
-Started deploying. -Success: Compute Engine setup, look at the connection manager-
-説明：作業が終わったらエンジンを停止する。
-使用方法:
-%project_engine_suspend <Project_Name>構文規則：
-project: プロジェクトの名前。
-出力:
-Started suspend. Success: connection removed -Success: Suspending Compute Engine-
説明: プロジェクトにデプロイされているエンジンの一覧表示します。
-使用方法:
-%project_engine_list project=<Project_Name>構文規則：
-project: プロジェクトの名前。
-出力:
-
-説明: プロジェクトに割り当てられた共同作業者の一覧表示します。
-使用方法:
-%project_user_list project=<Project_Name>構文規則：
-[オプション] project: プロジェクトの名前。
-出力:
-
-説明: エンジン内のプロジェクトのメタデータとオブジェクト定義をバックアップする。
-使用方法:
-%project_backup project=<Project_Name>構文規則：
-project: プロジェクトの名前。
-出力:
-Backup of the object definitions created-
説明:GitHubリポジトリからプロジェクトのメタデータとオブジェクト定義を復元する。
-使用方法:
-%project_restore project=<Project_Name>, gitref=<Git_Reference>構文規則：
-project: プロジェクトの名前。
-[オプション] gitref:Gitリファレンス。
-出力:
-Restore of the object definitions done-
説明: AI-Unlimited-Teradata SQL CE Kernel で提供されるマジックを一覧表示する。
-使用方法:
-%helpさらに、コマンドごとに詳細なヘルプメッセージを表示することもできます。
-使用方法:
-%help <command>| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細については、Teradataサポートに連絡してください。 - | -
AWS CloudFormation テンプレートは、AWS コンピューティング、ネットワーク、ストレージ、およびワークスペース サービスと JupyterLab を AWS にデプロイするために必要なその他のサービスを起動、設定、実行します。 -以下のいずれかの方法を使用して CloudFormation テンプレートをデプロイできます。
-ワークスペース サービスのダウンロードに追加料金はかかりません。 ただし、ワークスペース サービスとエンジンのデプロイ中に使用される AWS のサービスまたはリソースのコストはお客様の負担となります。 -AWS CloudFormation テンプレートには、カスタマイズできる設定パラメータが含まれています。インスタンス型などの設定の一部は、デプロイメントのコストに影響します。コストの見積もりについては、マーケットプレイスの契約ページを確認してください。
-ターミナル ウィンドウを開き、 Teradata AI Unlimited GitHub リポジトリ のクローンを作成します。このリポジトリには、ワークスペース サービスと JupyterLab をデプロイするためのサンプル CloudFormation テンプレートが含まれています。
-git clone https://github.com/Teradata/ai-unlimitedAWS アカウントをまだお持ちでない場合は、画面上の指示に従って、https://aws.amazon.comでアカウントを作成します。
-ワークスペース サービスをデプロイするアカウントに、IAM ロールまたは IAM ポリシーを作成するための十分な IAM アクセス権があることを確認してます。アカウントに必要なアクセス権がない場合は、組織の管理者に問い合わせてください。 カスタム権限とポリシーを使用してAWSのアクセスと権限を制御する を参照してください。
-ナビゲーション バーのリージョン セレクターを使用して、Teradata AI Unlimited ワークスペース サービスをデプロイする AWS リージョンを選択します。
-ワークスペース サービス インスタンスの起動後に SSH を使用して安全に接続するためのキー ペアを生成します。 Amazon EC2キーペアとLinuxインスタンス を参照してください。
-| - - | --あるいは、AWS Session Manager を使用してワークスペース サービス インスタンスに接続することもできます。その場合、session-manager.json ポリシーを IAM ロールに付与する必要があります。 カスタム権限とポリシーを使用してAWSのアクセスと権限を制御する を参照してください。ホスト OS へのアクセスが必要ない場合は、これらの接続方法のいずれも使用しないことを選択できます。 - | -
今回は、AWS で実行される Teradata AI Unlimited の Amazon Machine Image (AMI) サブスクリプションが必要です。Teradata AI Unlimitedのライセンスを取得するには、Teradataサポートに連絡してください。
-サブスクライブするには:
-AWSアカウントにログオンする。
-Teradata AI UnlimitedのAWSマーケットプレイスページを開き、Continue を選択する。
-エンジンイメージの利用規約を確認し、同意する。
- -AWSコンソールでAWSアカウントにサインオンする。
-ナビゲーションバーの右上隅に表示される AWSリージョン を確認し、必要に応じて変更します。Teradataでは、プライマリ作業場所に最も近いリージョンを選択することをお薦めする。
-CloudFormation > Create Stack に移動します。 Create Stack を選択し、 With new resources (standard) を選択します。
-テンプレートの準備ができました を選択し、Teradata AI Unlimited GitHub リポジトリからダウンロードしたテンプレート ファイルの 1 つをアップロードします。
-Workspaces テンプレート: systemd によって制御されるコンテナー内で実行されるワークスペースを含む単一のインスタンスをデプロイします。
-workspaces.yaml CloudFormation テンプレート
-parameters/workspaces.json パラメータ ファイル
-Jupyter テンプレート: systemd によって制御されるコンテナ内で実行される JupyterLab を含む単一のインスタンスをデプロイします。
-jupyter.yaml CloudFormation テンプレート
-parameters/jupyter.json パラメータ ファイル
-All-In-One ワンテンプレート: Workspaces と JupyterLab が同じインスタンス上で実行される単一のインスタンスをデプロイします。
-all-in-one.yaml CloudFormation テンプレート
-parameters/all-in-one.json パラメータ ファイル
-このテンプレートを使用している場合は、埋め込み JupyterLab サービスを使用することも、外部 JupyterLab インスタンスに接続することもできます。埋め込み JupyterLab サービスに接続するときは、JupyterLab Notebookで適切な接続アドレス (例えば、127.0.0.1) を設定する必要があります。また、外部クライアントの場合は、適切なパブリック/プライベート IP または DNS 名を設定する必要があります。
-テンプレートのパラメータを確認します。入力が必要なパラメータの値を指定します。その他のすべてのパラメータについては、デフォルト設定を確認し、必要に応じてカスタマイズします。パラメータの確認とカスタマイズが終了したら、Next を選択します。
-以下のテーブルでは、パラメータがカテゴリ別にリストされています。
-AWSインスタンスとネットワーク設定
-| パラメータ | -説明 | -必須? | -デフォルト | -注記 | -
|---|---|---|---|---|
InstanceType |
-サービスに使用する EC2 インスタンスの型。 |
-デフォルトでは必須 |
-t3.small |
-Teradata では、コストを節約するためにデフォルトのインスタンス型を使用することをお勧めします。 |
-
RootVolumeSize |
-インスタンスに接続するroot ディスクのサイズ (GB 単位)。 |
-デフォルトでは必須 |
-8 |
-8～1000の値をサポートします。 |
-
TerminationProtection |
-インスタンス終了保護を有効にします。 |
-デフォルトでは必須 |
-false |
-- |
IamRole |
-インスタンスに割り当てるIAMロールの名前。既存のIAMロールまたは 新しく作成されたIAMロールのいずれか。 |
-デフォルトでは必須 |
-New |
-サポートされているオプションは以下のとおりです: NewまたはExisting -ai-unlimited-aws-permissions-policies.html を参照してください。 |
-
IamRoleName |
-インスタンスに割り当てるIAMロールの名前。既存のIAMロールまたは で新しく作成されたIAMロールのいずれか。 |
-デフォルトではオプション |
-workspaces-iam-role |
-新しい IAM ロールに名前を付ける場合、CloudFormation には CAPABILITY_NAMED_IAM 機能が必要です。 -自動生成された名前を使用する場合は、このフィールドを空白のままにします。 |
-
IamPermissionsBoundary |
-インスタンスに割り当てられた IAM ロールに関連付ける IAM アクセス権境界の ARN。 |
-オプション |
-- | - |
AvailabilityZone |
-インスタンスをデプロイするアベイラビリティゾーン。 |
-必須 |
-- | 値はサブネット、既存のボリュームのゾーンと一致する必要があり、インスタンス型は選択したゾーンで使用できる必要があります。 |
-
LoadBalancing |
-インスタンスがNLBを介してアクセスされるかどうかを指定します。 |
-デフォルトでは必須 |
-NetworkLoadBalancer |
-サポートされているオプションは以下のとおりです: NetworkLoadBalancer または なし |
-
LoadBalancerScheme |
-ロードバランサが使用されている場合、このフィールドは、インスタンスがインターネットからアクセスできるか、VPC 内からのみアクセスできるかを指定します。 |
-デフォルトではオプション |
-Internet-facing |
-インターネットに接続されたロード バランサーの DNS 名は、ノードのパブリック IP アドレスにパブリックに解決できます。したがって、インターネットに接続されたロード バランサーは、クライアントからのリクエストをインターネット経由でルーティングできます。内部ロード バランサのノードにはプライベート IP アドレスのみがあります。インターネットに接続された内部ロード バランサーの DNS 名は、ノードのパブリック個人 IP アドレスにパブリックに解決できます。したがって、内部ロードバランサーは、ロードバランサーの VPC にアクセスできるクライアントからのリクエストをルーティングできます。 |
-
Private |
-サービスをパブリック IP のないプライベート ネットワークにデプロイするかどうかを指定します。 |
-必須 |
-false |
-- |
Session |
-AWSセッションマネージャを使用してインスタンスにアクセスできるかどうかを指定する。 |
-必須 |
-false |
-- |
Vpc |
-インスタンスをデプロイするネットワーク。 |
-必須 |
-- | - |
Subnet |
-インスタンスをデプロイするサブネットワーク。 |
-必須 |
-- | サブネットは、選択した可用性ゾーン内に存在する必要があります。 |
-
KeyName |
-インスタンスの起動後に安全に接続できるようにする公開鍵と秘密鍵のペア。AWS アカウントを作成するとき、これは優先リージョンで作成するキー ペアです。 |
-オプション |
-- | SSHキーを含めない場合は、このフィールドを空白のままにします。 |
-
AccessCIDR |
-インスタンスへのアクセスが認証される CIDR IP アドレス範囲。 |
-オプション |
-- | Teradata では、この値を信頼できる IP 範囲に設定することをお勧めします。 -カスタム セキュリティ グループ受信ルールを作成しない限り、受信通信量を認証するには、AccessCIDR、PrefixList、または SecurityGroup の少なくとも 1 つを定義します。 |
-
PrefixList |
-インスタンスとの通信に使用できる接頭辞リスト。 |
-オプション |
-- | カスタム セキュリティ グループ受信ルールを作成しない限り、受信通信量を認証するには、AccessCIDR、PrefixList、または SecurityGroup の少なくとも 1 つを定義します。 |
-
SecurityGroup |
-インスタンスへのインバウンドおよびアウトバウンドの通信量を制御する仮想ファイアウォール。 |
-オプション |
-- | SecurityGroup は、インスタンスへのアクセスを認証するプロトコル、ポート、IP アドレスまたは CIDR ブロックを指定する一連のルールとして実装されます。 -カスタム セキュリティ グループ受信ルールを作成しない限り、受信通信量を認証するには、AccessCIDR、PrefixList、または SecurityGroup の少なくとも 1 つを定義します。 |
-
UsePersistentVolume |
-データの保存に永続ボリュームを使用するかどうかを指定します。 |
-デフォルトではオプション |
-なし |
-サポートされるオプションは、ユースケースに応じて、新しい永続ボリューム、既存の永続ボリューム、またはなしです。 |
-
PersistentVolumeSize |
-インスタンスに付与できる永続ボリュームのサイズ (GB 単位)。 |
-デフォルトでは必須 |
-8 |
-8 ～ 1000 の値をサポート |
-
ExistingPersistentVolumeId |
-インスタンスに付与できる既存の永続ボリュームの ID。 |
-UsePersistentVolume が Existing に設定されている場合は必須 |
-- | 永続ボリュームは、ワークスペース サービス インスタンスと同じ可用性ゾーンに存在する必要があります。 |
-
PersistentVolumeDeletionPolicy |
-CloudOmatics の配置を削除したときの永続的なボリュームの動作。 |
-デフォルトでは必須 |
-Delete |
-サポートされているオプションは、 Delete、Retain、RetainExceptOnCreate、およびSnapshotです。 |
-
LatestAmiId |
-AMI の最新バージョンを指すイメージの ID。この値は SSM ルックアップに使用されます。 |
-デフォルトでは必須 |
-- | このデプロイメントでは、利用可能な最新の ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2 イメージを使用します。 -IMPORTANT: この値を変更すると、スタックが破損する可能性があります。 |
-
Workspace サービスのパラメータ
-| パラメータ | -説明 | -必須? | -デフォルト | -注記 | -
|---|---|---|---|---|
WorkspacesHttpPort |
-Workspace サービス UI にアクセスするためのポート。 |
-デフォルトでは必須 |
-3000 |
-- |
WorkspacesGrpcPort |
-Workspace サービス API にアクセスするためのポート。 |
-デフォルトでは必須 |
-3282 |
-- |
WorkspacesVersion |
-デプロイするワークスペース サービスのバージョン。 |
-デフォルトでは必須 |
-latest |
-値はコンテナのバージョンタグ (latest など) です。 |
-
JupyterLabのパラメータ
-| パラメータ | -説明 | -必須? | -デフォルト | -注記 | -
|---|---|---|---|---|
JupyterHttpPort |
-JupyterLab サービス UI にアクセスするためのポート |
-デフォルトでは必須 |
-8888 |
-- |
JupyterToken |
-UI から JupyterLab にアクセスするために使用されるトークンまたはパスワード |
-必須 |
-- | トークンは文字で始まり、英数字のみを含む必要があります。認証されるパターンは ^[a-zA-Z][a-zA-Z0-9-]* です。 |
-
JupyterVersion |
-デプロイしたいJupyterLabのバージョン。 |
-デフォルトでは必須 |
-latest |
-値はコンテナのバージョンタグ (latest など) です。 |
-
| - - | --Workspace サービスをデプロイしているアカウントに、IAM ロールまたは IAM ポリシーを作成するための十分な IAM アクセス権がない場合は、クラウド管理者に問い合わせてください。 - | -
オプション ページでは、スタック内のリソースのタグ (キーと値のペア) の指定、アクセス権の設定、スタック障害オプションの設定、および詳細オプションの設定を行うことができます。終了したら、Next を選択します。
-Reviewページで、テンプレート設定を確認します。[Capabilities]で、テンプレートがIAMリソースを作成することを確認するチェックボックスをオンにします。
-Createを選択してstackをデプロイします。
-スタックのステータスを監視します。ステータスが`CREATE_COMPLETE`の場合、Teradata AI Unlimitedワークスペースサービスの準備が整っています。
-スタックの Outputs タブに表示されるURLを使用して、作成されたリソースを表示します。
-ワークスペースサービスの設定とセットアップ を参照してください。
-| - - | --ワークスペース サービスのみをデプロイした場合は、ワークロードを実行する前にインターフェースをデプロイする必要があります。インターフェースをDocker上にローカルにデプロイするには、 Dockerを使用した Teradata AI Unlimited インターフェースのデプロイ を参照してください。 Jupyter テンプレート を使用して、systemd によって制御されるコンテナ内で実行される JupyterLab を持つ単一のインスタンスをデプロイすることもできます。 - | -
Teradata AI Unlimited の準備が整いました。
-簡単なワークフローを実行して、Teradata AI Unlimited を開始します。 Teradata AI Unlimitedを使用してJupyterLabでサンプルワークロードを実行する を参照してください。
-Teradata AI Unlimited-AWS IAMのロールとポリシーについて詳しく知りたいですか? カスタム権限とポリシーを使用してAWSのアクセスと権限を制御する を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細については、Teradataサポートに連絡してください。 - | -
AWS CLIから`aws cloudformation create-stack`または`aws cloudformation deploy`コマンドを使用してスタックをデプロイできる。このセクションの例では、create-stackコマンドを使用している。 create-stack コマンドと deploy コマンドの構文の違いについては 、 AWS CLI コマンド リファレンスドキュメントを参照してください。
AWS CLIをインストールして設定する。 「AWS CLI の開始方法」を参照してください。
-以下を確認します。
-必須の AWS 認証情報。
-リソースを作成および管理するために必要な IAM アクセス権。必要なアクセス権がない場合は、組織管理者に問い合わせて、指定されたすべてのロールを作成してください。
-必要なパラメータファイルとCloudFormationテンプレート。ファイルは AI Unlimited GitHubリポジトリ からダウンロードできます。
-AWS CLI で以下のコマンドを実行します。
-aws cloudformation create-stack --stack-name all-in-one \
- --template-body file://all-in-one.yaml \
- --parameters file://test_parameters/all-in-one.json \
- --tags Key=ThisIsAKey,Value=AndThisIsAValue \
- --capabilities CAPABILITY_IAM CAPABILITY_NAMED_IAMNOTE:
-IamRoleが新規に設定されている場合は、CAPABILITY_IAMが必要です。
-IamRoleがNewに設定され、IamRoleNameに値が指定されている場合は、CAPABILITY_NAMED_IAM が必要です。
-既存のロールを使用するには、「アクセス権とポリシーを使用した AWS アクセスとアクセス権の制御」を参照してください。
-AWS CLI で以下のコマンドを実行します。
-aws cloudformation delete-stack --stack-name <stackname>AWS CLI で以下のコマンドを実行します。
-aws cloudformation delete-stack --stack-name <stackname>
-aws cloudformation describe-stacks --stack-name <stackname>
-aws cloudformation describe-stack-events --stack-name <stackname>
-aws cloudformation describe-stack-instance --stack-name <stackname>
-aws cloudformation describe-stack-resource --stack-name <stackname>
-aws cloudformation describe-stack-resources --stack-name <stackname>AWS CLI で以下のコマンドを実行します。
-aws cloudformation describe-stacks --stack-name <stackname> --query 'Stacks[0].Outputs' --output table簡単なワークフローを実行して、Teradata AI Unlimited を開始します。Teradata AI Unlimitedを使用してJupyterLabでサンプルワークロードを実行する を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細について興味がある場合は、Teradata サポートにお問い合わせください。 - | -
Teradata AI Unlimited は、SQL エンジンをデプロイしてデータ レイクに接続できるようにするセルフサービスのオンデマンド プラットフォームです。その後、任意のクラウド サービス プロバイダ (CSP) にデプロイされたスケーラブルな AI Unlimited コンピューティング エンジンでワークロードを実行できます。エンジンを使用すると、データ管理の必要性を排除しながら、高度な並列データベースの機能を活用できます。
-Teradata AI Unlimited は、以下の構成要素で構成されています。
-ワークスペースサービス: Teradata AI Unlimited の自動化とデプロイを制御および管理するオーケストレーション サービス。また、データ関連プロジェクトの実行時にシームレスなユーザー エクスペリエンスを提供する統合構成要素も制御します。ワークスペースサービスには、ユーザーを承認し、CSP 統合の選択を定義するために使用できる Web ベースの UI が含まれています。
-インターフェース: データ プロジェクトを作成して実行し、Teradata システムに接続し、データを視覚化するための環境。JupyterLabまたはワークスペースクライアント(workspacectl)のいずれかを使用できます。
-エンジン: データ サイエンスおよび分析ワークロードの実行に使用できる、フルマネージドの計算リソース。
-以下のオプションのいずれかを使用して、Teradata AI Unlimited 構成要素をデプロイできます。
-Docker上でローカルに実行されるワークスペースサービスと JupyterLab
-Virtual Private Cloud (VPC) 上のワークスペース サービスと、Docker上でローカルに実行されている JupyterLab
-VPC 上の同じインスタンス上のワークスペース サービスと JupyterLab
-Network Load Balancer の背後にあるワークスペースサービスと JupyterLab
-開発環境またはテスト環境の場合、Dockerを使用してワークスペース サービスと JupyterLab をデプロイできます。Dockerを使用した Teradata AI Unlimited Workspaceサービスのデプロイとセットアップ を参照してください。クラウド インフラストラクチャにアクセスできるエンタープライズ ユーザーの場合は、ワークスペース サービスと JupyterLab を VPC にデプロイできます。AWS CloudFormation テンプレートを使用して Teradata AI Unlimited Workspace サービスとインターフェースをデプロイする と「Azure を使用してTeradata AI Unlimited をデプロイする方法」(近日公開)を参照してください。
-Dockerを使用して Teradata AI Unlimited をローカルにデプロイしたいですか?Dockerを使用した Teradata AI Unlimited Workspaceサービスのデプロイとセットアップ を参照してください。
-CloudFormation テンプレートを使用して AWS に Teradata AI Unlimited をデプロイしたいですか?AWS CloudFormation テンプレートを使用して Teradata AI Unlimited Workspace サービスとインターフェースをデプロイする を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細について興味がある場合は、Teradata サポートにお問い合わせください。 - | -
このドキュメントでは、Dockerを使用して Teradata AI Unlimited インターフェースをデプロイおよび設定する手順の概要を説明します。Teradata AI Unlimited インターフェースとして JupyterLab またはワークスペース クライアントを使用できます。
-JupyterLabは、次の手法でデプロイできます。
-ワークスペース クライアントの詳細については、 Workspace Client で Teradata AI Unlimited を使用するを参照してください。
-https://hub.docker.com/r/teradata/ai-unlimited-jupyter にある DockerHub からDockerイメージをプルします。
-JUPYTER_HOME 変数を設定したら、Dockerイメージを実行します。
| - - | --要件に基づいてディレクトリを変更します。 - | -
docker run -detach \
- --env “accept_license=Y” \
- --publish 8888:8888 \
- --volume ${JUPYTER_HOME}:/home/jovyan/JupyterLabRoot \
- teradata/ai-unlimited-jupyter:latestこのコマンドは、JupyterLab コンテナをダウンロードして起動し、それにアクセスするために必要なポートを公開します。 -URL: http://localhost:8888 を使用して JupyterLab に接続し、プロンプトが表示されたらトークンを入力します。詳細な手順については、 「Teradata Vantage™ Modules for Jupyter インストール ガイド」 または 「Jupyter Notebook から Vantage を使用する」 を参照してください。
-Docker Compose を使用すると、Dockerベースの JupyterLab インストールを簡単に構成、インストール、アップグレードできます。
-Docker Composeをインストールします。https://docs.docker.com/compose/install/ を参照してください。
-jupyter.yml ファイル を作成します。
-version: "3.9"
-
-services:
- jupyter:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: jupyter
- image: ${JUPYTER_IMAGE_NAME:-teradata/ai-unlimited-jupyter}:${JUPYTER_IMAGE_TAG:-latest}
- environment:
- accept_license: "Y"
- ports:
- - 8888:8888
- volumes:
- - ${JUPYTER_HOME:-./volumes/jupyter}:/home/jovyan/JupyterLabRoot/userdata
- networks:
- - td-ai-unlimited
-
-networks:
- td-ai-unlimited:jupyter.yml ファイルがあるディレクトリに移動し、JupyterLabを起動します。
-docker compose -f jupyter.yml upJupyterLabサーバーが初期化されて起動されると、URL: http://localhost:8888を使用してJupyterLabに接続し、プロンプトが表示されたらトークンを入力します。詳細な手順については、 「Teradata Vantage™ Modules for Jupyter インストール ガイド」 または 「Jupyter Notebook から Vantage を使用する」 を参照してください。
-おめでとうございます！これで、Teradata AI Unlimitedを使用するための設定は完了しました。
-簡単なワークフローを実行して、Teradata AI Unlimited を開始します。Teradata AI Unlimitedを使用してJupyterLabでサンプルワークロードを実行する を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細について興味がある場合は、Teradata サポートにお問い合わせください。 - | -
このドキュメントでは、Dockerを使用して Teradata AI Unlimited ワークスペース サービスをデプロイおよび設定する手順の概要を説明します。
-ワークスペースサービスは、次の方法でインストールできます。
-Teradata AI Unlimitedをワークスペース クライアントで使用するには、Workspace Client で Teradata AI Unlimited を使用する を参照してください。
-次のものが揃っていることを確認してください。
-GitHubアカウント: GitHubのアカウントをまだ持っていない場合は、https://github.com/で作成してください。
-CSPアカウント: AWSまたはAzure上のエンジンをホストできるもの。
-https://aws.amazon.com/free/ で AWS 無料利用枠アカウントにサインアップします。AWS CLI を設定するには、「 https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html」を参照してください。
-https://azure.microsoft.com/en-us/freeで Azure の無料アカウントにサインアップします。Azure CLI をインストールし、ワークスペース サービスを実行しているマシンに信頼証明を構成します。https://learn.microsoft.com/en-us/cli/azure/get-started-with-azure-cli を参照してください。
-Docker: Dockerをダウンロードしてインストールするには、 https://docs.docker.com/docker-for-windows/install/を参照してください。
-Dockerイメージは、単一のコンテナ内で必要なサービスを実行するワークスペース サービスのモノリシック イメージです。
-link:https://hub.docker.com/r/teradata/ai-unlimited-workspaces[Docker Hub] から Dockerイメージをプルします。-
docker pull teradata/ai-unlimited-workspaces続行する前に、必ず以下のことを行ってください。
-AWSコンソールからCSP環境変数をコピーして保持します。
- -環境変数 WORKSPACES_HOME を、構成ファイルとデータファイルがあるディレクトリに設定します。ディレクトリが存在し、適切なアクセス権が付与されていることを確認してください。WORKSPACES_HOME を設定しない場合、デフォルトの場所は ./volumes/workspaces です。
| ローカルの場所 | -コンテナの場所 | -使用方法 | -
|---|---|---|
$WORKSPACES_HOME |
-/etc/td |
-データと構成の保存 |
-
$WORKSPACES_HOME/tls |
-/etc/td/tls |
-証明書ファイルの保存する |
-
`WORKSPACES_HOME` 変数を設定したら、Dockerイメージを実行する。-
| - - | --要件に基づいてディレクトリを変更します。 - | -
docker run -detach \
- --env accept_license="Y" \
- --env AWS_ACCESS_KEY_ID="${AWS_ACCESS_KEY_ID}" \
- --env AWS_SECRET_ACCESS_KEY="${AWS_SECRET_ACCESS_KEY}" \
- --env AWS_SESSION_TOKEN="${AWS_SESSION_TOKEN}" \
- --publish 3000:3000 \
- --publish 3282:3282 \
- --volume ${WORKSPACES_HOME}:/etc/td \
- teradata/ai-unlimited-workspaces:latest| - - | --Azure の場合、Teradata では Docker Compose を使用してワークスペース サービスをデプロイすることをお勧めします。 - | -
このコマンドは、ワークスペース サービス コンテナをダウンロードして開始し、アクセスするために必要なポートを公開します。ワークスペース サービス サーバーが初期化され、開始されると、URL: http://<ip_or_hostname>:3000/を使用してアクセスできます。
-Docker Compose を使用すると、Docker ベースのワークスペース サービス インストールを簡単に構成、インストール、アップグレードできます。
-Docker Composeをインストールします。https://docs.docker.com/compose/install/ を参照してください。
-workspaces.yml ファイルを作成します。
-| - - | --以下の例では、ローカル ボリュームを使用して CSP 信頼証明を保存します。CSP 環境変数を含む別の YAML ファイルを作成し、Docker Compose ファイルを実行できます。他のオプションについては、 「AI Unlimited GitHub: Docker Compose を使用して AI Unlimited をインストールする」 を参照してください。 - | -
version: "3.9"
-
-services:
- workspaces:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: workspaces
- image: ${WORKSPACES_IMAGE_NAME:-teradata/ai-unlimited-workspaces}:${WORKSPACES_IMAGE_TAG:-latest}
- command: workspaces serve -v
- restart: unless-stopped
- ports:
- - "443:443/tcp"
- - "3000:3000/tcp"
- - "3282:3282/tcp"
- environment:
- accept_license: "Y"
- TZ: ${WS_TZ:-UTC}
- volumes:
- - ${WORKSPACES_HOME:-./volumes/workspaces}:/etc/td
- - ${WORKSPACES_AWS_CONFIG:-~/.aws}:/root/.aws
-
- networks:
- - td-ai-unlimitedversion: "3.9"
-
-services:
- workspaces:
- deploy:
- replicas: 1
- platform: linux/amd64
- container_name: workspaces
- image: ${WORKSPACES_IMAGE_NAME:-teradata/ai-unlimited-workspaces}:${WORKSPACES_IMAGE_TAG:-latest}
- command: workspaces serve -v
- restart: unless-stopped
- ports:
- - "443:443/tcp"
- - "3000:3000/tcp"
- - "3282:3282/tcp"
- environment:
- accept_license: "Y"
- TZ: ${WS_TZ:-UTC}
- volumes:
- - ${WORKSPACES_HOME:-./volumes/workspaces}:/etc/td
- - ${WS_HOME:-~/.azure}:/root/.azure
-
- networks:
- - td-ai-unlimitedworkspaces.yml ファイルが配置されているディレクトリに移動し、ワークスペース サービスを開始します。
-docker compose -f workspaces.yamlワークスペース サービス サーバーが初期化され、開始されると、URL: http://<ip_or_hostname>:3000/を使用してアクセスできます。
-ワークスペース サービスは、GitHub OAuth アプリを使用してユーザーを承認し、プロジェクトの状態を管理します。ワークスペース サービスにプロジェクト インスタンス構成を保存する権限を与えるには、GitHub OAuth アプリの登録時に生成されたクライアント ID とクライアント シークレット キーを使用します。プロジェクト インスタンスの構成値は GitHub リポジトリに保持されており、ワークスペース サービスの Profile ページで表示できます。
-初めてのユーザーは、続行する前に以下の手順を完了する必要があります。VPC の構成やアクセス権について不明な点がある場合は、組織の管理者に問い合わせてください。
-GitHub アカウントにログオンし、OAuth アプリを作成します。 GitHub ドキュメント を参照してください。
-OAuth アプリを登録するときに、URL フィールドに以下のワークスペース サービス URL を入力します。
-ホームページのURL: http://<ip_or_hostname>:3000/
-認証コールバック URL: http://<ip_or_hostname>:3000/auth/github/callback
-クライアントID と クライアントの秘密鍵 をコピーして保持します。
-ワークスペース サービスを設定するには、以下の手順を実行します。
-URL: http://<ip_or_hostname>; :3000/ を使用してワークスペース サービスにアクセスします。
-
-セットアップ の下に以下の一般的なサービス構成を適用します。
-| 設定 | -説明 | -必須? | -
|---|---|---|
Service Base URL |
-[編集不可] サービスのroot URL。 |
-はい |
-
Git Provider |
-Git 統合のプロバイダ。現在、Teradata AI Unlimited は GitHub と GitLab をサポートしています。 |
-はい |
-
Service Log Lev |
-ロギングのレベル。 |
-はい |
-
Engine IP Network Type |
-エンジン インスタンスに割り当てられるネットワークの型。パブリックまたはプライベートのいずれかになります。ワークスペースサービスと同じVPCにエンジンをデプロイする場合は、Private オプションを選択します。 |
-はい |
-
Use TLS |
-TLSサポートが有効かどうかを示します。インスタンスにプライベート ネットワーク内からのみアクセスでき、信頼済みユーザーのみがアクセスできる場合は、デフォルト値を無視できます。Teradataでは、機密データ、パブリックネットワーク、およびコンプライアンス要件に対してTLSオプションを有効にすることを推奨している。 |
-はい |
-
Service TLS Certification |
-サーバIDを認証するためのサーバ証明書。 |
-いいえ |
-
Service TLS Certificate Key |
-サーバ証明書キー。 |
-いいえ |
-
Service Base URL に自己署名証明書を使用するには、GENERATE TLS を選択します。証明書と秘密鍵が生成され、それぞれのフィールドに表示されます。
-Save Changes を選択します。
-選択した Cloud Integrations: CSP の下に以下の設定を適用します。
-| 設定 | -説明 | -必須? | -
|---|---|---|
Default Region |
-エンジンを配置するリージョン。Teradataでは、プライマリ作業ロケーションに最も近いリージョンを選択することをお薦めします。3. |
-はい |
-
Default Subnet |
-エンジンインスタンスにインターネットゲートウェイへのルートを提供するサブネット。サブネットを指定しない場合、エンジンは自動的にデフォルトのサブネットに関連付けられます。 |
-はい |
-
Default IAM Role |
-AWS でユーザーができることとできないことを決定するデフォルトの IAM ID。デフォルトの IAM ロールがユーザーまたはリソースに割り当てられると、ユーザーまたはリソースは自動的にそのロールが付与されたと想定し、そのロールに付与されたアクセス権を取得します。 |
-いいえ |
-
Resource Tag |
-リソースに関するメタデータを保持するためにリソースに適用されるキーと値のペア。リソースタグを使用すると、環境で使用するリソースを迅速に識別、整理、管理できる。 |
-いいえ |
-
Default CIDRs |
-エンジンに使用されるクラスレス ドメイン間ルーティング (CIDR) アドレスのリスト。CIDRを使用すると、ネットワーク内で柔軟かつ効率的にIPアドレスを割り当てることができる。CIDR を指定しない場合、エンジンはデフォルトの CIDR に自動的に関連付けられます。 |
-いいえ |
-
Default Security Groups |
-各リージョンの VPC のセキュリティ グループのリスト。セキュリティ グループを指定しない場合、エンジンは VPC のデフォルトのセキュリティ グループに自動的に関連付けられます。 |
-いいえ |
-
Role Prefix |
-ロールの名前の先頭に追加される文字列。ロール接頭辞を使用すると、ロールを編成および管理し、命名規則を適用できます。 |
-いいえ |
-
Permission Boundary |
-アイデンティティベースのポリシーで定義されたアクセス権に関係なく、IAM エンティティが持つことができる最大アクセス認証。ユーザーのアクセス権と役割を定義および管理し、コンプライアンス要件を強制できます。 |
-いいえ |
-
Save Changes を選択します。
-Git Integrations の下に以下の設定を適用します。
-| 設定 | -説明 | -必須? | -
|---|---|---|
GitHub Client ID |
-OAuthアプリを作成する際にGitHubから受け取ったクライアントID。 |
-はい |
-
GitHub Client Secret |
-OAuth アプリの作成時に GitHub から受け取ったクライアント シークレット ID。 |
-はい |
-
Auth Organization |
-チームと共同作業するために使用する GitHub 組織アカウントの名前。 |
-いいえ |
-
GitHub Base URL |
-GitHubアカウントのベースURL。URL はアカウントの型によって異なる場合があります。例えば、GitHub Enterprise アカウントの場合は https://github.company.com/ です。 |
-いいえ |
-
Authenticate を選択します 。GitHub にリダイレクトされます。
-GitHub 信頼証明を使用してログオンし、ワークスペース サービスを承認します。
-認証後、Workspace サービス Profile ページにリダイレクトされ、API キーが生成されます。API キーを使用して、ワークスペース サービスにリクエストを行うことができます。
-| - - | --ワークスペースサービスに接続するたびに、新しいAPIキーが生成されます。 - | -
Teradata AI Unlimited の準備が整いました。
-ワークスペース サービスを Teradata AI Unlimited Interface に接続し、エンジンをデプロイします。Dockerを使用した Teradata AI Unlimited インターフェースのデプロイ を参照してください。
-Teradata AI Unlimited が実際のユースケースでどのように役立つかを知りたいですか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
Regulus は、SQL クエリー エンジンをデプロイしてデータ レイクに接続できるようにするセルフサービス プラットフォームです。その後、優先クラウド サービス プロバイダ (CSP) にデプロイされたオンデマンドのスケーラブルなクエリー エンジンでワークロードを実行できます。クエリー エンジンを使用すると、データ管理の必要性を排除しながら、高度な並列データベースの機能を活用できます。
-Regulus には以下の構成要素が含まれています。
-ワークスペース: Regulus の自動化とデプロイを制御および管理するオーケストレーション サービス。また、データ関連プロジェクトの実行時にシームレスなユーザー エクスペリエンスを提供する統合構成要素も制御します。ワークスペースには、ユーザーを承認し、CSP 統合の選択を定義するために使用できる Web ベースの UI が含まれています。
-インターフェース: データプロジェクトの作成と実行、Teradataシステムへの接続、およびデータの視覚化を行うための環境。JupyterLab または Workspaces CLI のいずれかを使用できます。
-クエリーエンジン: データサイエンスおよび分析ワークロードの実行に使用できる、完全に管理された計算リソース。
-
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細について興味がある場合は、Teradata サポートにお問い合わせください。 - | -
このドキュメントでは、JupyterLab を使用して以下のことを行うための簡単なワークフローについて説明します。
-オンデマンドでスケーラブルなコンピューティングをデプロイメントする
-外部データソースに接続する
-ワークロードの実行する
-計算を中断する
-Teradata AI Unlimited Workspaces と JupyterLab をデプロイして構成します。Dockerを使用した Teradata AI Unlimited Workspaceサービスのデプロイとセットアップ と Dockerを使用した Teradata AI Unlimited インターフェースのデプロイ を参照してください。
-以下をコピーして保持します。
-コンソールからの CSP 環境変数。環境変数 を参照してください。
-ワークスペースサービスからのAPIキー。
-マジックコマンドの詳細については、%help または %help <command> を実行してください。詳細については、Teradata AI Unlimited JupyterLab マジック コマンド リファレンス を参照してください。
URL: http://localhost:8888 を使用して JupyterLab に接続し、プロンプトが表示されたらトークンを入力します。
-APIキーを使用してワークスペースサービスに接続します。
-%workspaces_config host=<ip_or_hostname>, apikey=<API_Key>, withtls=F新しいプロジェクトを作成します。
-| - - | --現在、Teradata AI Unlimited は AWS と Azure をサポートしています。 - | -
%project_create project=<Project_Name>, env=<CSP>, team=<Project_Team>(オプション) CSP 信頼証明を保存するための認証オブジェクトを作成します。
-ACCESS_KEY_ID、SECRET_ACCESS_KEY、および REGION を実際の値に置き換えます。
%project_auth_create name=<Auth_Name>, project=<Project_Name>, key=<ACCESS_KEY_ID>, secret=<SECRET_ACCESS_KEy>, region=<REGION>プロジェクトのエンジンをデプロイします。
-<Project_Name> を任意の名前に置き換えます。サイズパラメータ値には、small、medium、large、またはextralargeを指定できます。デフォルトのサイズはsmallです。
-%project_engine_deploy name=<Project_Name>, size=<Size_of_Engine>デプロイのプロセスが完了するまでに数分かかります。デプロイメントが成功すると、パスワードが生成されます。
-プロジェクトとの接続を確立します。
-%connect <Project_Name>接続が確立されると、インターフェースによってパスワードの入力が求められます。前のステップで生成されたパスワードを入力します。
-サンプルワークロードを実行します。
-| - - | --選択したデータベースに SalesCenter または SalesDemo という名前のテーブルがないことを確認してください。 - | -
販売センターのデータを格納するテーブルを作成します。
-まず、テーブルがすでに存在する場合は削除します。テーブルが存在しない場合、コマンドは失敗します。
-DROP TABLE SalesCenter;
-CREATE MULTISET TABLE SalesCenter ,NO FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO
- (
- Sales_Center_id INTEGER NOT NULL,
- Sales_Center_Name VARCHAR(255) CHARACTER SET LATIN NOT CASESPECIFIC)
-NO PRIMARY INDEX ;%dataload マジックコマンドを使用して、データをSalesCenterテーブルにロードします。
%dataload DATABASE=<Project_Name>, TABLE=SalesCenter, FILEPATH=notebooks/sql/data/salescenter.csv| - - | --salescenter.csv ファイルが見つかりませんか? GitHub Demo:Charting and Visualization Data からファイルをダウンロードします。 - | -
データが挿入されたことを確認します。
-SELECT * FROM SalesCenter ORDER BY 1販売デモ データを含むテーブルを作成します。
-DROP TABLE SalesDemo;
-CREATE MULTISET TABLE SalesDemo ,NO FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO
- (
- Sales_Center_ID INTEGER NOT NULL,
- UNITS DECIMAL(15,4),
- SALES DECIMAL(15,2),
- COST DECIMAL(15,2))
-NO PRIMARY INDEX ;`%dataload`マジック コマンドを使用して、SalesDemo テーブルにデータをロードします。
-%dataload DATABASE=<Project_Name>, TABLE=SalesDemo, FILEPATH=notebooks/sql/data/salesdemo.csv| - - | --salesdemo.csv ファイルが見つかりませんか? GitHub Demo:Charting and Visualization Data からファイルをダウンロードします。 - | -
販売デモ データが正常に挿入されたことを確認します。
-SELECT * FROM SalesDemo ORDER BY sales接続のナビゲータを開き、テーブルが作成されたことを確認します。テーブルで行カウントを実行して、データがロードされたことを確認します。
-チャートマジックを使用して、結果を視覚化します。
-チャートにX軸とY軸を提供しま。
-%chart sales_center_name, sales, title=Sales Dataテーブルをドロップします。
-DROP TABLE SalesCenter;
-DROP TABLE SalesDemo;プロジェクトのメタデータとオブジェクト定義を GitHub リポジトリにバックアップします。
-%project_backup project=<Project_Name>エンジンを停止します。
-%project_engine_suspend project=<Project_Name>おめでとうございます！JupyterLab で最初のユースケースが正常に実行されました。
-高度なユースケースを探索することに興味がありますか? 近日公開! GitHub リンクについては、このスペースを引き続き監視してください。
-JupyterLab で利用できるマジック コマンドについて学びます。 Teradata AI Unlimited JupyterLab マジック コマンド リファレンス を参照してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --この製品はプレビュー版であり、変更される可能性があります。このサービスの詳細について興味がある場合は、Teradata サポートにお問い合わせください。 - | -
Workspace Client (workspacectl) は、Teradata AI Unlimited のコマンド ライン インターフェース (CLI) です。このドキュメントでは、workspacectlをインストールするための手順を説明します。このドキュメントには、CLI コマンドに関する必要な情報とガイダンスがすべて記載されており、コマンド ラインを迅速かつ効率的に操作できるようになります。現在のリリースでは、workspacectl を使用してワークスペース サービスに接続し、エンジンを管理することのみが可能です。Teradata では、データ探索用の Teradata AI Unlimited インターフェースとして JupyterLab を使用することを推奨しています。
-以下を確認します。
-Dockerを使用した Teradata AI Unlimited Workspaceサービスのデプロイとセットアップで説明されている手順を使用して、ワークスペースサービスをインストール、設定、およびセットアップしている。
-AWS環境変数とAPIキーをコピーして保持している。
-https://downloads.teradata.com/download/tools/ai-unlimited-ctlからworkspacectlの実行可能ファイルをダウンロードします。
-| - - | --Workspacectlはすべての主要なオペレーティングシステムをサポートしています。 - | -
ターミナルウィンドウを開き、workspacectlファイルを実行します。
- -
-API キーを使用してワークスペース サービスを構成します。
-workspacesctl workspaces config新しいプロジェクトを作成します。
-workspacesctl project create <Project_Name> -e <CSP> --no-tlsプロジェクトのエンジンをデプロイします。
-workspacesctl project engine deploy <Project_Name> -t <Size_of_Engine> --no-tlsサンプルワークロードを実行します。
-プロジェクトとエンジンを管理します。
-プロジェクトをバックアップする。
-workspacesctl project backup <Project_Name> --no-tlsエンジンを停止します。
-workspacesctl project engine suspend <Project_Name> --no-tlsサポートされているコマンドのリストについては、 ワークスペースクライアントのリファレンス を参照してください。
-説明: CLI をワークスペース サービスにバインドするための 1 回限りの構成。ワークスペースサービスのプロファイルページに移動し、APIキーをコピーします。
-使用方法:
-workspacesctl workspaces configフラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-
-プロンプトに従って、ワークスペースサービスのエンドポイントとAPIキーを選択します。
-説明: GitHub で Teradata AI Unlimited 用に設定されたユーザーのリストを表示します。
-使用方法:
-workspacesctl workspaces user list --no-tls| - - | --設定にTLS設定が含まれている場合は、`-no-tls`パラメータを追加する必要はありません。 - | -
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-
-説明: Teradata AI Unlimitedでプロジェクトを作成します。このコマンドは、プロジェクトに対応する GitHub リポジトリも作成します。
-使用方法:
-workspacesctl project create <Project_Name> -e <CSP> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
-| フラグ | -型 | -説明 | -必須? | -
|---|---|---|---|
|
-文字列 |
-プロジェクト エンジンがホストされる環境。値:aws、azure、またはgcloud。現在、Teradata AI Unlimited は aws と azure をサポートしています。 |
-はい |
-
|
-文字列 |
-入力に使用されるyamlファイルをマニフェストするためのパス。 |
-いいえ |
-
|
-文字列 |
-プロジェクトに割り当てられたチーム。 |
-いいえ |
-
|
-- | コマンドの詳細をリストします。 |
-いいえ |
-
出力:
-
-説明: Teradata AI Unlimited で設定されているすべてのプロジェクトの一覧表示します。
-使用方法:
-workspacesctl project list --no-tlsまたは
-workspacesctl project list <Project_Name> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-
-説明: Teradata AI Unlimited でプロジェクトを削除します。
-使用方法:
- workspacesctl project delete <Project_Name> --no-tls| - - | --設定にTLS設定が含まれている場合は、`-no-tls`パラメータを追加する必要はありません。 - | -
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-| - - | --出力は YAML 形式です。 - | -
-説明: GitHub でプロジェクトに割り当てられた共同作業者をリストします。
-使用方法:
-workspacesctl project user list <Project_Name> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-
-説明: エンジン オブジェクト定義を、プロジェクトに割り当てられた GitHub リポジトリにバックアップします。
-使用方法:
-workspacesctl project backup <Project_Name> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: プロジェクトの GitHub リポジトリからすべてのエンジン オブジェクト定義を復元します。
-使用方法:
-workspacesctl project restore <Project_Name> --no-tlsまたは
-workspacesctl project restore <Project_Name> --gitref <git_reference> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
-| フラグ | -型 | -説明 | -必須? | -
|---|---|---|---|
|
-文字列 |
-タグ、SHA、またはブランチ名。 |
-いいえ |
-
|
-- | コマンドの詳細をリストします。 |
-いいえ |
-
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: プロジェクトのエンジンをデプロイします。
-使用方法:
-workspacesctl project engine deploy <Project_Name> -t small --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
-| フラグ | -型 | -説明 | -必須? | -
|---|---|---|---|
|
-Int |
-エンジン ノードの数。デフォルト値は1です。 |
-いいえ |
-
|
-文字列 |
-エンジンのインスタンス サイズ。 |
-いいえ |
-
|
-文字列 |
-入力に使用する yaml ファイルをマニフェストするパス。 |
-いいえ |
-
|
-文字列 |
-デプロイメントのリージョン。 |
-いいえ |
-
|
-文字列 |
-デプロイメントのサブネット ID。 |
-いいえ |
-
|
-- | コマンドの詳細をリストします。 |
-いいえ |
-
説明: デプロイされたエンジンを破棄し、セッション中に作成されたオブジェクト定義をバックアップします。
-使用方法:
-workspacesctl project engine suspend <Project_Name> --no-tls| - - | --設定にTLS設定が含まれている場合は、`-no-tls`パラメータを追加する必要はありません。 - | -
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: プロジェクトのエンジンに関する詳細情報を表示します。このコマンドは、エンジンの最後の状態を表示します。
-使用方法:
-workspacesctl project engine list <Project_Name> --no-tls| - - | --設定にTLS設定が含まれている場合は、`-no-tls`パラメータを追加する必要はありません。 - | -
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: オブジェクト ストアの認証を作成します。
-使用方法:
-workspacesctl project auth create <Project_Name> -n <Auth_Name> -a <Auth_Key> -s <Auth_Secret> -r <ObjectStore_Region> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
-| フラグ | -型 | -説明 | -必須? | -
|---|---|---|---|
|
-文字列 |
-認証アクセスキーまたはID。 |
-はい ( |
-
|
-文字列 |
-オブジェクトストアの認証名。 |
-はい ( |
-
|
-文字列 |
-入力に使用する yaml ファイルをマニフェストするパス。 |
-いいえ |
-
|
-文字列 |
-オブジェクトストアのリージョン。 |
-はい |
-
-s, --secret string |
-文字列 |
-オブジェクト ストアの認証シークレット アクセス キー。 |
-はい ( |
-
|
-- | コマンドの詳細をリストします。 |
-いいえ |
-
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: プロジェクトに対して作成されたオブジェクト ストアの認証をリストします。
-使用方法:
-workspacesctl project auth list <Project_Name> --no-tls| - - | --設定にTLS設定が含まれている場合は、 `-no-tls`パラメータを追加する必要はありません。 - | -
フラグ:
--h、--help: コマンドの詳細をリストします。
出力:
-| - - | --出力はYAML形式です。 - | -
-説明: プロジェクトに対して作成されたオブジェクト ストアの認証を削除します。
-使用方法:
-workspacesctl project auth delete <Project_Name> -n <Auth_Name> --no-tls| - - | -
-設定にTLS設定が含まれている場合は、-no-tls パラメータを追加する必要はありません。
- |
-
フラグ:
-| フラグ | -型 | -説明 | -必須? | -
|---|---|---|---|
|
-文字列 |
-削除するオブジェクト ストアの認証の名前。 |
-はい |
-
|
-- | コマンドの詳細をリストします。 |
-いいえ |
-
出力:
-| - - | --出力はYAML形式です。 - | -
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --このガイドには、Microsoft と Teradata の両方の製品ドキュメントの内容が含まれています。 - | -
今回は、Power BI Desktop を Teradata Vantage に接続して、レポートやデータの劇的な視覚化を作成するプロセスについて説明します。 Power BI は Teradata Vantage をデータ ソースとしてサポートしており、Power BI Desktop の他のデータ ソースと同様に基になるデータを使用できます。
-Power BI は、ソフトウェア サービス、アプリケーション、コネクタで構成され、これらが連携して、関連性のないデータ ソースを、一貫性があり、視覚的に没入型の対話型の分析情報に変換します。
-Power BI Desktop -と呼ばれる Windows デスクトップ アプリケーション* Power BI サービス -と呼ばれるオンライン SaaS サービス* Windows、iOS、Android デバイス用の Power BI モバイル アプリ
-
-これら 3 つの要素 (Power BI Desktop、Power BI サービス、モバイル アプリ) は、人々が自分や自分の役割に最も効果的に応える方法でビジネスの分析情報を作成、共有、利用できるように設計されています。
-
-4 番目の要素である Power BI Report Server を使用すると、Power BI Desktop で Power BI レポートを作成した後、オンプレミスのレポート サーバーに発行できます。
-Power BI Desktop は、Vantage を「ネイティブ」データ ソースとしてではなく、サード パーティ データ ソースとしてサポートします。 代わりに、Power BI サービスで公開されたレポートは、 構成要素の オンプレミス データ ゲートウェイ を使用して Vantage にアクセスする必要があります。
-この入門ガイドでは、Teradata Vantageへの接続方法について説明します。Power BI Desktop Teradata コネクタは .NET Data Provider for Teradataを使用します。Power BI Desktopを使用するコンピューターにドライバをインストールする必要があります。.NET Data Provider for Teradata の単一インストールでは、32 ビットまたは 64 ビットの両方の Power BI Desktop アプリケーションがサポートされます。
-Azure サービス、Teradata Vantage、Power BI Desktop に精通していることが求められます。
-以下のアカウントとシステムが必要です。
-Power BI Desktop は、Windows 用の無料アプリケーションです。(Power BI Desktop は Mac では利用できません。 Parallels や VMware Fusion などの仮想マシン、または Apple の Boot Campで実行することもできますが、それはこの記事のスコープ外です。)
-ユーザーとパスワードを持つ Teradata Vantage インスタンス。ユーザーは、Power BI Desktop で使用できるデータに対するアクセス認証を持っている必要があります。Vantage には Power BI Desktop からアクセスできる必要があります。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Power BI Desktop は Microsoft Store からインストールすることも、 インストーラーをダウンロード し て直接実行することもできます。
-最新バージョンの .NET Data Provider for Teradata をダウンロードしてインストールします。
-ダウンロードできるファイルは複数あることに注記してください。「tdnetdp」で始まるファイルが必要です。
-黄色のアイコンが付いている Power BI Desktopを実行します。
-
-開始 (スプラッシュ) 画面が表示されている場合は、「データの取得」をクリックします。
-
-それ以外の場合、Power BI のメイン フォームを使用している場合は、_Home_リボン上にいることを確認し、_Get data_をクリックします。_More…_をクリックします。
-
-左側の Database をクリックします。
-Teradata database が表示されるまで、右側のリストをスクロールします。Teradata database をクリックしてから、Connect ボタンをクリックします。
-(今回は、「Teradata database」と「Teradata Vantage」は同義です。)
-
-表示されるウィンドウで、Vantage システムの名前または IP アドレスをテキスト ボックスに入力します。データを Power BI データ モデルに直接_インポート_するか、 DirectQuery を使用してデータ ソースに直接接続して_OK_ をクリックするかを選択できます。
-
-(Advanced オプションをクリックして、手作りした SQL文を送信します。)
-信頼証明については、Vantage で定義された Windows ログインまたは データベース ユーザー名を使用して接続するオプションがあります。これがより一般的です。適切な 認証方式を選択し、ユーザー名とパスワードを入力します。Connect をクリックします。
-また、LDAPサーバで認証するオプションもある。このオプションは、デフォルトでは非表示になっている。
-環境変数 PBI_EnableTeradataLdap を true に設定すると、LDAP 認証方式が使用可能になります。
-
-LDAPは、Power BIサービスに発行されるレポートに使用されるオンプレミスデータゲートウェイではサポートされないことに注記してください。LDAP 認証が必要で、オンプレミス データ ゲートウェイを使用している場合は、Microsoft にインシデントを送信してサポートをリクエストする必要があります。
-Vantage システムに接続すると、Power BI Desktop は今後システムに接続するための信頼証明を記憶します。 File > Optionsおよびsettings > Data source setting に移動すると、これらの信頼証明を変更できます。
-接続が成功すると、Navigatorウィンドウが表示されます。Vantageシステムで使用可能なデータが表示される。Power BI Desktop で使用する 1 つ以上の要素を選択できます。
-
-テーブルの名前をクリックして、テーブルをプレビューする。Power BI Desktop にロードする場合は、テーブル名の横にあるチェックボックスを必ずオンにしてください。
-選択したテーブルを ロード して、Power BI Desktop に取り込むことができます。クエリーを 編集 することもできます。これにより、クエリー エディターが開き、ロードするデータのセットをフィルタして絞り込むことができます。
-編集 は、使用している Power BI Desktop のバージョンに応じて _データの変換_と呼ばれる場合があります。
-テーブルの結合の詳細については、 「Power BI Desktop 機能でのリレーションシップの作成と管理」 を参照してください。
-レポートを公開するには、Power BI Desktopの Home リボンの [Publish] をクリックします。
-
-Power BI Desktop では、レポートを保存するように求められます。_My workspace_を選択し、_Select_をクリックします。
-
-レポートが公開されたら、Got it をクリックして閉じます。また、リンクにレポート名が含まれているリンクをクリックすることもできます。
-
-これは、Power BI Desktop で作成されたレポートの例です。
-
-Power BI Desktop を使用して、さまざまなソースからのデータを組み合わせることができます。詳細については、以下のリンクを参照してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 今回は、Azure Data Shareサービスを使用してAzure Blob Storageデータセットをあるユーザーから別のユーザーに共有し、Teradata VantageでNative Object Store（NOS）機能を活用してクエリを実行する手順について説明します。両方のユーザーに対してストレージアカウントとデータ共有アカウントを作成し、使用することになります。
-これは、ワークフローの図です。
-
Azure Data Share は、企業が複数の顧客やパートナーと簡単かつ安全にデータを共有することを可能にします。データ提供者とデータ消費者の両方が、データを共有および受信するためにAzureサブスクリプションを持つ必要があります。Azure Data Shareは現在、スナップショットベースの共有とインプレース共有を提供しています。現在、Azure Data Shareが サポートしているデータストア は、Azure Blob Storage、Azure Data Lake Storage Gen1およびGen2、Azure SQL Database、Azure Synapse Analytics、Azure Data Explorerです。Azure Data Shareを使用してデータセット共有を送信すると、データ消費者はAzure Blob Storageなどの任意のデータストアでそのデータを受け取り、Teradata Vantageを使用してデータを探索、分析することができます。
-詳細については、https://docs.microsoft.com/en-us/azure/data-share/[ドキュメント] を参照してください。
-Vantageは、データウェアハウス、データレイク、アナリティクスを単一の接続されたエコシステムに統合する最新のクラウドプラットフォームです。
-Vantageは、記述的分析、予測的分析、処方的分析、自律的意思決定、ML機能、可視化ツールを統合したプラットフォームで、データの所在を問わず、リアルタイムのビジネスインテリジェンスを大規模に発掘することが可能です。
-Vantageは、小規模から始めて、コンピュートやストレージを弾力的に拡張し、使用した分だけ支払い、低コストのオブジェクトストアを活用し、分析ワークロードを統合することを可能にします。
-Vantageは、R、Python、Teradata Studio、およびその他のSQLベースのツールをサポートしています。Vantageは、パブリッククラウド、オンプレミス、最適化されたインフラ、コモディティインフラ、as-a-serviceのいずれでもデプロイメント可能です。
-Teradata Vantage Native Object Store（NOS）は、標準的なSQLを使用して、Azure Blob Storageなどの外部オブジェクトストアにあるデータを探索することが可能です。NOSを使用するために、特別なオブジェクトストレージ側の計算インフラは必要ありません。コンテナを指すNOSテーブル定義を作成するだけで、Blob Storageコンテナにあるデータを探索することができます。NOSを使用すると、Blob Storageからデータを迅速にインポートしたり、データベース内の他のテーブルと結合したりすることも可能です。
-また、Teradata Parallel Transporter（TPT）ユーティリティを使用して、Blob StorageからTeradata Vantageにデータを一括でインポートすることも可能です。Vantage内で効率的にクエリ一することができます。
-詳細については、https://docs.teradata.com/home[ドキュメント]を参照してください。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Azureアカウント。 無料アカウント で始めることができます。
-データデータセットを保存するための Azure Blob Storage アカウント。
-前提条件を満たしたら、以下の手順を実行します。
-Azure Blob Storage アカウントとコンテナを作成する
-データ共有アカウントを作成する
-共有を作成する
-データ共有を使用してデータを受信および受信する
-Blob Storage への NOS アクセスを構成する
-lob Storageのデータセットにクエリーを実行する
-Blob StorageからVantageにデータをロードする（オプション）
-ブラウザで Azureポータル を開き（Chrome、Firefox、Safariでうまくいきます）、この記事の myProviderStorage_rg というリソースグループに ストレージアカウントを作成する の手順に従います。
-ストレージ名と接続方式を入力します。今回は、 myproviderstorage と public endpoint を使用します。
-| - - | --作成するすべてのサービスに同じ場所を使用することをお勧めします。 - | -
Review + create を選択し、Create を選択します。
-Go to resource をクリックし、 Containers をクリックし、コンテナを作成します。
-+ Container ボタンをクリックします。
-コンテナ名を入力します。今回は providerdata を使用します。
-
作成 をクリックします。
-データセットを共有するプロバイダーのデータ共有アカウントを作成します。
-この記事の Azure データ共有アカウントの作成 の手順に従い、 myDataShareProvider_rg というリソース グループにリソースを作成します。
-Basics タブで、データ共有アカウント名を入力します。今回は 、mydatashareprovider を使用します。
-
| - - | --作成するすべてのサービスに同じ場所を使用することをお勧めします。 - | -
Review + create を選択し、Create を選択します。
-デプロイが完了したら、Go to resource を選択します。
-[データ共有]の概要ページに移動し、 共有を作成 の手順に従います。
-Start sharing your data を選択します。
-+ Create を選択します。
-Details タブで、共有名と共有タイプを入力します。今回は、WeatherData と Snapshot を使用します。
-
| - - | -
- スナップショット共有
-
-
-受信者にデータのコピーを提供するために、スナップショット共有を選択します。 -
-
-サポートされているデータストア Azure Blob Storage、Azure Data Lake Storage Gen1、Azure Data Lake Storage Gen2、Azure SQL Database、Azure Synapse Analytics (旧 SQL DW) - |
-
| - - | -
- インプレース共有
-
-
-データへのアクセスをソースで提供するために、インプレース共有を選択します。 -
-
-サポートされているデータストア Azure データエクスプローラ - |
-
Continue をクリックします。
-Datasets タブで、 Add datasets -をクリックします。
-Azure Blob Storage を選択します。
-
*次へ*をクリックします。
-データセットを提供するストレージアカウントを入力します。今回は、 myproviderstorage を使用します。
-
Next をクリックします。
-コンテナをダブルクリックして、データセットを選択します。今回は 、providerdata と onpoint_history_postal-code_hour.csv ファイルを使用します。
-
図 6 ストレージ コンテナとデータセットの選択
-| - - | --Azure Data Share は、フォルダおよびファイル レベルで共有できます。ファイルのアップロードには、Azure Blob Storageリソースを使用します。 - | -
次へ をクリックします。
-コンシューマに表示されるフォルダとデータセットのデータセット名を入力します。今回はデフォルトの名前を使用しますが、providerdata フォルダを削除します。Add datasets をクリックします。
-
Add datasets をクリックします。
-
Continue をクリックします。
-Recipients タブで、 Add recipient の電子メールアドレスを追加するをクリックします。。
-消費者の電子メールアドレスを入力します。
-
| - - | --消費者が受け入れることができるシェア有効期限を設定します。 - | -
Continue をクリックします。
-[Settings] タブで、スナップショットのスケジュールを設定します。今回は、デフォルトで チェックを外して 使用します。
-
Continue をクリックします。
-Review + Create タブの *Create*をクリックします。
-
これでAzureデータ共有が作成され、データ共有の受信者が招待を受け入れる準備ができました。
-
今回は、受信者/消費者が Azure Blob ストレージ アカウントにデータを受信することを想定しています。
-データ共有 プロバイダ と同様に、データ共有の招待を受け入れる前に、コンシューマ のすべての事前要件が完了していることを確認します。
-Azureのサブスクリプション。持っていない場合は、事前に 無料アカウント を作成してください。
-Azure Blob Storage アカウントとコンテナ: myConsumerStorage_rg というリソース グループを作成し、アカウント名 myconsumerstorage とコンテナ consumerdata を作成します。
-Azure Data Share アカウント: myDataShareConsumer_rg というリソース グループを作成し、 mydatashareconsumer というデータ共有アカウント名を作成して、データを受け入れます。
-https://docs.microsoft.com/en-us/azure/data-share/subscribe-to-data-share?tabs=azure-portal[Azure Data Shareを使用してデータを受信する]の手順に従います。-
メールには、Microsoft Azureから「Azure Data Share invitation from yourdataprovider@domain.com.*という件名の招待状が届いています。*View invitation(招待状を表示する) をクリックすると、Azureで招待状を表示することができます。
-
ブラウザでData Shareの招待状の一覧を表示するアクションです。
-
表示したいシェアを選択します。今回は 、WeatherData を選択します。
-Target Data Share Account(ターゲット データ共有アカウント) で、データシェアをデプロイするサブスクリプションとリソースグループを選択するか、ここで新しいデータシェアを作成することができます。
-| - - | --f プロバイダが利用規約の承諾を必要とする場合、ダイアログボックスが表示され、利用規約に同意することを示すボックスにチェックを入れる必要があります。 - | -
Resource groupとData share accountを入力します。今回は myDataShareConsumer_rg と mydatashareconsumer のアカウントを使用します。
-
Accept and configure を選択すると、Share subscriptionが作成されます。
-Datasets タブを選択します。宛先を指定するデータセットの横にあるチェックボックスをオンにします。+ Map to target を選択し、ターゲット データ ストアを選択します。
-
ターゲットデータストアの種類と、データを格納するパスを選択します。この記事のスナップショットの例では、コンシューマーの Azure Blob Storage アカウント myconsumerstorage とコンテナ consumerdata を使用することにします。
-| - - | --Azure Data Shareは、異なるデータストアから、または異なるデータストアへの共有機能を含む、オープンで柔軟なデータ共有を提供します。スナップショットおよびインプレース共有を受け入れることができるhttps://docs.microsoft.com/en-us/azure/data-share/supported-data-stores#supported-data-stores[サポートされた]データソースを確認します。 - | -
*Map to target*をクリックします。
-マッピングが完了したら、スナップショットベースの共有の場合は、Details タブをクリックし、Full または Incremental で Trigger snapshot をクリックします。プロバイダからデータを受け取るのは初めてなので、完全なコピーを選択します。
-
最終実行ステータスが 成功 したら、ターゲットデータストアに移動して受信したデータを表示します。 Datasets を選択し、Target Pathにあるリンクをクリックします。
-
Native Object Store（NOS）は、Azure Blob Storageのデータを直接読み込むことができるため、明示的にデータを読み込むことなくBlob Storageのデータを探索、分析することが可能です。
-外部テーブル定義により、Blob Storage内のデータをAdvanced SQL Engine内で簡単に参照することができ、構造化されたリレーショナル形式でデータを利用できるようになります。
-| - - | --NOSは、CSV、JSON、Parquet形式のデータをサポートしています。 - | -
Teradata Studioを使用してVantageシステムにログインします。
-以下のSQLコマンドを使用して、Blob StorageコンテナにアクセスするためのAUTHORIZATIONオブジェクトを作成します。
-CREATE AUTHORIZATION DefAuth_AZ
-AS DEFINER TRUSTED
-USER 'myconsumerstorage' /* Storage Account Name */
-PASSWORD '*****************' /* Storage Account Access Key or SAS Token */USER の文字列は、ストレージアカウント名に置き換えてください。
-PASSWORD の文字列は、ストレージアカウントのアクセスキーまたは SAS トークンに置き換えます。
-以下のSQLコマンドで、Blob Storage上のCSVファイルに対する外部テーブル定義を作成します。
-CREATE MULTISET FOREIGN TABLE WeatherData,
-EXTERNAL SECURITY DEFINER TRUSTED DefAuth_AZ (
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC,
- Payload DATASET INLINE LENGTH 64000 STORAGE FORMAT CSV
-)
-USING (
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata/')
-)| - - | --最低限、外部テーブルの定義には、テーブル名（WeatherData）と、オブジェクトストアのデータを指し示すロケーション句を含める必要があります。 - | -
LOCATION では、ストレージアカウント名とコンテナ名が必要です。これを自分のストレージアカウント名とコンテナ名に置き換える必要があります。
-オブジェクトに標準拡張子 (例えば、「.json」、「.csv」、「.parquet」) がない場合、 Location…Payload 列定義句も必要であり、LOCATION フェーズにファイル名を含める必要があります。例えば、以下のようになります。LOCATION (AZ/<storage account name>.blob.core.windows.net/<container>/<filename>)。
外部テーブルは常にNoPI（No Primary Index）テーブルとして定義されます。
-以下のSQL コマンドを実行して、データセットにクエリを実行します。
-SELECT * FROM WeatherData SAMPLE 10;外部テーブルには、2つの列しか含まれていません。LocationとPayloadです。Locationは、オブジェクトストアシステム内のアドレスです。データ自体はpayload列で表現され、外部テーブルの各レコード内のpayloadの値が1つのCSV行を表現します。
-
以下のSQLコマンドを実行し、オブジェクト内のデータに注目します。
-SELECT payload..* FROM WeatherData SAMPLE 10;
ビューを使用すると、ペイロード属性に関連する名前を簡素化でき、オブジェクトデータに対するSQLを簡単にコーディングでき、外部テーブルのLocation参照を隠蔽できます。
-| - - | -
-Vantage の外部テーブルでは、オブジェクト名と列名の区切りに .. (ダブルドットまたはダブルピリオド) オペレータが使用されます。
- |
-
以下の SQL コマンドを実行し、ビューを作成します。
-REPLACE VIEW WeatherData_view AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL(4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM WeatherData
-)以下の SQL コマンドを実行し、ビューを検証します。
-SELECT * FROM WeatherData_view SAMPLE 10;
ビューを作成した後は、オブジェクト ストアのデータをクエリで簡単に参照し、他のテーブル（Vantage のリレーショナル テーブルとオブジェクト ストアの外部テーブルの両方）と結合することができます。これにより、データがどこにあっても、Vantageの完全な分析機能を100%活用することができます。
-Blob Storageデータの永続的なコピーを持つことは、同じデータに繰り返しアクセスすることが予想される場合に便利です。NOS では、Blob Storage データの永続的なコピーは自動的に作成されません。外部テーブルを参照するたびに、VantageはBlob Storageからデータをフェッチします。(一部のデータはキャッシュされることがありますが、これは Blob Storage 内のデータのサイズと Vantage の他のアクティブなワークロードに依存します)。
-また、Blob Storage から転送されるデータに対してネットワーク料金が課金される場合があります。Blob Storage内のデータを複数回参照する場合は、一時的にでもVantageにロードすることでコストを削減することができます。
-Vantageにデータをロードする方法は、以下の中から選択できます。
-単一のステートメントで、テーブルの作成とデータのロードの両方を行うことができます。外部テーブルのペイロードから必要な属性を選択し、それらがリレーショナルテーブルでどのように呼ばれるかを選択することができます。
-*CREATE TABLE AS … WITH DATA*ステートメントは、ソーステーブルとして外部テーブル定義を使用することができます。-
以下のSQLコマンドを実行してリレーショナル テーブルを作成しデータをロードします。
-CREATE MULTISET TABLE WeatherData_temp AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL(4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- WeatherData
- WHERE
- Postal_Code = '36101'
-)
-WITH DATA
-NO PRIMARY INDEX下のSQLコマンドを実行し、テーブルの内容を検証します。
-SELECT * FROM WeatherData_temp SAMPLE 10;
複数のステートメントを使用して、最初にリレーショナルテーブルを作成し、その後データをロードすることもできます。この選択の利点は、複数のロードを実行できることです。オブジェクトが非常に大きい場合は、異なるデータを選択したり、より小さな増分でロードしたりできる可能性があります。
-以下の SQLコマンドを実行し、リレーショナルテーブルを作成します。
-CREATE MULTISET TABLE WeatherData_temp (
- Postal_code VARCHAR(10),
- Country CHAR(2),
- Time_Valid_UTC TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS',
- DOY_UTC INTEGER,
- Hour_UTC INTEGER,
- Time_Valid_LCL TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS',
- DST_Offset_Minutes INTEGER,
- Temperature_Air_2M_F DECIMAL(4,1),
- Temperature_Wetbulb_2M_F DECIMAL(3,1),
- Temperature_Dewpoint_2M_F DECIMAL(3,1),
- Temperature_Feelslike_2M_F DECIMAL(4,1),
- Temperature_Windchill_2M_F DECIMAL(4,1),
- Temperature_Heatindex_2M_F DECIMAL(4,1),
- Humidity_Relative_2M_Pct DECIMAL(3,1),
- Humdity_Specific_2M_GPKG DECIMAL(3,1),
- Pressure_2M_Mb DECIMAL(5,1),
- Pressure_Tendency_2M_Mb DECIMAL(2,1),
- Pressure_Mean_Sea_Level_Mb DECIMAL(5,1),
- Wind_Speed_10M_MPH DECIMAL(3,1),
- Wind_Direction_10M_Deg DECIMAL(4,1),
- Wind_Speed_80M_MPH DECIMAL(3,1),
- Wind_Direction_80M_Deg DECIMAL(4,1),
- Wind_Speed_100M_MPH DECIMAL(3,1),
- Wind_Direction_100M_Deg DECIMAL(4,1),
- Precipitation_in DECIMAL(3,2),
- Snowfall_in DECIMAL(3,2),
- Cloud_Cover_Pct INTEGER,
- Radiation_Solar_Total_WPM2 DECIMAL(5,1)
-)
-UNIQUE PRIMARY INDEX ( Postal_Code, Time_Valid_UTC )以下の SQLを実行し、データをテーブルにロードします。
-INSERT INTO WeatherData_temp
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL (4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- WeatherData
- WHERE
- Postal_Code = '30301'以下の SQL コマンドを実行し、テーブルの内容を検証します。
-SELECT * FROM WeatherData_temp SAMPLE 10;
外部テーブルを定義する代わりに、 READ_NOS テーブルオペレータを使用する方法があります。このテーブルオペレータを使うと、最初に外部テーブルを作成することなく、オブジェクトストアから直接データにアクセスしたり、Location句で指定されたすべてのオブジェクトに関連するキーの一覧を表示したりすることができます。
`READ_NOS` テーブルオペレータを使用すると、オブジェクト内のデータを探索することができます。-
以下のコマンドを実行し、オブジェクト内のデータを調査します。
- -LOCATION では、ストレージアカウント名とコンテナ名が必要です。これは上記で黄色で強調表示されています。これを自分のストレージアカウント名とコンテナ名で置き換える必要があります。
-ACCESS_ID の文字列を、ストレージアカウント名で置き換えます。
-ACCES_KEY の文字列を、ストレージアカウントのアクセスキーまたはSASトークン -に置き換えます。
-
また、READ_NOSテーブルオペレータを活用して、オブジェクトの長さ（サイズ）を取得することも可能です。
-以下の SQL コマンドを実行し、オブジェクトのサイズを表示します。
-SELECT
- location(CHAR(120)), ObjectLength
-FROM
- READ_NOS (
- ON (SELECT CAST( NULL AS DATASET STORAGE FORMAT CSV))
- USING
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata')
- ACCESS_ID('myconsumerstorage')
- ACCESS_KEY('*****')
- RETURNTYPE('NOSREAD_KEYS')
- ) AS THE_TABLE
-ORDER BY 1LOCATION、 ACCESS_ID、および ACCESS_KEY の値を入れ替えてください。
-
NOS_READテーブルオペレータは、上記セクションの外部テーブル定義で、データをリレーショナルテーブルに読み込むために代用することができます。
-CREATE MULTISET TABLE WeatherData_temp AS (
- SELECT
- CAST(payload..postal_code AS VARCHAR(10)) Postal_code,
- CAST(payload..country AS CHAR(2)) Country,
- CAST(payload..time_valid_utc AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_UTC,
- CAST(payload..doy_utc AS INTEGER) DOY_UTC,
- CAST(payload..hour_utc AS INTEGER) Hour_UTC,
- CAST(payload..time_valid_lcl AS TIMESTAMP(0) FORMAT 'YYYY-MM-DDBHH:MI:SS') Time_Valid_LCL,
- CAST(payload..dst_offset_minutes AS INTEGER) DST_Offset_Minutes,
- CAST(payload..temperature_air_2m_f AS DECIMAL (4,1)) Temperature_Air_2M_F,
- CAST(payload..temperature_wetbulb_2m_f AS DECIMAL(3,1)) Temperature_Wetbulb_2M_F,
- CAST(payload..temperature_dewpoint_2m_f AS DECIMAL(3,1)) Temperature_Dewpoint_2M_F,
- CAST(payload..temperature_feelslike_2m_f AS DECIMAL(4,1)) Temperature_Feelslike_2M_F,
- CAST(payload..temperature_windchill_2m_f AS DECIMAL(4,1)) Temperature_Windchill_2M_F,
- CAST(payload..temperature_heatindex_2m_f AS DECIMAL(4,1)) Temperature_Heatindex_2M_F,
- CAST(payload..humidity_relative_2m_pct AS DECIMAL(3,1)) Humidity_Relative_2M_Pct,
- CAST(payload..humidity_specific_2m_gpkg AS DECIMAL(3,1)) Humdity_Specific_2M_GPKG,
- CAST(payload..pressure_2m_mb AS DECIMAL(5,1)) Pressure_2M_Mb,
- CAST(payload..pressure_tendency_2m_mb AS DECIMAL(2,1)) Pressure_Tendency_2M_Mb,
- CAST(payload..pressure_mean_sea_level_mb AS DECIMAL(5,1)) Pressure_Mean_Sea_Level_Mb,
- CAST(payload..wind_speed_10m_mph AS DECIMAL(3,1)) Wind_Speed_10M_MPH,
- CAST(payload..wind_direction_10m_deg AS DECIMAL(4,1)) Wind_Direction_10M_Deg,
- CAST(payload..wind_speed_80m_mph AS DECIMAL(3,1)) Wind_Speed_80M_MPH,
- CAST(payload..wind_direction_80m_deg AS DECIMAL(4,1)) Wind_Direction_80M_Deg,
- CAST(payload..wind_speed_100m_mph AS DECIMAL(3,1)) Wind_Speed_100M_MPH,
- CAST(payload..wind_direction_100m_deg AS DECIMAL(4,1)) Wind_Direction_100M_Deg,
- CAST(payload..precipitation_in AS DECIMAL(3,2)) Precipitation_in,
- CAST(payload..snowfall_in AS DECIMAL(3,2)) Snowfall_in,
- CAST(payload..cloud_cover_pct AS INTEGER) Cloud_Cover_Pct,
- CAST(payload..radiation_solar_total_wpm2 AS DECIMAL(5,1)) Radiation_Solar_Total_WPM2
- FROM
- READ_NOS (
- ON (SELECT CAST( NULL AS DATASET STORAGE FORMAT CSV))
- USING
- LOCATION ('/AZ/myconsumerstorage.blob.core.windows.net/consumerdata')
- ACCESS_ID('myconsumerstorage')
- ACCESS_KEY('*****')
- ) AS THE_TABLE
- WHERE
- Postal_Code = '36101'
-)
-WITH DATA| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --このハウツーでは、Teradata Extensions を Jupyter Notebooks 環境に追加する方法を示します。Teradata Extensions および分析ツールと統合された Jupyter Notebooks のホストされたバージョンは、https://clearscape.teradata.comで無料で機能テストに利用できます。 - | -
Teradata Jupyter拡張は、Teradata SQLカーネルといくつかのUI拡張を提供し、ユーザーがJupyter環境からTeradataデータベースに容易にアクセスし、操作できるようにします。Google Vertex AIは、Google Cloudの新しい統合MLプラットフォームです。Vertex AI Workbenchは、データサイエンスワークフロー全体のためのJupyterベースの開発環境を提供します。今回は、Vertex AIユーザーがMLパイプラインでTeradata拡張を利用できるように、弊社のJupyterエクステンションをVertex AI Workbenchと統合するについて説明します。
-Vertex AI Workbenchは、マネージドNotebookとユーザーマネージドNotebookの2種類のNotebookをサポートしています。ここでは、ユーザー管理型Notebookに焦点を当てます。Jupyter 拡張機能をユーザー管理のNotebookと統合する 2 つの方法を示します。スタートアップスクリプトを使用してカーネルと拡張機能をインストールする方法と、カスタムコンテナを使用する方法の2種類があります。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Vertex AIを有効にしたGoogle Cloudアカウント
-起動スクリプトとTeradata Jupyter拡張パッケージを保存するためのGoogleクラウドストレージ
-Vertex AIでTeradata Jupyter Extensionsを実行するには、2つの方法があります。
-この2つの統合方法について、以下に説明します。
-新しいNotebookインスタンスを作成する際に、スタートアップスクリプトを指定することができます。このスクリプトは、インスタンスの作成後に一度だけ実行されます。以下はその手順です。
-Teradata Jupyter 拡張パッケージのダウンロードする
-Vantage Modules for Jupyter ページから、Teradata Jupyter extensionsパッケージのバンドルLinux版をダウンロードします。
-パッケージを Google Cloud ストレージ バケットにアップロードする
-起動スクリプトを作成し、クラウドストレージバケットにアップロードする
-下記はサンプルスクリプトです。クラウドストレージバケットからTeradata Jupyter extensionパッケージを取得し、Teradata SQLカーネルとエクステンションをインストールします。
-#! /bin/bash
-
-cd /home/jupyter
-mkdir teradata
-cd teradata
-gsutil cp gs://teradata-jupyter/* .
-unzip teradatasql*.zip
-
-# Install Teradata kernel
-cp teradatakernel /usr/local/bin
-
-jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-# Install Teradata extensions
-pip install --find-links . teradata_preferences_prebuilt
-pip install --find-links . teradata_connection_manager_prebuilt
-pip install --find-links . teradata_sqlhighlighter_prebuilt
-pip install --find-links . teradata_resultset_renderer_prebuilt
-pip install --find-links . teradata_database_explorer_prebuilt
-
-# PIP install the Teradata Python library
-pip install teradataml
-
-# Install Teradata R library (optional, uncomment this line only if you use an environment that supports R)
-#Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"新しいNotebookを作成し、クラウドストレージバケットからスタートアップスクリプトを追加する
-
Notebookの作成が完了するまで、数分かかる場合があります。完了したら、 Open notebook をクリックする。
もう 1 つのオプションは、Notebookの作成時にカスタム コンテナを提供することです。
-Teradata Jupyter エクステンションパッケージのダウンロードする
-Vantage Modules for Jupyter ページから、Teradata Jupyter extensionsパッケージバンドルLinux版をダウンロードします。
-このパッケージを作業ディレクトリにコピーし、解凍する
-カスタム Docker イメージを構築する
-カスタムコンテナは、8080番ポートでサービスを公開する必要があります。Google Deep Learning Containersイメージから派生したコンテナを作成することをお勧めします。これらのイメージは、ユーザ管理Notebookと互換性があるようにすでに構成されているからです。
-以下は、Teradata SQLカーネルおよび拡張機能をインストールしたDockerイメージを構築するために使用できるDockerfileのサンプルです。
-# Use one of the deep learning images as base image
-# if you need both Python and R, use one of the R images
-FROM gcr.io/deeplearning-platform-release/r-cpu:latest
-
-USER root
-
-##############################################################
-# Install kernel and copy supporting files
-##############################################################
-
-# Copy the kernel
-COPY ./teradatakernel /usr/local/bin
-
-RUN chmod 755 /usr/local/bin/teradatakernel
-
-# Copy directory with kernel.json file into image
-COPY ./teradatasql teradatasql/
-
-# Copy notebooks and licenses
-COPY ./notebooks/ /home/jupyter
-COPY ./license.txt /home/jupyter
-COPY ./ThirdPartyLicenses/ /home/jupyter
-
-# Install the kernel file to /opt/conda jupyter lab instance
-RUN jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-##############################################################
-# Install Teradata extensions
-##############################################################
-
-RUN pip install --find-links . teradata_preferences_prebuilt && \
- pip install --find-links . teradata_connection_manager_prebuilt && \
- pip install --find-links . teradata_sqlhighlighter_prebuilt && \
- pip install --find-links . teradata_resultset_renderer_prebuilt && \
- pip install --find-links . teradata_database_explorer_prebuilt
-
-# Give back ownership of /opt/conda to jovyan
-RUN chown -R jupyter:users /opt/conda
-
-# PIP install the Teradata Python libraries
-RUN pip install teradataml
-
-# Install Teradata R library (optional, include it only if you use a base image that supports R)
-RUN Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"作業ディレクトリ（Teradata Jupyter extensionsパッケージを解凍した場所）で、`docker build`を実行してイメージをビルドしてください。
-docker build -f Dockerfile imagename:imagetag .docker イメージを Google コンテナレジストリまたはアーティファクトレジストリにプッシュする。
-docker イメージをレジストリにプッシュするには、以下のドキュメントを参照してください。
-新しいNotebookを作成する
-Environment セクションで、 custom container フィールドを新しく作成したカスタム コンテナの場所に設定します。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --このハウツーでは、Teradata Extensions を Jupyter Notebooks 環境に追加する方法を示します。Teradata Extensions および分析ツールと統合された Jupyter Notebooks のホストされたバージョンは、https://clearscape.teradata.comで無料で機能テストに利用できます。 - | -
Teradata Jupyter ExtentionsはTeradata SQLカーネルといくつかのUI拡張を提供しユーザーがJupyter環境からTeradataデータベースを簡単に操作できるようにするものです。今回は、Jupyter ExtentionsとSageMakerNotebookインスタンスを連携させる方法について説明します。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
AWS アカウント
-ライフサイクル構成スクリプトとTeradata Jupyter Extentionsパッケージを格納するためのAWS S3バケット
-SageMakerは、ライフサイクルコンフィギュレーションスクリプトを使用したNotebookインスタンスのカスタマイズをサポートしています。以下では、ライフサイクル構成スクリプトを使用して、Jupyterカーネルと拡張機能をNotebookインスタンスにインストールする方法をデモします。
-Teradata Jupyter Extentionsパッケージのダウンロードする
-Linux版を https://downloads.teradata.com/download/tools/vantage-modules-for-jupyter からダウンロードし、S3バケットにアップロードしてください。Teradata Jupyterのカーネルとエクステンションを含むzipパッケージです。各エクステンションには2つのファイルがあり、名前に"_prebuilt "が付いているものがPIPでインストールできるプリビルドエクステンション、もう1つが "jupyter labextension "でインストールする必要があるソースエクステンションになります。プレビルド拡張を使用することをお勧めします。
-notebookインスタンスのライフサイクル設定の作成する
-
以下はS3バケットからTeradataパッケージを取得しJupyterカーネルとエクステンションをインストールするスクリプトのサンプルです。on-create.shはNotebookインスタンスのEBSボリュームに永続化するカスタムconda envを作成し、Notebook再起動後にインストールが失われないようにしています。on-start.shは、カスタムconda envにTeradataカーネルとエクステンションをインストールします。
-on-create.sh
-#!/bin/bash
-
-set -e
-
-# This script installs a custom, persistent installation of conda on the Notebook Instance's EBS volume, and ensures
-# that these custom environments are available as kernels in Jupyter.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-# Install a separate conda installation via Miniconda
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-mkdir -p "$WORKING_DIR"
-wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
-bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda"
-rm -rf "$WORKING_DIR/miniconda.sh"
-# Create a custom conda environment
-source "$WORKING_DIR/miniconda/bin/activate"
-KERNEL_NAME="teradatasql"
-
-PYTHON="3.8"
-conda create --yes --name "$KERNEL_NAME" python="$PYTHON"
-conda activate "$KERNEL_NAME"
-pip install --quiet ipykernel
-
-EOFon-start.sh
-#!/bin/bash
-
-set -e
-
-# This script installs Teradata Jupyter kernel and extensions.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-
-source "$WORKING_DIR/miniconda/bin/activate" teradatasql
-
-# fetch Teradata Jupyter extensions package from S3 and unzip it
-mkdir -p "$WORKING_DIR/teradata"
-aws s3 cp s3://sagemaker-teradata-bucket/teradatasqllinux_3.3.0-ec06172022.zip "$WORKING_DIR/teradata"
-cd "$WORKING_DIR/teradata"
-
-unzip -o teradatasqllinux_3.3.0-ec06172022.zip
-
-# install Teradata kernel
-cp teradatakernel /home/ec2-user/anaconda3/condabin
-jupyter kernelspec install --user ./teradatasql
-
-# install Teradata Jupyter extensions
-source /home/ec2-user/anaconda3/bin/activate JupyterSystemEnv
-
-pip install teradata_connection_manager_prebuilt-3.3.0.tar.gz
-pip install teradata_database_explorer_prebuilt-3.3.0.tar.gz
-pip install teradata_preferences_prebuilt-3.3.0.tar.gz
-pip install teradata_resultset_renderer_prebuilt-3.3.0.tar.gz
-pip install teradata_sqlhighlighter_prebuilt-3.3.0.tar.gz
-
-conda deactivate
-EOFNotebook インスタンスを作成するPlatform identifierに「Amazon Linux 2, Jupyter Lab3」を選択しLifecycle configurationに手順2で作成したライフサイクル構成を選択してください。
-
また、Teradataデータベースにアクセスするために「Network」セクションにvpc、サブネット、セキュリティグループを追加する必要がある場合があります。
-Notebookインスタンスのステータスが「InService」になるまで待ち「Open JupyterLab」をクリックし、Notebookを開く。
-
デモノートにアクセスし使い方のヒントを得ることができます。
-+
-
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このハウツーでは、SalesforceとTeradata Vantageの間でデータを移行するプロセスについて説明します。2つのユースケースを含みます。
-Salesforceから顧客情報を取得し、Vantageから注文および出荷情報と組み合わせて、分析的な洞察を得ます。
-Vantage の newleads テーブルを Salesforce のデータで更新し、AppFlow を使用して新しいリードを Salesforce に追加します。
Amazon AppFlowは、SalesforceからAmazon S3に顧客アカウントデータを転送します。その後、Vantage は Native Object Store (NOS) の読み込み機能を使用して、Amazon S3 のデータと Vantage のデータを 1 回のクエリーで結合します。
-アカウント情報は、Vantage 上の newleads テーブルの更新に使用されます。テーブルが更新されると、VantageはNOS WriteでAmazon S3バケットに書き戻す。新しいリードデータファイルの到着時にLambda関数が起動し、データファイルをParquet形式からCSV形式に変換し、AppFlowは新しいリードをSalesforceに挿入し直します。
Amazon AppFlowは、Salesforce、Marketo、Slack、ServiceNowなどのSaaSアプリケーションと、Amazon S3やAmazon RedshiftなどのAWSサービス間で安全にデータを転送できる、フルマネージド型の統合サービスです。AppFlowは、移動中のデータを自動的に暗号化し、AWS PrivateLinkと統合されたSaaSアプリケーションの公衆インターネット上でのデータのフローを制限することができ、セキュリティ脅威への露出を減らすことができます。
-現在、Amazon AppFlowは16のソースから選択でき、4つの宛先にデータを送信することができます。
-Teradata Vantageは、エンタープライズ分析のためのマルチクラウド対応データプラットフォームであり、データに関する課題を最初から最後まで解決します。
-Vantageにより、企業は小規模から始めてコンピュートやストレージを弾力的に拡張し、使用した分だけ支払い、低コストのオブジェクトストアを活用し、分析ワークロードを統合することができます。Vantageは、R、Python、Teradata Studio、その他あらゆるSQLベースのツールをサポートします。
-Vantageは、記述的分析、予測的分析、処方的分析、自律的意思決定、ML機能、可視化ツールを統合したプラットフォームで、データがどこにあっても、リアルタイムのビジネスインテリジェンスを大規模に発掘することができます。
-Teradata Vantage Native Object Store（NOS）は、Amazon S3などの外部オブジェクトストアにあるデータを、標準SQLを使用して探索することが可能です。NOSを使用するために、特別なオブジェクトストレージ側の計算インフラは必要ありません。Amazon S3のバケットにあるデータを探索するには、バケットを指すNOSテーブル定義を作成するだけでよいのです。NOSを使用すると、Amazon S3からデータを迅速にインポートしたり、Vantageデータベースの他のテーブルと結合したりすることもできます。
-Amazon AppFlowサービスおよびTeradata Vantageに精通していることが前提です。
-以下のアカウントとシステムが必要です。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
フローの作成と実行が可能なロールを持つAWSアカウント。
-Salesforce データを保存するための Amazon S3 バケット (例: ptctsoutput)
-生の Vantage データ (Parquet ファイル) を保存する Amazon S3 バケット (例: vantageparquet)。このバケットには、Amazon AppFlowのアクセスを認証するポリシーが必要です。
-変換された Vantage データ (CSV ファイル) を保存する Amazon S3 バケット (例: vantagecsv)
-以下の要件を満たすSalesforceアカウント。
-お客様の Salesforce アカウントで、API アクセスを有効にする必要があります。Enterprise、Unlimited、Developer、および Performance エディションでは、API アクセスはデフォルトで有効になっています。
-Salesforce アカウントで、接続アプリのインストールが認証されている必要があります。これが無効になっている場合は、Salesforce 管理者にお問い合わせください。Amazon AppFlow で Salesforce 接続を作成した後、「Amazon AppFlow Embedded Login App」という名前の接続アプリが Salesforce アカウントにインストールされていることを確認します。
-Amazon AppFlow Embedded Login App」のリフレッシュトークンポリシーは、「Refresh token is valid until revoked」に設定されている必要があります。そうでない場合、リフレッシュトークンの有効期限が切れるとフローが失敗します。
-イベント駆動型のフロートリガーを使用するには、SalesforceのChange Data Captureを有効にする必要があります。セットアップから、クイック検索に「Change Data Capture」と入力します。
-Salesforce アプリが IP アドレスの制限を実施している場合、Amazon AppFlow で使用するアドレスをホワイトリストに登録する必要があります。詳細については、Amazon Web Services General Reference の AWS IP アドレス範囲 を参照してください。
-Salesforce のレコードを 100 万件以上転送する場合、Salesforce の複合フィールドを選択することはできません。Amazon AppFlow は転送に Salesforce Bulk API を使用するため、複合フィールドの転送は認証されません。
-AWS PrivateLinkを使用してプライベート接続を作成するには、Salesforceアカウントで「メタデータの管理」と「外部接続の管理」の両方のユーザー権限を有効にする必要があります。プライベート接続は現在、us-east-1 および us-west-2 の AWS リージョンで利用可能です。
-履歴オブジェクトなど、更新できないSalesforceオブジェクトがあります。これらのオブジェクトについて、Amazon AppFlowは、スケジュールトリガー型のフローの増分エクスポート（「新しいデータのみを転送」オプション）をサポートしません。代わりに、「すべてのデータを転送する」オプションを選択し、適切なフィルタを選択して転送するレコードを制限することができます。
-前提条件を満たした上で、以下の手順で行います。
-Salesforce to Amazon S3 フローを作成する
-NOS を使用したデータの探索する
-NOS を使用して Vantage データを Amazon S3 にエクスポートする
-Amazon S3からSalesforceへのフローを作成する
-このステップでは、Amazon AppFlowを使用してフローを作成します。この例では、 Salesforce 開発者アカウント を使用してSalesforceに接続します。
-https://console.aws.amazon.com/appflow[AppFlow コンソール] にアクセスし、AWSログイン認証でサインインし、 *Create flow* をクリックします。正しいリージョンにいること、Salesforceのデータを保存するためのバケットが作成されていることを確認します。-
このステップでは、フローの基本情報を提供します。
-*フロー名* (例： _salesforce_) と *フローの説明(オプション)* を入力し、 *暗号化設定のカスタマイズ(詳細)* のチェックを外したままにします。*次へ* をクリックします。-
このステップでは、フローのソースと宛先に関する情報を提供します。この例では、ソースとして Salesforce を、宛先として Amazon S3 を使用します。
-Source name で Salesforce を選択し、*Choose Salesforce connection*で * Create new connection*を選択します。
-
Salesforce環境 と データの暗号化 にデフォルトを使用する。接続に名前（例：salesforce）を付けて、 Continue をクリックします。
-
salesforceのログインウィンドウで、 Username と Password を入力します。 ログイン をクリックします。
-
Allow をクリックして、AppFlowによるSalesforceのデータおよび情報へのアクセスを認証します。
-
AppFlow の*Configure flow* ウィンドウに戻り、 Salesforceオブジェクト を使用し、Salesforce オブジェクトとして Account を選択します。
-
Destination name として Amazon S3 を使用します。 先ほど 作成した、データを保存するバケット（例：ptctsoutput)を選択します。
-
Flow trigger を Run on demand にします。 Next をクリックします。
-
このステップでは、データがソースから宛先に転送される方法を決定します。
-マッピング方法 -として、手動でフィールドをマッピングする を使用します* 簡単のため、 送信元から送信先へのマッピング には Map all fields directly を選択します。
-
「Map all fields directly」をクリックすると、Mapped fields*の下にすべてのフィールドが表示される。 *Add formula (concatenates)、 Modify values (mask or truncate field values)、または *Remove selected mappings*を行うフィールドのチェックボックスをクリックします。
-この例では、チェックボックスは選択されない。
-Validations では、「Billing Address」が含まれていないレコードを無視する条件を追加します（オプション）。 Next をクリックします。
-
転送するレコードを決定するためのフィルタを指定することができます。この例では、削除されたレコードをフィルタリングする条件を追加します（オプション）。Next をクリックします。
-
入力したすべての情報を確認します。必要であれば修正します。Create flow をクリックします 。
-フローが作成されると、フロー情報とともにフロー作成成功のメッセージが表示されます。
-
Native Object Storeには、Amazon S3内のデータを探索 分析するための機能が組み込まれています。ここでは、NOSのよく使われる機能をいくつか列挙します。
-外部テーブルを使用すると、Vantage Advanced SQL Engine 内で外部データを簡単に参照できるようになり、構造化されたリレーショナル形式でデータを利用できるようになります。
-外部テーブルを作成するには、まず認証情報を使用してTeradata Vantageシステムにログインします。Amazon S3バケットにアクセスするためのアクセスキーを持つAUTHORIZATIONオブジェクトを作成します。Authorizationオブジェクトは、誰がAmazon S3データにアクセスするために外部テーブルの使用を認証されるかの制御を確立することで、セキュリティを強化します。
-
CREATE AUTHORIZATION DefAuth_S3
-AS DEFINER TRUSTED
-USER 'A*****************' /* AccessKeyId */
-PASSWORD '********'; /* SecretAccessKey */"USER "はAWSアカウントのAccessKeyId、"PASSWORD "はSecretAccessKeyです。
-Amazon S3上のJSONファイルに対して、以下のコマンドで外部テーブルを作成します。
-CREATE MULTISET FOREIGN TABLE salesforce,
-EXTERNAL SECURITY DEFINER TRUSTED DefAuth_S3
-(
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC,
- Payload JSON(8388096) INLINE LENGTH 32000 CHARACTER SET UNICODE
-)
-USING
-(
- LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
-);最低限、外部テーブルの定義には、テーブル名と、オブジェクトストアのデータを指すLocation句（黄色でハイライトされています）を含める必要があります。Locationは、Amazonでは "bucket"と呼ばれるトップレベルの単一名が必要です。
-ファイル名の末尾に標準的な拡張子（.json, .csv, .parquet）がない場合、データファイルの種類を示すために、LocationとPayload列の定義も必要です（ターコイズ色でハイライトされている）。
-外部テーブルは常にNo Primary Index (NoPI)テーブルとして定義される。
-外部テーブルが作成されると、外部テーブル上で "選択 "を実行することにより、Amazon S3データセットの内容を照会することができます。
-SELECT * FROM salesforce;
-SELECT payload.* FROM salesforce;外部テーブルには、2つの列しか含まれていません。LocationとPayloadです。Locationは、オブジェクトストアシステム内のアドレスです。データ自体はpayload列で表され、外部テーブルの各レコード内のpayload値は、単一のJSONオブジェクトとそのすべての名前-値ペアを表します。
-”SELECT * FROM salesforce;” からの出力例。
-
サンプル出力形式 "SELECT payload.* FROM salesforce;"。
-
JSONデータには、レコードごとに異なる属性が含まれることがあります。データストアに含まれる可能性のある属性の完全なリストを決定するには、JSON_KEYSを使用します。
-|SELECT DISTINCT * FROM JSON_KEYS (ON (SELECT payload FROM salesforce)) AS j;部分出力
-
ビューは、ペイロード属性に関連する名前を単純化し、オブジェクトストアのデータに対して実行可能なSQLを簡単にコーディングできるようにし、外部テーブルのLocation参照を隠して通常の列のように見えるようにすることができます。
-以下は、上記の JSON_KEYS テーブルオペレータから検出された属性を使用したビュー作成文のサンプルです。
-REPLACE VIEW salesforceView AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS VARCHAR(10)) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.LastActivityDate AS VARCHAR(50)) Last_Activity_Date
- FROM salesforce
-);SELECT * FROM salesforceView;部分出力
-
READ_NOSテーブルオペレータは、最初に外部テーブルを定義せずにデータの一部をサンプリングして調査したり、Location句で指定したすべてのオブジェクトに関連するキーのリストを表示するために使用できます。
-SELECT top 5 payload.*
-FROM READ_NOS (
- ON (SELECT CAST(NULL AS JSON CHARACTER SET Unicode))
-USING
-LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
- ACCESS_ID ('A**********') /* AccessKeyId */
- ACCESS_KEY ('***********') /* SecretAccessKey */
- ) AS D
-GROUP BY 1;出力:
-
外部テーブルを Vantage 内のテーブルと結合して、さらに分析することができます。例えば、注文と配送の情報は、VantageのOrders、Order_Items、Shipping_Addressの3つのテーブルに格納されています。
-Orders の DDL:
-CREATE TABLE Orders (
- Order_ID INT NOT NULL,
- Customer_ID VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC,
- Order_Status INT,
- -- Order status: 1 = Pending; 2 = Processing; 3 = Rejected; 4 = Completed
- Order_Date DATE NOT NULL,
- Required_Date DATE NOT NULL,
- Shipped_Date DATE,
- Store_ID INT NOT NULL,
- Staff_ID INT NOT NULL
-) Primary Index (Order_ID);Order_Items の DDL:
-CREATE TABLE Order_Items(
- Order_ID INT NOT NULL,
- Item_ID INT,
- Product_ID INT NOT NULL,
- Quantity INT NOT NULL,
- List_Price DECIMAL (10, 2) NOT NULL,
- Discount DECIMAL (4, 2) NOT NULL DEFAULT 0
-) Primary Index (Order_ID, Item_ID);Shipping_Address の DDL:
-CREATE TABLE Shipping_Address (
- Customer_ID VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC NOT NULL,
- Street VARCHAR(100) CHARACTER SET LATIN CASESPECIFIC,
- City VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC,
- State VARCHAR(15) CHARACTER SET LATIN CASESPECIFIC,
- Postal_Code VARCHAR(10) CHARACTER SET LATIN CASESPECIFIC,
- Country VARCHAR(20) CHARACTER SET LATIN CASESPECIFIC
-) Primary Index (Customer_ID);そして、テーブルには以下のデータがあります。
-Orders:
-
Order_Items:
-
Shipping_Address:
-
データベースのOrders, Order_Items, Shipping_Address テーブルにsalesforceの外部テーブルを結合することで、顧客の注文情報を顧客の配送情報とともに取得することができます。
-SELECT
- s.payload.Id as Customer_ID,
- s.payload."Name" as Customer_Name,
- s.payload.AccountNumber as Acct_Number,
- o.Order_ID as Order_ID,
- o.Order_Status as Order_Status,
- o.Order_Date as Order_Date,
- oi.Item_ID as Item_ID,
- oi.Product_ID as Product_ID,
- sa.Street as Shipping_Street,
- sa.City as Shipping_City,
- sa.State as Shipping_State,
- sa.Postal_Code as Shipping_Postal_Code,
- sa.Country as Shipping_Country
-FROM
- salesforce s, Orders o, Order_Items oi, Shipping_Address sa
-WHERE
- s.payload.Id = o.Customer_ID
- AND o.Customer_ID = sa.Customer_ID
- AND o.Order_ID = oi.Order_ID
-ORDER BY 1;結果:
-
Amazon S3データの永続的なコピーを持つことは、同じデータへの反復的なアクセスが予想される場合に便利です。NOSの外部テーブルでは、自動的にAmazon S3データの永続的なコピーを作成しません。データベースにデータを取り込むためのいくつかのアプローチについて、以下に説明します。
-CREATE TABLE AS … WITH DATAステートメントは、ソーステーブルとして機能する外部テーブル定義で使用することができます。このアプローチでは、外部テーブルのペイロードのうち、ターゲットテーブルに含めたい属性と、リレーショナルテーブルの列の名前を選択的に選択することができます。
-CREATE TABLE salesforceVantage AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM salesforce)
-WITH DATA
-NO PRIMARY INDEX;SELECT* * FROM salesforceVantage; 部分的な結果:
外部テーブルを使用する代わりに、READ_NOS テーブルオペレータを使用することができます。このテーブルオペレータにより、最初に外部テーブルを構築することなく、オブジェクトストアから直接データにアクセスすることができます。READ_NOSをCREATE TABLE AS句と組み合わせて、データベース内にデータの永続的なバージョンを構築することができます。
-CREATE TABLE salesforceReadNOS AS (
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM READ_NOS (
- ON (SELECT CAST(NULL AS JSON CHARACTER SET Unicode))
- USING
- LOCATION ('/S3/s3.amazonaws.com/ptctstoutput/salesforce/1ce190bc-25a9-4493-99ad-7497b497a0d0/903790813-2020-08-21T21:02:25')
- ACCESS_ID ('A**********') /* AccessKeyId */
- ACCESS_KEY ('***********') /* SecretAccessKey */
- ) AS D
-) WITH DATA;`salesforceReadNOS`テーブルからの結果:
-SELECT * FROM salesforceReadNOS;
Amazon S3データをリレーショナルテーブルに配置するもう一つの方法は、"INSERT SELECT "です。このアプローチでは、外部テーブルがソーステーブルであり、新しく作成されたパーマネントテーブルが挿入されるテーブルとなります。上記のREAD_NOSの例とは逆に、この方法ではパーマネントテーブルを事前に作成する必要があります。
-INSERT SELECT方式の利点の1つは、ターゲット テーブルの属性を変更できることです。例えば、ターゲットテーブルを`MULTISET`にするかしないかを指定したり、別のプライマリインデックスを選択したりすることができます。
-CREATE TABLE salesforcePerm, FALLBACK ,
-NO BEFORE JOURNAL,
-NO AFTER JOURNAL,
-CHECKSUM = DEFAULT,
-DEFAULT MERGEBLOCKRATIO,
-MAP = TD_MAP1
-(
- Customer_Id VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- Acct_Number VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Street VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_City VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_State VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Post_Code VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- Billing_Country VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Phone VARCHAR(15) CHARACTER SET LATIN NOT CASESPECIFIC,
- Fax VARCHAR(15) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Street VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_City VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_State VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Post_Code VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- Shipping_Country VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Industry VARCHAR(50) CHARACTER SET LATIN NOT CASESPECIFIC,
- Description VARCHAR(200) CHARACTER SET LATIN NOT CASESPECIFIC,
- Num_Of_Employee INT,
- Priority VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Rating VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- SLA VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Type VARCHAR(20) CHARACTER SET LATIN NOT CASESPECIFIC,
- Customer_Website VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- Annual_Revenue VARCHAR(10) CHARACTER SET LATIN NOT CASESPECIFIC,
- Last_Activity_Date DATE
-) PRIMARY INDEX (Customer_ID);INSERT INTO salesforcePerm
- SELECT
- CAST(payload.Id AS VARCHAR(20)) Customer_ID,
- CAST(payload."Name" AS VARCHAR(100)) Customer_Name,
- CAST(payload.AccountNumber AS VARCHAR(10)) Acct_Number,
- CAST(payload.BillingStreet AS VARCHAR(20)) Billing_Street,
- CAST(payload.BillingCity AS VARCHAR(20)) Billing_City,
- CAST(payload.BillingState AS VARCHAR(10)) Billing_State,
- CAST(payload.BillingPostalCode AS VARCHAR(5)) Billing_Post_Code,
- CAST(payload.BillingCountry AS VARCHAR(20)) Billing_Country,
- CAST(payload.Phone AS VARCHAR(15)) Phone,
- CAST(payload.Fax AS VARCHAR(15)) Fax,
- CAST(payload.ShippingStreet AS VARCHAR(20)) Shipping_Street,
- CAST(payload.ShippingCity AS VARCHAR(20)) Shipping_City,
- CAST(payload.ShippingState AS VARCHAR(10)) Shipping_State,
- CAST(payload.ShippingPostalCode AS VARCHAR(5)) Shipping_Post_Code,
- CAST(payload.ShippingCountry AS VARCHAR(20)) Shipping_Country,
- CAST(payload.Industry AS VARCHAR(50)) Industry,
- CAST(payload.Description AS VARCHAR(200)) Description,
- CAST(payload.NumberOfEmployees AS INT) Num_Of_Employee,
- CAST(payload.CustomerPriority__c AS VARCHAR(10)) Priority,
- CAST(payload.Rating AS VARCHAR(10)) Rating,
- CAST(payload.SLA__c AS VARCHAR(10)) SLA,
- CAST(payload."Type" AS VARCHAR(20)) Customer_Type,
- CAST(payload.Website AS VARCHAR(100)) Customer_Website,
- CAST(payload.AnnualRevenue AS VARCHAR(10)) Annual_Revenue,
- CAST(payload.LastActivityDate AS DATE) Last_Activity_Date
- FROM salesforce;SELECT * FROM salesforcePerm;結果のサンプル:
-
Vantage システムで1 行を含む newleads テーブルがあります。
このリードにはアドレス情報がないことに注記してください。Salesforceから取得したアカウント情報を使って、`newleads`テーブルを更新してみましょう。
-UPDATE nl
-FROM
- newleads AS nl,
- salesforceReadNOS AS srn
-SET
- Street = srn.Billing_Street,
- City = srn.Billing_City,
- State = srn.Billing_State,
- Post_Code = srn.Billing_Post_Code,
- Country = srn.Billing_Country
- WHERE Account_ID = srn.Acct_Number;これで、新しいリードにアドレス情報が付与されました。
-
WRITE_NOSを使用して、新しいリード情報をS3バケットに書き込みます。
-SELECT * FROM WRITE_NOS (
-ON (
- SELECT
- Account_ID,
- Last_Name,
- First_Name,
- Company,
- Cust_Title,
- Email,
- Status,
- Owner_ID,
- Street,
- City,
- State,
- Post_Code,
- Country
- FROM newleads
-)
-USING
- LOCATION ('/s3/vantageparquet.s3.amazonaws.com/')
- AUTHORIZATION ('{"Access_ID":"A*****","Access_Key":"*****"}')
- COMPRESSION ('SNAPPY')
- NAMING ('DISCRETE')
- INCLUDE_ORDERING ('FALSE')
- STOREDAS ('CSV')
-) AS d;ここで、Access_IDはAccessKeyID、Access_KeyはBucketに対するSecretAccessKeyです。
-ステップ1を繰り返し、ソースにAmazon S3、宛先にSalesforceを使用したフローを作成します。
-このステップでは、フローの基本情報を提供する。
-*Flow name* (例： _vantage2SF_) と *Flow description (optional)*を入力し、 *Customize encryption settings (advanced)* のチェックは外したままにします。*Next*をクリックします。-
このステップでは、フローの送信元と送信先に関する情報を提供します。この例では、ソースとして Amazon S3 を、宛先として Salesforce を使用します。
-*Source details*は、 _Amazon S3_を選択し、CSVファイルを書き込んだバケットを選択します（例：vantagecsv）。
-Destination details は、Salesforce を選択し、Choose Salesforce connection のドロップダウンリストでStep1で作成した接続を使用し、Choose Salesforce object として_Lead_ を選択します。
-*Error handling*の場合は、デフォルトの_Stop the current flow run_を使用する。
-Flow trigger は _Run on demand_です。 *Next*をクリックします。
-このステップでは、ソースからデスティネーションへのデータ転送の方法を決定します。
-Mapping method -として、Manually map fields を使用します* Destination record preference -として、Insert new records (default) を使用します* 送信元から送信先へのマッピング には、次のマッピングを使用します
-
Next をクリックします。
-Salesforce データの使用が完了したら、使用したリソースに対して AWS アカウント (AppFlow、 Amazon S3、 Vantage 、 VMなど) に請求されないように、以下の手順を実行します。
-AppFlow:
-フローに作成した「接続」を削除する
-フローを削除する
-Amazon S3バケットとファイル:
-Vantage データファイルが保存されている Amazon S3 バケットに移動し、ファイルを削除する
-バケットを保持する必要がない場合は、バケットを削除する
-Teradata Vantage インスタンス
-不要になったインスタンスを停止/終了する
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- この記事では、 Data Catalog Teradata Connector on GitHub を使用して Teradata VantageとGoogle Cloud Data Catalogを接続し、Data Catalog経由でVantageテーブルのメタデータを探索する手順について説明します。
-
Scrape: Teradata Vantageに接続し、利用可能なすべてのメタデータを取得する
-Prepare: Data Catalogエンティティでメタデータを変換し、タグを作成する
-Ingest: Data CatalogエンティティをGoogle Cloudプロジェクトに送信する
-Google Cloud Data Catalog は、完全に管理されたデータ検出およびメタデータ管理サービスです。Data Catalog は、データ アセットのネイティブなメタデータをカタログ化することができます。Data Catalog はサーバーレスであり、テクニカルメタデータとビジネスメタデータの両方を構造化された形式で取り込むためのセントラルカタログを提供します。
-Vantageは、データウェアハウス、データレイク、アナリティクスを単一の接続されたエコシステムに統合する最新のクラウドプラットフォームです。
-Vantageは、記述的分析、予測的分析、処方的分析、自律的意思決定、ML機能、可視化ツールを統合したプラットフォームで、データの所在を問わず、リアルタイムのビジネスインテリジェンスを大規模に発掘することが可能です。
-Vantageは、小規模から始めて、コンピュートやストレージを弾力的に拡張し、使用した分だけ支払い、低コストのオブジェクトストアを活用し、分析ワークロードを統合することを可能にします。
-Vantageは、R、Python、Teradata Studio、およびその他のSQLベースのツールをサポートしています。Vantageは、パブリッククラウド、オンプレミス、最適化されたインフラ、コモディティインフラ、as-a-serviceのいずれでもデプロイメント可能です。
-Teradata Vantage の詳細については、 ドキュメント を参照してください。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Data Catalog 管理者ロールを持つ Google Service Account
-アカウント用にhttps://cloud.google.com/resource-manager/docs/creating-managing-projects[作成されたCloud Consoleプロジェクト] (例、partner-integration-lab)
-課金が有効になっている
-Pip がインストールされている
-Data Catalog API を有効にする
-Teradata Data Catalog コネクタをインストールする
-実行する
-Teradata VantageのメタデータをData Catalogで探索する
-Google にログインし、ナビゲーションメニューから APIs & Services を選択し、 _Library_をクリックします。トップメニューバーでプロジェクトが選択されていることを確認します。
-
検索ボックスに Data Catalog を入力し、 Google Cloud Data Catalog API をクリックし、 ENABLE -をクリックします
-
Teradata Data Catalog コネクタは GitHub で公開されています。このコネクタは Python で記述されています。
-以下のコマンドを実行し、gcloudを認証して、Googleのユーザー認証でCloud Platformにアクセスできるようにします。
-
gcloud auth loginGoogleのログインページが開くので、Googleアカウントを選択し、次のページで Allow をクリックします。
-次に、デフォルトプロジェクトの設定がまだの場合は設定します。
-gcloud config set project <project id>Teradata Data Catalog コネクタは、分離されたPython環境にインストールすることをお勧めします。これを行うには、まず virtualenv をインストールします。
-管理者としてPowerShellで実行:
-pip install virtualenv
-virtualenv --python python3.6 <your-env>
-<your-env>\Scripts\activatepip install virtualenv
-virtualenv --python python3.6 <your-env>
-source <your-env>/bin/activatepip install virtualenv
-virtualenv --python python3.6 <your-env>
-source <your-env>/bin/activateexport GOOGLE_APPLICATION_CREDENTIALS=<google_credentials_file>
-export TERADATA2DC_DATACATALOG_PROJECT_ID=<google_cloud_project_id>
-export TERADATA2DC_DATACATALOG_LOCATION_ID=<google_cloud_location_id>
-export TERADATA2DC_TERADATA_SERVER=<teradata_server>
-export TERADATA2DC_TERADATA_USERNAME=<teradata_username>
-export TERADATA2DC_TERADATA_PASSWORD=<teradata_password>`<google_credential_file>` には、サービスアカウントのキー（jsonファイル）を指定します。-
`google-datacatalog-teradata-connector` コマンドを実行して、Vantage データベースへのエ ントリポイントを確立します。-
google-datacatalog-teradata-connector \
- --datacatalog-project-id=$TERADATA2DC_DATACATALOG_PROJECT_ID \
- --datacatalog-location-id=$TERADATA2DC_DATACATALOG_LOCATION_ID \
- --teradata-host=$TERADATA2DC_TERADATA_SERVER \
- --teradata-user=$TERADATA2DC_TERADATA_USERNAME \
- --teradata-pass=$TERADATA2DC_TERADATA_PASSWORDgoogle-datacatalog-teradata-connectorコマンドの出力例です。
-INFO:root: -==============Starting CLI=============== -INFO:root:This SQL connector does not implement the user defined datacatalog-entry-resource-url-prefix -INFO:root:This SQL connector uses the default entry resoure URL - -============Start teradata-to-datacatalog=========== - -==============Scrape metadata=============== -INFO:root:Scrapping metadata from connection_args - -1 table containers ready to be ingested... - -==============Prepare metadata=============== - ---> database: Gcpuser -37 tables ready to be ingested... - -==============Ingest metadata=============== - -DEBUG:google.auth._default:Checking /Users/Teradata/Apps/Cloud/GCP/teradata2dc-credentials.json for explicit credentials as part of auth process... -INFO:root:Starting to clean up the catalog... -DEBUG:google.auth.transport.requests:Making request: POST https://oauth2.googleapis.com/token -DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): oauth2.googleapis.com:443 -DEBUG:urllib3.connectionpool:https://oauth2.googleapis.com:443 "POST /token HTTP/1.1" 200 None -INFO:root:0 entries that match the search query exist in Data Catalog! -INFO:root:Looking for entries to be deleted... -INFO:root:0 entries will be deleted. - -Starting to ingest custom metadata... - -DEBUG:google.auth._default:Checking /Users/Teradata/Apps/Cloud/GCP/teradata2dc-credentials.json for explicit credentials as part of auth process... -INFO:root:Starting the ingestion flow... -DEBUG:google.auth.transport.requests:Making request: POST https://oauth2.googleapis.com/token -DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): oauth2.googleapis.com:443 -DEBUG:urllib3.connectionpool:https://oauth2.googleapis.com:443 "POST /token HTTP/1.1" 200 None -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_database_metadata -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata -INFO:root:Tag Template created: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_column_metadata -INFO:root:Entry Group created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata -INFO:root:1/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser -INFO:root: ^ [database] 34.105.107.155/gcpuser -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_database_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser/tags/CWHNiGQeQmPT -INFO:root:2/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories -INFO:root: ^ [table] 34.105.107.155/gcpuser/Categories -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_Categories/tags/Ceij5G9t915o -INFO:root:38/38 -INFO:root:Entry does not exist: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest -INFO:root:Entry created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest -INFO:root: ^ [table] 34.105.107.155/gcpuser/tablesv_instantiated_latest -INFO:root:Starting the upsert tags step -INFO:root:Processing Tag from Template: projects/partner-integration-lab/locations/us-west1/tagTemplates/teradata_table_metadata ... -INFO:root:Tag created: projects/partner-integration-lab/locations/us-west1/entryGroups/teradata/entries/gcpuser_tablesv_instantiated_latest/tags/Ceij5G9t915o -INFO:root: -============End teradata-to-datacatalog============-
Data Catalog コンソールに移動し、 *Projects*の下にあるプロジェクト（例：Partner-integration-lab）をクリックします。右側のパネルにTeradataのテーブルが表示されます。
-
目的のテーブル(CITY_LEVEL_TRANS)をクリックすると、このテーブルに関するメタデータが表示される。
-
データカタログからメタデータをクリーンアップする。これを行うには、 https://github.com/GoogleCloudPlatform/datacatalog-connectors-rdbms/blob/master/google-datacatalog-teradata-connector/tools/cleanup_datacatalog.py をローカルディレクトリにコピーする。
-このファイルがあるディレクトリに移動し、以下のコマンドを実行する。
-python cleanup_datacatalog.py --datacatalog-project-ids=$TERADATA2DC_DATACATALOG_PROJECT_ID| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
- このハウツーは、Amazon SageMakerとTeradata Vantageを統合するのに役立ちます。このガイドで説明するアプローチはこのサービスと統合するための多くの潜在的なアプローチの1つです。
-Amazon SageMakerはフルマネージドな機械学習プラットフォームを提供します。Amazon SageMakerとTeradataには2つのユースケースがあります。
-データはTeradata Vantage上に存在しAmazon SageMakerはモデル定義とその後のスコアリングの両方に使用されます。このユースケースではTeradataはAmazon S3環境にデータを提供し、Amazon SageMakerがモデル開発のためにトレーニングおよびテストデータセットを利用できるようにします。TeradataはさらにAmazon S3を通じてAmazon SageMakerによるその後のスコアリングのためにデータを利用できるようにします。このモデルではTeradataはデータリポジトリのみとなります。
-データはTeradata Vantage上に存在しAmazon SageMakerはモデル定義に使用され、Teradataはその後のスコアリングに使用されます。このユースケースでは、TeradataはAmazon S3環境にデータを提供しAmazon SageMakerはモデル開発のためにトレーニングおよびテストデータセットを消費できるようにします。Teradataは、Amazon SageMakerのモデルをTeradataのテーブルにインポートしTeradata Vantageでスコアリングを行う必要があります。このモデルではTeradataはデータリポジトリでありスコアリングエンジンでもあります。
-このドキュメントでは、最初のユースケースについて説明します。
-Amazon SageMakerはAmazon S3バケットからトレーニングデータとテストデータを消費します。この記事ではTeradataの分析データセットをAmazon S3バケットにロードする方法について説明します。その後、データはAmazon SageMakerで利用可能になり機械学習モデルを構築してトレーニングし本番環境にデプロイすることができます。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Amazon S3バケットにアクセスしAmazon SageMakerサービスを使用するためのIAM権限。
-学習データを保存するためのAmazon S3バケット。
-Amazon SageMakerはAmazon S3バケットからデータをトレーニングします。以下はVantageからAmazon S3バケットにトレーニングデータをロードする手順です。
-Amazon SageMakerコンソールに移動しNotebookインスタンスを作成します。Notebookインスタンスを作成する方法については、 Amazon SageMaker 開発者ガイド を参照してください。
-
-Notebookのインスタンスを開きます。
-
-New → conda_python3 をクリックして新規ファイルを起動します。
-Teradata Pythonライブラリをインストールします。
-!pip install teradataml新しいセルに追加のライブラリをインポートします。
-import teradataml as tdml
-from teradataml import create_context, get_context, remove_context
-from teradataml.dataframe.dataframe import DataFrame
-import pandas as pd
-import boto3, os新しいセルで、Teradata Vantageに接続します。<hostname>、 <database user name>、 <database password> はVantageの環境にあわせて置き換えてください。
create_context(host = '<hostname>', username = '<database user name>', password = '<database password>')TeradataML DataFrame APIを使用して学習用データセットが存在するテーブルからデータを取得します。
-train_data = tdml.DataFrame('table_with_training_data')
-trainDF = train_data.to_pandas()ローカルファイルにデータを書き込みます。
-trainFileName = 'train.csv'
-trainDF.to_csv(trainFileName, header=None, index=False)Amazon S3にファイルをアップロードします。
-bucket = 'sagedemo'
-prefix = 'sagemaker/train'
-
-trainFile = open(trainFileName, 'rb')
-boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, localFile)).upload_fileobj(trainFile)左メニューの Training の下にある Training jobs を選択し、 Create training job をクリックします。
-トレーニングジョブの作成 ウィンドウで、ジョブ名 (例: xgboost-bank ) を入力しIAMロールの 新しいロールを作成 します。Amazon S3 バケットに Any S3バケット 、 ロールの作成 に
を選択します。image::cloud-guides/sagemaker-with-teradata-vantage/create.iam.role.png[IAMロールの作成,width=50%]
-Create training job ウィンドウに戻りアルゴリズムとして XGBoost を使用します。
-インスタンスタイプはデフォルトの ml.m4.xlarge、インスタンスあたりの追加ストレージボリュームは30GBを使用します。これは短いトレーニングジョブで10分以上はかからないはずです。
-以下のハイパーパラメータを入力しそれ以外はデフォルトのままにしてください。
-num_round=100 -silent=0 -eta=0.2 -gamma=4 -max_depth=5 -min_child_weight=6 -subsample=0.8 -objective='binary:logistic'-
Input data configuration には学習データを保存したAmazon S3バケットを入力します。Input modeは File です。Content typeは csv です。S3 location はファイルのアップロード先です。
-Output data configuration には出力データを保存するパスを入力します。
-他はデフォルトのまま「トレーニングジョブの作成」をクリックします。トレーニングジョブの設定方法の詳細は 、「Amazon SageMaker 開発者ガイド」に記載されています。
-トレーニングジョブが作成されるとAmazon SageMakerはMLインスタンスを起動してモデルをトレーニングし、結果のモデル成果物やその他の出力を`Output data configuration`デフォルトでは`path/<training job name>/output`）に格納します。
-モデルを学習させた後、永続的なエンドポイントを使用してモデルをデプロイします。
-左パネルの [ Inference の下にある Models を選択し、 Create model を選択します。モデル名 (例: xgboost-bank) を入力し前のステップで作成したIAMロールを選択します。
コンテナ定義1 では 433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest を Location of inference code image として使用します。Location of model artifacts には学習ジョブの出力パスを指定します。
-他はデフォルトのまま モデルを作成 します。
作成したモデルを選択し、 Create endpoint configuration をクリックします。
-名前（例： xgboost-bank)を記入しその他はdefaultを使用します。モデル名とトレーニングジョブは自動的に入力されるはずです。 Create endpoint configuration をクリックします。
左パネルから Inference → Models を選択し、再度モデルを選択し、今度は`Create endpoint` をクリックします。
-名前 (例: xgboost-bank)を入力し、既存のエンドポイント構成を使用する:
-を選択します。image::sagemaker-with-teradata-vantage/attach.endpoint.configuration.png[エンドポイント構成を添付する]
前回の手順で作成したエンドポイント構成を選択し エンドポイント構成の選択 をクリックします。
-他のすべてをデフォルトのままにして エンドポイントを作成 をクリックします。
これでモデルがエンドポイントにデプロイされクライアントアプリケーションから利用できるようになります。
-このハウツーでは、Vantageから学習データを抽出し、それを使ってAmazon SageMakerでモデルを学習させる方法を紹介しました。このソリューションでは、Jupyter Notebookを使用して Vantage からデータを抽出し、S3 バケットに書き込みました。SageMaker トレーニング ジョブは、S3 バケットからデータを読み取り、モデルを生成します。このモデルをサービスエンドポイントとして AWS にデプロイしました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Azure Machine Learning (ML) Studioは、データに対する予測分析ソリューションの構築、テスト、およびデプロイに使用できる、ドラッグ＆ドロップ可能なコラボレーションツールです。ML Studioは、Azure Blob Storageからデータを取得することができます。このスタートガイドでは、ML Studio に組み込まれた Jupter Notebook 機能を使用して Teradata Vantage データセットを Blob Storage にコピーする方法を説明します。このデータは、ML Studio で機械学習モデルを構築、学習し、本番環境にデプロイするために使用することができます。
-
Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Azureサブスクリプションまたは 無料アカウント -の作成* Azure ML Studio ワークスペース
-(オプション) AdventureWorks DW 2016データベース のダウンロード( 「モデルの学習」 セクションなど)
-「vTargetMail」 テーブルを SQL Server から Teradata Vantageに復元およびコピーします。
-現在利用可能な格納場所にストレージ アカウントがあり、このスタート ガイドの Web service plan に DEVTEST Standard を選択していない限り、ML Studio ワークスペースの作成中に、新規のストレージ アカウントを作成する必要がある場合があります。 Azure ポータル にログオンし、ストレージ アカウントを開き、 コンテナ がまだ存在しない場合は作成します。
-
ストレージアカウント名 と キー をメモ帳にコピーし、Python3 NotebookでAzure Blob Storageアカウントにアクセスするために使用します。
-
最後に、Configuration プロパティを開き、'Secure transfer required' を Disabled に設定して、ML Studioインポートデータモジュールがブロブストレージアカウントにアクセスできるようにする。
-
ML Studioにデータを取り込むために、まずはTeradata VantageからAzure Blob Storageにデータをロードする必要があります。ML Jupyter Notebookを作成し、Teradataに接続するためのPythonパッケージをインストールし、Azure Blob Storageにデータを保存することにします。
-https://portal.azure.com/[Azure ポータル] にログオンし、 *ML Studioワークスペース* に移動して、 https://studio.azureml.net/[Machine Learning Studio を起動] し 、 *サインイン*します。-
以下の画面が表示されます。 Notebooks をクリックして、正しいリージョン/ワークスペースにいることを確認し、Notebook の New
-をクリックします。
Python3 を選択し、Notebook インスタンスに 名前を付け ます。
-
Jupyter Notebook インスタンスに、 Teradata Vantage Python package for Advanced Analytics をインストールします。
-pip install teradataml| - - | --Microsoft Azure ML StudioとTeradata Vantage Pythonパッケージの間の検証は行われていません。 - | -
Microsoft Azure Storage Blob Client Library for Python をインストールします。
-!pip install azure-storage-blob以下のライブラリをインポートしてください。
-import teradataml as tdml
-from teradataml import create_context, get_context, remove_context
-from teradataml.dataframe.dataframe import DataFrame
-import pandas as pd
-from azure.storage.blob import (BlockBlobService)以下のコマンドを使用して Teradata に接続します。
-create_context(host = '<hostname>', username = '<database user name>', password = '<password>')Teradata Python DataFrameモジュールを使用してデータを取得します。
-train_data = DataFrame.from_table("<table_name>")Teradata DataFrameをPanda DataFrameに変換します。
-trainDF = train_data.to_pandas()データをCSVに変換します。
-trainDF = trainDF.to_csv(head=True,index=False)Azue Blob Storage アカウント名、キー、コンテナ名の変数を割り当てます。
-accountName="<account_name>"
-accountKey="<account_key>"
-containerName="mldata"Azure Blob Storageにファイルをアップロードします。
-blobService = BlockBlobService(account_name=accountName, account_key=accountKey)
-blobService.create_blob_from_text(containerNAme, 'vTargetMail.csv', trainDF)Azure ポータル にログオンし、BLOB ストレージ アカウントを開いて、アップロードされたファイルを表示します。
-
既存の Azure Machine Learning を使用したデータの分析 の記事を使って、Azure Blob Storageのデータに基づいて予測型機械学習モデルを構築します。顧客が自転車を購入する可能性があるかどうかを予測することで、自転車店であるアドベンチャーワークスのためのターゲットマーケティングキャンペーンを構築する予定です。
-データは、上のセクションでコピーした vTargetMail.csv という Azure Blob Storage ファイルにあります。
1.. Azure Machine Learning Studio にサインインし、 Experiments をクリックします。 -2.. 画面左下の +NEW をクリックし、 Blank Experiment を選択します。 -3.. 実験の名前として「Targeted Marketing」を入力します。 -4.. Data Input and output の下にある Import data モジュールをモジュール ペインからキャンバスにドラッグします。 -5.. [プロパティ] ペインで Azure Blob Storage の詳細 (アカウント名、キー、コンテナ名) を指定します。
-experimentキャンバスの下にある Run をクリックして、実験を実行します。
-
実験が正常に終了したら、Import Data モジュールの下部にある出力ポートをクリックし、 Visualize を選択してインポートしたデータを確認します。
-
データをクリーンアップするには、モデルに関連しないいくつかの列を削除する。次を実行します。
-Data Transformation < Manipulation の下にある*Select Columns in Dataset*モジュールをキャンバスにドラッグします。このモジュールを*Import Data*モジュールに接続します。
-プロパティペインの*Launch column selector*をクリックして、ドロップする列を指定します。
-
-3.*CustomerAlternateKey*と*GeographyKey*の2 つのカラムを除外します。
80%は機械学習モデルの学習用、20%はモデルのテスト用としてデータを80対20に分割します。この2値分類問題には、「Two-Class」アルゴリズムを使用します。
-SplitData モジュールをキャンバスにドラッグし、「Select Columns in DataSet」で接続します。
-プロパティペインで「Fraction of rows in the first output dataset」に「0.8」を入力します。
-
Two-Class Boosted Decision Tree モジュールを検索し、キャンバスにドラッグします。
-Train Model モジュールを検索してキャンバスにドラッグし、Two-Class Boosted Decision Tree (MLアルゴリズム)モジュールと Split Data (アルゴリズムをトレーニングするためのデータ)モジュールに接続して入力を指定する。
-
次に、[プロパティ]ペインで Launch column selector をクリックします。予測するカラムとして BikeBuyer カラムを選択します。
-
次に、このモデルがテストデータでどのように動作するかをテストします。選択したアルゴリズムと異なるアルゴリズムを比較し、どちらがより良いパフォーマンスを示すかを確認します。
-Score Model モジュールをキャンバスにドラッグし、 Train Model と Split Data モジュールに接続します。
-
Two-Class Bayes Point Machine を検索し、実験キャンバスにドラッグします。このアルゴリズムが、Two-Class Boosted Decision Treeと比較して、どのようなパフォーマンスを示すかを比較します。
-Train Model 」と「Score Model」モジュールをコピーして、キャンバスに貼り付けます。
-Evaluate Model モジュールを検索して、キャンバスにドラッグし、2つのアルゴリズムを比較します。
-実行 実験します。
-
Evaluate Model モジュールの下部にある出力ポートをクリックし、Visualize をクリックします。
-
提供される指標は、ROC曲線、精度-再現性ダイアグラム、リフトカーブです。これらの指標を見ると、最初のモデルが2番目のモデルよりも良い性能を発揮していることがわかります。最初のモデルが何を予測したかを見るには、スコア モデルの出力ポートをクリックし、可視化をクリックします。
-
テストデータセットに2つの列が追加されているのがわかります。 -1. スコアリングされた確率：顧客がバイクの購入者である可能性。 -2. スコアされたラベル：モデルによって行われた分類 - 自転車の購入者（1）またはそうでない（0）。このラベリングのための確率の閾値は50％に設定されており、調整することが可能です。
-BikeBuyer列（実際）とScored Labels列（予測）を比較すると、モデルがどの程度うまく機能したかが分かります。次のステップとして、このモデルを使用して新規顧客の予測を行い、このモデルをWebサービスとして公開したり、SQL Data Warehouseに結果を書き戻したりすることが可能です。
-予測型機械学習モデルの構築の詳細については、 Introduction to Machine Learning on Azureを参照してください。
-大規模なデータセットのコピーには、Teradata Parallel Transporterのロード/アンロード オペレーターとAzure Blob Storageの間のインターフェイスである Teradata Access Module for Azure の利用を検討してください。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このチュートリアルでは、Teradata Vantage で dbt (Data Build Tool) を使用して 、Airbyte (オープンソースの抽出ロード ツール) を介して外部データ ロードを変換する方法を説明します。
-このチュートリアルは 、元の dbt Jaffle Shop tutorial に基づいていますが、 dbt seed コマンドを使用する代わりに、Airbyte を使用して Jaffle Shop データセットが Google Sheets から Teradata Vantage にロードされるという小さな変更が加えられています。airbyte を通じてロードされたデータは、以下の図に示すように JSON カラムに含まれています。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
サンプルデータ: サンプルデータ Jaffle Shop Dataset は、 Google スプレッドシートにあります。
-参照 dbt プロジェクト リポジトリ: Jaffle Project with Airbyte.
-Python 3.7、3.8、3.9、3.10、または3.11がインストールされている。
-Airbyte tutorial の手順に従います。Airbyte チュートリアルで参照されるデフォルトのデータセットではなく、Jaffle Shop spreadsheet からデータをロードするようにしてください。また、Teradata宛先の Default Schema を airbyte_jaffle_shop に設定する。
| - - | -
-
-
-AirbyteでTeradata宛先を設定すると、 |
-
チュートリアル リポジトリのクローンを作成し、ディレクトリをプロジェクト ディレクトリに変更します。
-+
-git clone https://github.com/Teradata/airbyte-dbt-jaffle
-cd airbyte-dbt-jaffledbt とその依存関係を管理するための新しい Python 環境を作成します。環境を有効化します。
-python3 -m venv env
-source env/bin/activate| - - | -
-
-
-対応するバッチ ファイル `/myenv/Scripts/activate`を実行すると、Windows で仮想環境を有効化できます。 - |
-
`dbt-teradata`モジュールとその依存関係をインストールします。dbtのコアモジュールも依存関係のあるモジュールとして含まれているので、別にインストールする必要はありません。
-pip install dbt-teradatadbtプロジェクトを初期化します。
-dbt initdbt プロジェクト ウィザードでは、プロジェクト名と、プロジェクトで使用するデータベース管理システムの入力を求められます。このデモでは、プロジェクト名を dbt_airbyte_demo と定義します。dbt-teradataコネクタを使用しているため、使用可能なデータベース管理システムはTeradataのみです。
-
-$HOME/.dbt ディレクトリにある profiles.yml ファイルを設定します。profiles.yml ファイルが存在しない場合は、新しいファイルを作成できます。
Teradataインスタンスの HOST、Username、Password に合わせて、server、username、password をそれぞれ調整します。
この構成では、schema はサンプルデータを含むデータベースを表し、この場合は、Airbyte airbyte_jaffle_shop で定義したデフォルト スキーマです。
dbt_airbyte_demo:
- target: dev
- outputs:
- dev:
- type: teradata
- server: <host>
- schema: airbyte_jaffle_shop
- username: <user>
- password: <password>
- tmode: ANSIprofiles.yml ファイルの準備ができたら、設定を検証できます。dbt プロジェクト フォルダに移動し、以下のコマンドを実行します。
dbt debugデバッグ コマンドがエラーを返した場合は、 profiles.yml のコンテンツに問題がある可能性があります。設定が正しければ、次のメッセージが表示されます。 All checks passed!
-jaffle_shop は、オンラインで注文を受ける架空のレストランです。このビジネスのデータは、以下のエンティティリレーション図に従う customers、 orders 、および payments のテーブルで構成されています。
-ソース システムのデータは正規化されています。同じデータに基づいた、分析ツールにより適したディメンションモデルを以下に示します。
-
-| - - | -
-
-
-以下で詳しく説明する変換を含む完全な dbt プロジェクトは Airbyte用いたJaffle プロジェクト にあります。 - |
-
参照 dbt プロジェクトは 2 つの型の変換を実行します。
-まず、Airbyte 経由で Google スプレッドシートからロードされた生データ (JSON 形式) をステージング ビューに変換します。この段階でデータは正規化されます。
-次に、正規化されたビューを、分析に使用できるディメンションモデルに変換します。
-以下の図は、dbt を使用した Teradata Vantage の変換手順を示しています。
-
-すべての dbt プロジェクトと同様に、フォルダ models には、プロジェクトまたは個々のモデル レベルでの対応する構成に従って、プロジェクトがテーブルまたはビューとしてマテリアライズドするデータ モデルが含まれています。
モデルは、データ ウェアハウス/レイクの編成における目的に応じて、さまざまなフォルダに編成できます。一般的なフォルダ レイアウトには、 staging のフォルダ、 core のフォルダ、および marts のフォルダが含まれます。この構造は、dbt の動作に影響を与えることなく簡素化できます。
オリジナルの dbt Jaffle Shop チュートリア プロジェクトのデータは、dbt の seed コマンドを使用して ./data フォルダにある csv ファイルからロードされます。 seed コマンドはテーブルからデータをロードするためによく使用されますが、このコマンドはデータ ローディングを実行するように設計されていません。
このデモでは、データ ローディング用に設計されたツール Airbyte を使用してデータウェアハウス/レイクにデータを読み込む、より一般的なセットアップを想定しています。 -ただし、Airbyte を通じてロードされたデータは生の JSON 文字列として表されます。これらの生データから、正規化されたステージング ビューを作成しています。このタスクは、以下のステージング モデルを通じて実行します。
-stg_customers モデルは、_airbyte_raw_customers テーブルから customers の正規化されたステージングビューを作成します。
stg_orders モデルは、_airbyte_raw_orders テーブルから orders の正規化されたステージングビューを作成します。
stg_payments モデルは、_airbyte_raw_payments テーブルから payments の正規化されたステージングビューを作成します。
| - - | -
-
-
-JSON 文字列を抽出するメソッドはすべてのステージング モデルで一貫しているため、これらのモデルの 1 つだけを例として使用して、変換の詳細な説明を提供します。 - |
-
以下は、stg_orders.sql モデルを介して生の JSON データをビューに変換する例です。
WITH source AS (
- SELECT * FROM {{ source('airbyte_jaffle_shop', '_airbyte_raw_orders')}}
-),
-
-flattened_json_data AS (
- SELECT
- _airbyte_data.JSONExtractValue('$.id') AS order_id,
- _airbyte_data.JSONExtractValue('$.user_id') AS customer_id,
- _airbyte_data.JSONExtractValue('$.order_date') AS order_date,
- _airbyte_data.JSONExtractValue('$.status') AS status
- FROM source
-)
-
-
-SELECT * FROM flattened_json_dataこのモデルでは、ソースは生のテーブル _airbyte_raw_orders として定義されます。
この生のテーブル列には、メタデータと実際に取り込まれたデータの両方が含まれています。データ列は _airbyte_data と呼ばれます。
この列は Teradata JSON 型です。この型は、JSON オブジェクトからスカラー値を取得するメソッド JSONExtractValue をサポートします。
-このモデルでは、ビューをマテリアライズドするために、対象の各属性を取得し、意味のあるエイリアスを追加しています。
-ディメンションモデルの構築は、以下の 2 段階のプロセスです。
-最初に、stg_orders、stg_customers、stg_payments の正規化されたビューを取得し、非正規化された中間結合テーブル customer_orders、order_payments、customer_payments を構築します。これらのテーブルの定義は ./models/marts/core/intermediate にあります。
2 番目のステップでは、 dim_customers と fct_orders モデルを作成します。これらは、BI ツールに公開するディメンション モデル テーブルを構成します。これらのテーブルの定義は ./models/marts/core にあります。
dbt プロジェクトで定義された変換を実行するには、以下のコマンドを実行します。
-dbt run以下に示すように、各モデルのステータスが取得されます。
-
-ディメンションモデル内のデータが正しいことを確認するために、dbt を使用すると、データに対するテストを定義して実行できます。
-テストは /models/marts/core/schema.yml と /models/staging/schema.yml で定義されています。 各列には、tests キーの下で複数のテストを構成できます。
例えば、 fct_orders.order_id 列には固有な非 NULL 値が含まれることが予想されます。
生成されたテーブルのデータがテスト条件を満たしていることを検証するには、以下のコマンドを実行します。
-dbt testモデル内のデータがすべてのテスト ケースを満たしている場合、このコマンドの結果は以下のようになります。
-
-このモデルは、わずか数個のテーブルで構成されています。より多くのデータ ソースとより複雑なディメンションモデルを使用するシナリオでは、データ系統と各中間モデルの目的をドキュメント化することが非常に重要です。
-dbt を使用してこの型のドキュメントを生成するのは非常に簡単です。
-dbt docs generateこれにより、`./target`ディレクトリにhtmlファイルが生成されます。
-独自のサーバーを起動してドキュメントを参照できます。以下のコマンドはサーバーを起動し、ドキュメントのランディング ページが表示されたブラウザ タブを開きます。
-dbt docs serveこのチュートリアルでは、dbt を使用して、Airbyte 経由でロードされた生の JSON データを Teradata Vantage のディメンションモデルに変換する方法を説明しました。サンプル プロジェクトは、Teradata Vantage にロードされた生の JSON データを取得し、正規化されたビューを作成し、最終的にディメンションデータ マートを生成します。dbt を使用して JSON を正規化ビューに変換し、複数の dbt コマンドを使用してモデルの作成 (dbt run)、データのテスト (dbt test)、モデルドキュメントの生成と提供 (dbt docs generate, dbt docs serve) を行いました。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このチュートリアルでは、Airbyteを使用してソースからTeradata Vantageにデータを移動する方法を紹介し、 Airbyte Open Source オプション と Airbyte Cloud オプション の両方について詳しく説明します。 この具体的な例では、Google スプレッドシートから Teradata Vantage へのレプリケーションを取り上げます。
-ソース: Google スプレッドシート
-宛先: Teradata Vantage
-
-Teradata Vantageインスタンスへのアクセス。これは、Airbyte 接続の宛先として定義されます。Airbyteの設定には、データベースの Host、Username、Password が必要です。
| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
個人または組織のアカウントで Google Cloud Platform API が有効になっている。OAuth またはサービス アカウント キー認証システムを介して Google アカウントを認証する必要があります。この例では、サービス アカウント キー認証システムを使用します。
-ソース システムからのデータ。この場合は、Google スプレッドシートのサンプルスプレッドシート を使用する。サンプルデータは、従業員型別の給与の内訳です。
-Airbyte Cloud でアカウントを作成し、Airbyte Configuration セクションの手順に進みます。
-Airbyte Open Source をローカルで実行するには、Docker Compose をインストールします。Docker Compose には Docker Desktop が付属しています。詳細については 、docker ドキュメント を参照してください。
-Airbyte Open Source リポジトリのクローンを作成し、airbyte ディレクトリに移動します。
-
-git clone --depth 1 https://github.com/airbytehq/airbyte.git
-cd airbyteシェルスクリプト`run-ab-platform`を実行する前に、Docker Desktopが実行されていることを確認します。
-シェルスクリプト run-ab-platform を次のように実行しますを実行します。
./run-ab-platform.sh| - - | -
-
-
-上記のコマンドは、Windowsの |
-
リポジトリに含まれる env ファイルにあるデフォルトの信頼証明を入力して、Web アプリ http://localhost:8000/ にログインします。
BASIC_AUTH_USERNAME=airbyte
-BASIC_AUTH_PASSWORD=password初めてログインするとき、Airbyte は電子メール アドレスを入力し、製品の改善に関する設定を指定するように求めます。設定を入力し、「Get started.」をクリックします。
-
-Airbyte Open Sourceが起動すると、接続ダッシュボードが表示されます。Airbyte Open Sourceを初めて起動した場合は、接続は表示されません。
-「Create your first connection」をクリックするか、右上隅をクリックして、Airbyte の接続ダッシュボードで新しい接続ワークフローを開始できます。
-
-Airbyte はソースを尋ねます。既存のソースから選択することも (すでに設定している場合)、新しいソースを設定することもできます。この場合は Google スプレッドシート を選択します。
認証には、JSON形式のサービスアカウントキーを使用する サービスアカウントキー認証 を使用している。デフォルトの OAuth から サービスアカウントキー認証 に切り替えます。. サービス アカウント キー認証で Google アカウントを認証するには、 JSON 形式の Google Cloud サービス アカウント キー を入力してください。
サービス アカウントにプロジェクト閲覧者アクセス権があることを確認してください。スプレッドシートがリンクを使用して誰にでも表示できる場合は、それ以上の操作は必要ありません。そうでない場合は、 サービス アカウントにスプレッドシートへのアクセスを認証してください。
-ソーススプレッドシートへのリンクを スプレッドシートのリンク として追加します。
-| - - | -
-
-
-詳細については、 Airbyte オープン ソースのソース コネクタとして Google スプレッドシートを設定する - を参照してください。 - |
-
[Set up source]をクリックし、設定が正しければ、次のメッセージが表示されます。 All connection tests passed!
Teradata Vantage を使用して新しい接続を作成する場合は、「Set up the destination」セクションで宛先型として Teradata Vantage を選択します。
Host、User、および Password を追加する。これらは、Clearscape Analytics Environmentで使用される Host、Username、Password とそれぞれ同じです。
特定のコンテキストに適したデフォルトのスキーマ名を指定します。ここでは、gsheet_airbyte_td を提供しました。
| - - | -
-
-
-
-
-`Default Schema` を指定しない場合は、 "Connector failed while creating schema"というエラーが表示されます。 `Default Schema` に適切な名前を指定していることを確認してください。- |
-
-「Set up destination」をクリックします。構成が正しい場合は、メッセージが表示されます。 All connection tests passed!
名前空間は、ソースまたは宛先内のストリーム (テーブル) のグループです。リレーショナル データベース システムのスキーマは、名前空間の一例です。ソースでは、名前空間はデータがレプリケート先にレプリケートされる格納場所です。宛先では、名前空間はレプリケートされたデータが宛先内に保存される格納場所です。 -詳細については 、Airbyte 名前空間 -を参照してください。
-
-この例では、宛先はデータベースであるため、名前空間は、宛先を設定したときに定義したデフォルトのスキーマ`gsheet_airbyte_td`です。ストリーム名は、ソース内のスプレッドシートの名前をミラーリングするテーブルであり、この場合は`sample_employee_payrate`です。単一のスプレッドシート コネクタを使用しているため、1 つのストリーム (アクティブなスプレッドシート) のみがサポートされます。
-他のタイプのソースと宛先では、レイアウトが異なる場合があります。この例では、ソースとしてのGoogle スプレッドシートは名前空間をサポートしていない。 -この例では、宛先の名前空間として`<destination schema>`を使用しました。これは、宛先設定で宣言した`Default Schema`に基づいてAirbyteによって割り当てられたデフォルトの名前空間です。データベース`gsheet_airbyte_td`が、Teradata Vantageインスタンスに作成されます。
-Airbyte は、Status タブの [Sync History] セクションで同期の試行を追跡します。
-次に、 ClearScape Analytics Experience に移動しで Jupyter Notebookを実行します。ClearScape Analytics Experience のNotebookは Teradata SQL クエリーを実行するように構成されており、データベース gsheet_airbyte_td、ストリーム (テーブル)、および完全なデータが存在するかどうかを検証します。
-
-
-%connect localSELECT DatabaseName, TableName, CreateTimeStamp, LastAlterTimeStamp
-FROM DBC.TablesV
-WHERE DatabaseName = 'gsheet_airbyte_td'
-ORDER BY TableName;DATABASE gsheet_airbyte_td;SELECT * FROM _airbyte_raw_sample_employee_payrate;この接続では正規化と変換がサポートされておらず、 生のテーブル しかないため、宛先のストリーム (テーブル) 名には \_airbyte_raw という接頭辞が付いています。各ストリーム (テーブル) には 3 つの列が含まれます。
_airbyte_ab_id: Airbyte によって処理される各イベントに割り当てられる uuid。Teradata の列型は VARCHAR(256) です。
_airbyte_emitted_at: イベントがデータ ソースからいつ取得されたかを表すタイムスタンプ。Teradata の列型は TIMESTAMP(6) です。
_airbyte_data: イベント データを表す json blob。Teradata の列型は JSON です。
`_airbyte_data`カラムには、ソースのGoogle スプレッドシートと同じ9行が表示され、データはJSON形式で、必要に応じてさらに変換できる。
-接続を無効にすることで、Airbyte での接続を閉じることができます。これにより、データ同期プロセスが停止します。
-
-接続を削除することもできます。
-
-このチュートリアルでは、Google シートなどのソース システムからデータを抽出し、Airbyte ELT ツールを使用してデータを Teradata Vantage インスタンスにロードする方法を説明しました。エンドツーエンドのデータフローと、Airbyte Open Source をローカルで実行し、ソース接続と宛先接続を構成するための完全な構成手順を確認しました。また、レプリケーション頻度に基づいて利用可能なデータ同期構成についても説明しました。Cloudscape Analytics Experience を使用して宛先での結果を検証し、最終的に Airbyte 接続を一時停止および削除するメソッドを確認しました。
-
- このプロジェクトでは、上級ユーザーの観点から dbt と Teradata Vantage の統合を紹介します。 -dbt を使用したデータ エンジニアリングが初めての場合は、導入プロジェクト - から始めることをお勧めします。 -デモで紹介されている高度なユースケースは以下のとおりです。
-増分マテリアライズド
-ユーティリティ マクロ
-Teradata 固有の修飾子を使用したテーブル/ビューの作成の最適化
-これらの概念の適用は、架空の店舗である teddy_retailers のELTプロセスを通じて説明されています。
Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Python 3.7、3.8、3.9、または 3.10 がインストールされていること。
-データベース コマンドを実行するためのデータベース クライアント。 このようなクライアントの構成例は、チュートリアル に示されています。
-チュートリアル リポジトリのクローンを作成し、プロジェクト ディレクトリに移動します。
-git clone https://github.com/Teradata/teddy_retailers_dbt-dev teddy_retailers
-cd teddy_retailersdbt とその依存関係を管理するための新しい Python 環境を作成します。環境の作成に使用しているPythonのバージョンが、上記のサポートされているバージョン内にあることを確認します。
-python -m venv envオペレーティング システムに応じて Python 環境を有効化します。
-source env/bin/activateMac、Linux、または
-env\Scripts\activateWindows
-`dbt-teradata`モジュールをインストールします。dbtのコアモジュールも依存関係のあるモジュールとして含まれているので、別にインストールする必要はありません。
-pip install dbt-teradataプロジェクトの依存関係`dbt-utils`と`teradata-utils`をインストールします。これは以下のコマンドで実行できます。
-dbt depsデモ プロジェクトでは、ソース データがデータ ウェアハウスにすでに読み込まれていることを前提としています。これは、実働環境での dbt の使用方法を模倣しています。 -この目的を達成するために、Google Cload Platform(GCP)で利用可能な公開データセットと、それらのデータセットをモックデータウェアハウスにロードするためのスクリプトを提供します。+
-作業用データベースを作成または選択します。dbt プロファイルは、 teddy_retailers`というデータベースを指します。Teradata Vantage インスタンス内の既存のデータベースを指すように `schema 値を変更することも、データベース クライアントで以下のスクリプトを実行して teddy_retailers データベースを作成することもできます。
CREATE DATABASE teddy_retailers
-AS PERMANENT = 110e6,
- SPOOL = 220e6;初期データセットをロードします。 -初期データセットをデータウェアハウスにロードするために、必要なスクリプトがプロジェクトの`references/inserts/create_data.sql`パスで使用できます。 -これらのスクリプトは、データベース クライアントにコピー アンド ペーストすることで実行できます。特定のケースでこれらのスクリプトを実行するためのガイダンスについては、データベース クライアントのドキュメントを参照してください。
-ここで、dbtを設定してVantageデータベースに接続します。
-以下の内容のファイル $HOME/.dbt/profiles.yml を作成します。Teradata Vantageに一致するように`<host>`、<user> 、<password> を調整します。
-ご使用の環境ですでに dbt を使用したことがある場合は、ホームのディレクトリ dbt/profiles.yml ファイルにプロジェクトのプロファイルを追加するだけで済みます。
-ディレクトリ.dbtがまだシステムに存在しない場合は、それを作成し、dbtプロファイルを管理するためにprofiles.ymlを追加する必要があります。
teddy_retailers:
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- logmech: TD2
- schema: teddy_retailers
- tmode: ANSI
- threads: 1
- timeout_seconds: 300
- priority: interactive
- retries: 1
- target: devプロファイルファイルが用意できたので、設定を検証できます。
-dbt debugデバッグ コマンドがエラーを返した場合は、 profiles.yml の内容に問題がある可能性があります。
前述のように、teddy_retailers は架空の店舗です。
-dbt 主導の変換を通じて、「teddy_retailers」 トランザクション データベースから取り込まれたソース データを、分析に使用できるスター スキーマに変換します。
ソース データは、以下のエンティティリレーションシップ図に従って、customers、orders、products、order_products のテーブルで構成されます。
-# Entities
-
-[customers] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
- *`id ` {bgcolor: "#f9d6cd", color: "#000000", label: "int", border: "1", border-color: "#ffffff"}
- `name ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
- `surname ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
- `email ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-[orders] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-*`id ` {bgcolor: "#f9d6cd", color: "#000000", label: "int", border: "1", border-color: "#ffffff"}
-`customer_id `{bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`order_date `{bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`status ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-order_products] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-`order_id `{bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`product_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`quantity ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-
-2[products] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-*`id ` {bgcolor: "#f9d6cd", color: "#000000", label: "int", border: "1", border-color: "#ffffff"}
-`name `{bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`category `{bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`unit_price `{bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-# Relationships
-
-customers 1--* orders
-orders 1--* order_products
-products 1--* order_products
-dbt を使用して、ソース データ テーブルを利用して、分析ツール用に最適化された以下のディメンションモデルを構築します。
-# Entities
-
-[dim_customers] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-* `customer_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`first_name ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`last_name ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`email ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-[dim_orders] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-* `order_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`order_date ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`order_status ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-dim_products] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-* `product_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`product_name ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`product_category ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`price_dollars ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-[fct_order_details] {bgcolor: "#f37843", color: "#ffffff", border: "0", border-color: "#ffffff"}
-`order_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`product_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`customer_id ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`order_date ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`unit_price ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-`quantity ` {bgcolor: "#fcece8", color: "#868686", label: "int", border: "1", border-color: "#ffffff"}
-`amount ` {bgcolor: "#fcece8", color: "#868686", label: "varchar", border: "1", border-color: "#ffffff"}
-
-# Relationships
-`dim_customers` 1--* `fct_order_details`
-`dim_orders` 1--* `fct_order_details`
-`dim_products` 1--* `fct_order_details`
-プロジェクトの models ディレクトリ内の`schema.yml`ファイルは、モデルのソースを指定します。これらのソースは、SQL スクリプトを使用して GCP からロードしたデータと一致しています。
-ステージングエリアモデルは、各ソースからデータを取り込み、必要に応じて各フィールドの名前を変更するだけです。 -このディレクトリの schema.yml では、主キーの基本的な保全性チェックを定義します。
-この段階では、以下の高度な dbt 概念がモデルに適用されます。
-このディレクトリ内の schema.yml ファイルは、構築している 2 つのモデルのマテリアライズドが増分であることを指定します。
-これらのモデルに対して異なる戦略を採用している。
all_orders model には、削除+挿入方式を使用する。この戦略が実装されるのは、データ更新に含まれる注文のステータスに変更がある可能性があるためです。
all_order_products`モデルでは、デフォルトの追加戦略を採用します。このアプローチが選択されたのは、`order_id と product_id の同じ組み合わせがソースに複数回出現する可能性があるためです。
-これは、同じ製品の新しい数量が特定の注文に追加または削除されたことを示します。
このチュートリアルでは、Teradata Vantage を使用した高度な dbt コンセプトの利用方法を検討しました。 -サンプル プロジェクトでは、ソース データの次元データ マートへの変換を紹介しました。 -プロジェクト全体を通じて、増分マテリアライゼーション、ユーティリティ マクロ、Teradata修飾子など、いくつかの高度な dbt コンセプトを実装しました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Ubuntu22.x
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Python 3.8、3.9、3.10、または 3.11 がインストールされていること。
-AIRFLOW_HOME環境変数を設定します。Airflowにはホームディレクトリが必要で、デフォルトで~/airflowを使用するが、必要に応じて別の場所を設定することもできます。AIRFLOW_HOME環境変数は、Airflowに目的の場所を通知するために使用されます。
-export AIRFLOW_HOME=~/airflowPyPIリポジトリから apache-airflow の安定版バージョン2. 8.1をインストールします。
AIRFLOW_VERSION=2.8.1
-PYTHON_VERSION="$(python --version | cut -d " " -f 2 | cut -d "." -f 1-2)"
-CONSTRAINT_URL="https://raw.githubusercontent.com/apache/airflow/constraints-${AIRFLOW_VERSION}/constraints-${PYTHON_VERSION}.txt"
-pip install "apache-airflow==${AIRFLOW_VERSION}" --constraint "${CONSTRAINT_URL}"Airflow Teradataプロバイダの安定バージョン1.0.0をPyPIリポジトリからインストールします。
-pip install "apache-airflow-providers-teradata==1.0.0"Airflow をスタンドアロンで実行します。
-airflow standaloneAirflow UIにアクセスします。ブラウザで https://localhost:8080 にアクセスし、ターミナルに表示されている管理者アカウントの詳細でログインします。
-UIの[Admin]→[Connections]セクションを開きます。[Create]リンクをクリックして、新しい接続を作成します。
-
-新しい接続ページに入力の詳細を入力します。
-
-接続ID: Teradata接続の一意のID。
-接続タイプ: システムのタイプ。Teradataを選択します。
-データベースサーバーのURL(必須): 接続するTeradataインスタンスのホスト名。
-データベース(オプション): 接続するデータベースの名前を指定します。
-ログイン(必須): 接続するユーザー名を指定します。
-パスワード(必須): 接続するためのパスワードを指定します。
-「Test and Save」をクリックします。
-irflow では、DAG は Python コードとして定義されます。
-DAG_FOLDER - $AIRFLOW_HOME/files/dags ディレクトリの下に、sample.py のような Python ファイルとして DAG を作成します。
-from datetime import datetime
-from airflow import DAG
-from airflow.providers.teradata.operators.teradata import TeradataOperator
-CONN_ID = "Teradata_TestConn"
-with DAG(
- dag_id="example_teradata_operator",
- max_active_runs=1,
- max_active_tasks=3,
- catchup=False,
- start_date=datetime(2023, 1, 1),
-) as dag:
- create = TeradataOperator(
- task_id="table_create",
- conn_id=CONN_ID,
- sql="""
- CREATE TABLE my_users,
- FALLBACK (
- user_id decimal(10,0) NOT NULL GENERATED ALWAYS AS IDENTITY (
- START WITH 1
- INCREMENT BY 1
- MINVALUE 1
- MAXVALUE 2147483647
- NO CYCLE),
- user_name VARCHAR(30)
- ) PRIMARY INDEX (user_id);
- """,
- )Airflowは、PythonソースファイルからDAGをロードし、設定されたDAG_FOLDER-$AIRFLOW_HOME/files/DAGsディレクトリ内で検索されます。
-DAG は次の 2 つの方法のいずれかで実行されます。
-1. 手動または API 経由でトリガーされた場合
-2. DAG の一部として定義されている定義されたスケジュールで、
-example_teradata_operator が手動でトリガーされるように定義されています。スケジュールを定義するには、Crontab スケジュール値をスケジュール引数に渡すことができます。
with DAG(
- dag_id="my_daily_dag",
- schedule="0 0 * * *"
- ) as dag:このチュートリアルでは、Airflow と Airflow Teradata プロバイダーを Teradata Vantage インスタンスで使用する方法を説明しました。提供されているサンプルDAGは、Connection UIで定義されたTeradata Vantageインスタンスに my_users テーブルを作成します。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Native Object Storage (NOS) はCSV、JSON、Parquet形式のデータセットなどのファイルに保存されているデータを照会するためのVantage 機能です。 -これらはAWS S3、Google GCS、Azure BlobやオンプレミスのS3互換のオブジェクト ストレージをサポートしています。 -この機能はVantageにデータを取り込むためのデータパイプラインを構築せずにデータを探索したい場合に役立ちます。このチュートリアルでは逆にVantageからオブジェクト ストレージにParquetファイル形式でデータをエクスポートする方法について説明します。
-Teradata Vantageインスタンスへのアクセス。NOSはVantage ExpressやDeveloperといった無償の製品でも、またDIYでもVantage as a ServiceでもすべてのVantageエディションでバージョン17.10以降で有効になっています。
-| - - | --このチュートリアルは、s3 awsオブジェクト ストレージをベースにしています。チュートリアルを完了するには、書き込み権限を持つあなた自身のs3バケットが必要です。 - | -
| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
WRITE_NOS を使用するとデータベーステーブルまたはクエリーの結果を選択したまたはすべてのカラムを使用してAmazon S3, Azure Blob storage, Azure Data Lake Storage Gen2, Google Cloud Storageなどの外部オブジェクト ストレージに書き込むことができます。この機能ではデータをParquet形式で保存します。
WRITE_NOS 機能については、 NOS ドキュメント に詳細なドキュメントが掲載されていますので参考にしてください。
WRITE_NOS 関数を実行できるデータベースへのアクセス権が必要です。そのようなデータベースがない場合は、以下のSQLでVantageユーザーを作成します。
CREATE USER db AS PERM=10e7, PASSWORD=db;
-
--- Don't forget to give the proper access rights
-GRANT EXECUTE FUNCTION on TD_SYSFNLIB.READ_NOS to db;
-GRANT EXECUTE FUNCTION on TD_SYSFNLIB.WRITE_NOS to db;| - - | --ユーザーとその権限の設定についてもっと詳しく知りたい場合は、 NOS ドキュメント を参照してください。 - | -
まず、Teradata Vantageインスタンスにテーブルを作成します。
-CREATE SET TABLE db.parquet_table ,FALLBACK ,
- NO BEFORE JOURNAL,
- NO AFTER JOURNAL,
- CHECKSUM = DEFAULT,
- DEFAULT MERGEBLOCKRATIO,
- MAP = TD_MAP1
- (
- column1 SMALLINT NOT NULL,
- column2 DATE FORMAT 'YY/MM/DD' NOT NULL,
- column3 DECIMAL(10,2))
-PRIMARY INDEX ( column1 );テーブルにサンプルデータを入力します。
-INSERT INTO db.parquet_table (1,'2022/01/01',1.1);
-INSERT INTO db.parquet_table (2,'2022/01/02',2.2);
-INSERT INTO db.parquet_table (3,'2022/01/03',3.3);テーブルは以下のようになります。
-column1 column2 column3 -------- -------- ------------ - 1 22/01/01 1.10 - 2 22/01/02 2.20 - 3 22/01/03 3.30-
WRITE_NOS を使用してParquetファイルを作成します。<BUCKET_NAME> をs3バケットの名前に置き換えることを忘れないでください。また、<YOUR-ACCESS-KEY-ID> と <YOUR-SECRET-ACCESS-KEY> をアクセス キーとシークレットに置き換えます。
| - - | --オブジェクト ストレージにアクセスするための信頼証明を作成する方法については、クラウド プロバイダのドキュメントを確認してください。例えば、AWS の場合は 、 How do I create an AWS access key? (AWS アクセス キーを作成するにはどうすればよいですか?)」 を確認してください。 - | -
SELECT * FROM WRITE_NOS (
-ON ( SELECT * FROM db.parquet_table)
-USING
-LOCATION('/s3/<BUCKET_NAME>.s3.amazonaws.com/parquet_file_on_NOS.parquet')
-AUTHORIZATION('{"ACCESS_ID":"<YOUR-ACCESS-KEY-ID>",
-"ACCESS_KEY":"<YOUR-SECRET-ACCESS-KEY>"}')
-STOREDAS('PARQUET')
-MAXOBJECTSIZE('16MB')
-COMPRESSION('SNAPPY')
-INCLUDE_ORDERING('TRUE')
-INCLUDE_HASHBY('TRUE')
-) as d;これで、オブジェクト ストレージ バケットにparquetファイルが作成されました。ファイルを簡単にクエリーするには、ステップ 4 に従う必要があります。
-NOSでサポートされる外部テーブルを作成します。<BUCKET_NAME> をs3バケットの名前に置き換えることを忘れないでください。また、 <YOUR-ACCESS-KEY-ID> と <YOUR-SECRET-ACCESS-KEY> をアクセス キーとシークレットに置き換えます。
CREATE MULTISET FOREIGN TABLE db.parquet_table_to_read_file_on_NOS
-, EXTERNAL SECURITY DEFINER TRUSTED CEPH_AUTH,
-MAP = TD_MAP1
-(
- Location VARCHAR(2048) CHARACTER SET UNICODE CASESPECIFIC
- , col1 SMALLINT
- , col2 DATE
- , col3 DECIMAL(10,2)
-
-)
-USING (
- LOCATION ('/s3/<BUCKET_NAME>.s3.amazonaws.com/parquet_file_on_NOS.parquet')
- AUTHORIZATION('{"ACCESS_ID":"<YOUR-ACCESS-KEY-ID>",
- "ACCESS_KEY":"<YOUR-SECRET-ACCESS-KEY>"}')
- STOREDAS ('PARQUET')
-)NO PRIMARY INDEX;これで、NOS 上のparquetファイルをクエリーする準備ができました。以下のクエリーを試してみましょう。
-SELECT col1, col2, col3 FROM db.parquet_table_to_read_file_on_NOS;クエリーから返されるデータは以下のようになります。
-col1 col2 col3 ------- -------- ------------ - 1 22/01/01 1.10 - 2 22/01/02 2.20 - 3 22/01/03 3.30-
このチュートリアルでは、Native Object Storage (NOS) を使用して、Vantage からオブジェクト ストレージ上の parquet ファイルにデータをエクスポートする方法を学習しました。NOS は、CSV、JSON、および Parquet 形式で保存されたデータの読み取りとインポートをサポートしています。NOS は、Vantage からオブジェクト ストレージにデータをエクスポートすることもできます。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このチュートリアルでは、Teradata Vantage で dbt (データ構築ツール) を使用する方法を説明します。これは、オリジナルの dbt Jaffle Shop チュートリアル に基づいています。いくつかのモデルは、Vantage がサポートする SQL Dialectに合わせて調整されています。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Python 3.7、3.8、3.9、3.10、または 3.11 がインストールされていること。
-チュートリアル リポジトリのクローンを作成し、プロジェクト ディレクトリに移動します。
-git clone https://github.com/Teradata/jaffle_shop-dev.git jaffle_shop
-cd jaffle_shopdbt とその依存関係を管理するための新しい Python 環境を作成します。環境を有効化します。
- -dbt-teradata モジュールとその依存関係をインストールします。dbtのコアモジュールも依存関係のあるモジュールとして含まれているので、別にインストールする必要はありません。
pip install dbt-teradataここで、dbtを設定してVantageデータベースに接続します。以下の内容のファイル $HOME/.dbt/profiles.yml を作成します。Teradata インスタンスに一致するように`<host>`、<user> 、<password> を調整します。
| - - | -
- データベースを設定する
-
-
-以下の dbt プロファイルは、 |
-
jaffle_shop:
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- logmech: TD2
- schema: jaffle_shop
- tmode: ANSI
- threads: 1
- timeout_seconds: 300
- priority: interactive
- retries: 1
- target: devプロファイル ファイルが適切に配置されたので、セットアップを検証できます。
-dbt debugデバッグ コマンドがエラーを返した場合は、 `profiles.yml`の内容に問題がある可能性があります。
-jaffle_shop 架空のEコマースストアです。この dbt プロジェクトは、アプリ データベースの生データを、分析可能な顧客データと注文データを含むディメンションモデルに変換します。
アプリからの生データは、顧客、注文、支払いで構成され、以下のエンティティリレーションシップ図が示されます。
-
-dbt は、これらの生データ テーブルを取得して、分析ツールにより適した以下のディメンションモデルを構築します。
-
-実際には、Segment、Stitch、Fivetran、または別の ETL ツールなどのプラットフォームから生データを取得することになります。この例では、dbtの seed 機能を使用して、csvファイルからテーブルを作成します。csvファイルは、./data ディレクトリにあります。各 csv ファイルによって 1 つのテーブルが作成されます。 dbt はファイルを検査し、型推論を行って列に使用するデータ型を決定します。
生データ テーブルを作成しましょう。
-dbt seedこれで、jaffle_shop`データベースに`raw_customers、raw_orders、`raw_payments`の3つのテーブルが表示されるはずです。テーブルには、csvファイルからのデータを入力する必要があります。
生のテーブルができたので、dbt にディメンション モデルを作成するように指示できます。
-dbt runでは、ここで何があったのか? dbtは CREATE TABLE/VIEW FROM SELECT SQLを使用して追加のテーブルを作成した。最初の変換では、dbtは生のテーブルを取得し、customer_orders、order_payments、customer_payments と呼ばれる非正規化結合テーブルを構築しました。これらのテーブルの定義は ./marts/core/intermediate に記載されています。
-2番目のステップでは、dbtは dim_customers と fct_orders のテーブルを作成しました。これらは、BI ツールに公開するディメンション モデル テーブルです。
dbt はデータに複数の変換を適用しました。ディメンションモデル内のデータが正しいことを確認するにはどうすればよいでしょうか? dbt を使用すると、データに対するテストを定義して実行できます。テストは /marts/core/schema.yml で定義されています。このファイルには、すべてのリレーションシップの各列が記述されています。各列には、tests キーの下に複数のテストを構成できます。例えば、 fct_orders.order_id 列には固有な非 NULL 値が含まれることが予想されます。生成されたテーブルのデータがテスト条件を満たしていることを検証するには、以下のコマンドを実行します。
dbt testこのモデルは、わずか数個のテーブルで構成されています。さらに多くのデータ ソースと、より複雑なディメンションモデルがあるシナリオを想像してください。また、生データと Data Vault 2.0 の原則に従ったディメンションモデルの間に中間ゾーンを設けることもできます。入力、変換、出力を何らかの方法でドキュメント化できたら便利ではないでしょうか? dbt を使用すると、構成ファイルからドキュメントを生成できます。
-dbt docs generateこれにより、./target ディレクトリにhtmlファイルが生成されます。
独自のサーバーを起動してドキュメントを参照できます。以下のコマンドはサーバーを起動し、ドキュメントのランディング ページが表示されたブラウザ タブを開きます。
-dbt docs serveこのチュートリアルでは、Teradata Vantage で dbt を使用する方法を説明しました。サンプルプロジェクトでは、生データを受け取り、ディメンションデータマートを作成します。複数の dbt コマンドを使用して、csv ファイルからテーブルにデータを入力し (dbt seed)、モデルを作成し (dbt run)、データをテストし (dbt test)、モデルドキュメントを生成して提供します (dbt docs generate、 dbt docs serve)。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | -
- 廃止のお知らせ
-
-
-このハウツーでは、 |
-
Vantageに大量のデータを移動させるニーズはよくあります。Teradataは、大量のデータをTeradata Vantageに効率的にロードできる Fastload ユーティリティを提供します 。このハウツーでは、Fastload の使用方法を説明します。このシナリオでは30万件以上のレコードをもつ40MB以上のデータを数秒でロードします。
Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Teradata Tools and Utilities (TTU) をダウンロード - サポートされているプラットフォーム: Windows、 MacOS、 Linux (登録が必要です)。
-非営利団体の米国税務申告を扱います。非営利の納税申告は公開データです。アメリカ内国歳入庁は、これらを S3 バケットで公開します。2020 年の提出書類のまとめを見てみましょう: https://s3.amazonaws.com/irs-form-990/index_2020.csv。ブラウザ、wget、または curl を使用して、ファイルをローカルに保存できます。
Vantageでデータベースを作成しましょう。お気に入りの SQL ツールを使用して、以下のクエリーを実行します。
-CREATE DATABASE irs
-AS PERMANENT = 120e6, -- 120MB
- SPOOL = 120e6; -- 120MBこれから Fastload を実行する。Fastload は、大量のデータを Vantage にアップロードする際に非常に効率的なコマンドラインツールです。Fastload は、高速にするためにいくつかの制限が設けられています。空のテーブルのみを設定でき、すでに設定されているテーブルへの挿入はサポートされていません。セカンダリ インデックスを持つテーブルはサポートされません。また、テーブルが MULTISET テーブルであっても、重複レコードは挿入されない。 制限の完全なリストについては、Teradata® `Fastload`リファレンス を参照してください。
Fastload には独自のスクリプト言語があります。この言語を使用すると、任意の SQLコマンドを使用してデータベースを準備し、入力ソースを宣言し、Vantage にデータを挿入する方法を定義できます。このツールは対話型モードとバッチ モードの両方をサポートしています。このセクションでは、対話型モードを使用します。
-対話型モードで Fastload を開始しましょう:
fastloadまず、Vantageデータベースにログインします。Vantage Express をローカルで実行しているので、ホスト名として localhost を使用し、ユーザー名とパスワードとして dbc を使用します。
LOGON localhost/dbc,dbc;ログインできたので、データベースを準備します。 irs データベースに切り替えて、ターゲット テーブル irs_returns とエラー テーブル (エラー テーブルについては後で詳しく説明します) が存在しないことを確認します。
DATABASE irs;
-DROP TABLE irs_returns;
-DROP TABLE irs_returns_err1;
-DROP TABLE irs_returns_err2;次に、csv ファイルのデータ要素を保持できる空のテーブルを作成します。
-CREATE MULTISET TABLE irs_returns (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
-)
-PRIMARY INDEX ( return_id );ターゲット テーブルが準備できたので、データのロードを開始できます。ERRORFILES ディレクティブはエラー ファイルを定義します。エラーファイルは、実際には Fastload が作成するテーブルです。 最初のテーブルには、データ変換とその他の問題に関する情報が含まれています。2 番目のテーブルは、主キー違反などのデータの固有性の問題を追跡します。
BEGIN LOADING irs_returns
- ERRORFILES irs_returns_err1, irs_returns_err2;Fastload に 10k 行ごとにチェックポイントを保存するように指示します。ジョブを再開する必要がある場合に便利です。最後のチェックポイントから再開できるようになります。
CHECKPOINT 10000;また、CSV ファイルの最初の行をレコード 2 からスキップするように Fastload に指示する必要があります。これは、最初の行には列ヘッダーが含まれているためです。
RECORD 2;Fastload また、それがカンマ区切りファイルであることも認識する必要があります。
SET RECORD VARTEXT ",";DEFINE ブロックは、どの列を期待するかを指定します。
DEFINE in_return_id (VARCHAR(19)),
- in_filing_type (VARCHAR(5)),
- in_ein (VARCHAR(19)),
- in_tax_period (VARCHAR(19)),
- in_sub_date (VARCHAR(22)),
- in_taxpayer_name (VARCHAR(100)),
- in_return_type (VARCHAR(5)),
- in_dln (VARCHAR(19)),
- in_object_id (VARCHAR(19)),DEFINE`ブロックには、データが含まれるファイルを指す `FILE 属性もあります。 FILE = /tmp/index_2020.csv; を index_2020.csv ファイルの格納場所に置き換えます。
FILE = /tmp/index_2020.csv;最後に、データベースにデータを入れる INSERT 文を定義し、LOADING ブロックを閉じます。
INSERT INTO irs_returns (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );
-END LOADING;ジョブが終了したら、データベースからログオフしてクリーンアップする。
-LOGOFF;スクリプト全体は以下のようになります。
-LOGON localhost/dbc,dbc;
-
-DATABASE irs;
-DROP TABLE irs_returns;
-DROP TABLE irs_returns_err1;
-DROP TABLE irs_returns_err2;
-
-CREATE MULTISET TABLE irs_returns (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
-)
-PRIMARY INDEX ( return_id );
-
-BEGIN LOADING irs_returns
- ERRORFILES irs_returns_err1, irs_returns_err2;
- CHECKPOINT 10000;
- RECORD 2;
- SET RECORD VARTEXT ",";
-
- DEFINE in_return_id (VARCHAR(19)),
- in_filing_type (VARCHAR(5)),
- in_ein (VARCHAR(19)),
- in_tax_period (VARCHAR(19)),
- in_sub_date (VARCHAR(22)),
- in_taxpayer_name (VARCHAR(100)),
- in_return_type (VARCHAR(5)),
- in_dln (VARCHAR(19)),
- in_object_id (VARCHAR(19)),
- FILE = /tmp/index_2020.csv;
-
- INSERT INTO irs_returns (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );
-END LOADING;
-
-LOGOFF;この例をバッチモードで実行するには、すべての命令を1つのファイルに保存して実行するだけです。
-fastload < file_with_instruction.fastloadFastload vs. NOSこの例では、ファイルは S3 バケット内にあります。つまり、Native Object Storage (NOS) を使用してデータを取り込むことができます。
--- create an S3-backed foreign table
-CREATE FOREIGN TABLE irs_returns_nos
- USING ( LOCATION('/s3/s3.amazonaws.com/irs-form-990/index_2020.csv') );
-
--- load the data into a native table
-CREATE MULTISET TABLE irs_returns_nos_native
- (RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME)
-AS (
- SELECT RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME FROM irs_returns_nos
-) WITH DATA
-NO PRIMARY INDEX;NOS ソリューションは追加のツールに依存しないため便利です。SQLのみで実装可能です。NOS タスクが AMP に委任され、並行して実行されるため、特に多数の AMP を備えた Vantage デプロイメント環境では良好なパフォーマンスを発揮します。また、オブジェクト ストレージ内のデータを複数のファイルに分割すると、パフォーマンスがさらに向上する可能性があります。
-このハウツーでは、大量のデータを Vantage に取り込む方法を説明しました。Fastload を使用して、数十万のレコードを Vantage に数秒でロードしました。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- この投稿では、わずか数行のコードで、GeoJson 形式の地理データセットを活用し、Teradata Vantage で地理空間分析に使用する方法を示します。
-現在、私たちは公共ソースから参照地理データ (公式地図、名所など) を収集し、それを日常の分析のサポートに使用しています。
-GeoJson データを Teradata Vantage に取得する 2 つのメソッドを学習します。
-これを単一のドキュメントとしてロードし、ネイティブ ClearScape 分析関数を使用して分析に使用できるテーブルに解析します。
-Vantage にロードするときにネイティブ Python で軽く変換して、分析対応のデータセットを生成します。
-1 つ目のメソッドは、単一の SQL文を使用して Vantage で半構造化フォーマットを処理する単純な ELT パターンです。2 つ目の方法は、(純粋な) Python での軽量の準備を必要とし、より柔軟な対応が可能になります (例えば、初期の品質チェックの追加や最適化など)。大きなドキュメントの負荷）。
-必要になるもの:
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Python 3 インタープリタ
-SQLクライアント
-ここでは、GeoJson ドキュメントを単一の文字ラージ オブジェクト(CLOB) として Vantage Data Store にロードし、ClearScape Analytics のネイティブ関数に支えられた単一の SQL 文を使用して、このドキュメントを地理空間分析に使用可能な構造に解析します。
-http://geojson.xyz/のウェブサイトは、GeoJson形式のオープンな地理データの素晴らしいソースです。1,000 を超える世界の重要な都市のリストを提供する「Populated Places」データセットを読み込みます。
-お気に入りの Python 3 インタープリタ を開き、以下のパッケージがインストールされていることを確認してください。
-wget
-teradatasql
-getpass
-都市データセットをダウンロードして読み取ります。
-import wget
-world_cities=wget.download('https://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_50m_populated_places.geojson')
-with open(world_cities) as geo_json:
- jmap = jmap = geo_json.read()必要に応じて、Vantage のホスト名、ユーザー名を使用してこのコードを変更し、logmech パラメータで高度なログイン メカニズム (LDAP、Kerberos など) を指定します。 -すべての接続パラメータは、teradatasql PyPi ページにドキュメント化されています。 https://pypi.org/project/teradatasql/
-以下のコードは、単に Vantage 接続を作成し、カーソルを開いてテーブルを作成し、それをファイルとともにロードします。
-import teradatasql
-import getpass
-tdhost='<Your-Vantage-System-HostName-Here>'
-tdUser='<Your-Vantage-User-Name-Here>'
-
-# Create a connection to Teradata Vantage
-con = teradatasql.connect(None, host=tdhost, user=tdUser, password=getpass.getpass())
-
-# Create a table named geojson_src and load the JSON map into it as a single CLOB
-with con.cursor () as cur:
- cur.execute ("create table geojson_src (geojson_nm VARCHAR(32), geojson_clob CLOB CHARACTER SET UNICODE);")
- r=cur.execute ("insert into geojson_src (?, ?)", ['cities',jmap])ここで、お気に入りの SQL クライアント を開き、Vantageシステムに接続します。
-ClearScape 分析の JSON 関数を使用して GeoJson ドキュメントを解析し、各フィーチャ (この例では都市を表す各フィーチャ) に最も関連するプロパティとジオメトリ自体 (都市の座標) を抽出します。 -次に、GeomFromGeoJSON 関数を使用して、ジオメトリをネイティブ Vantage ジオメトリ データ型 (ST_GEOMETRY) としてキャストします。
-ユーザーの利便性を考慮して、この SQL コードをすべてビューにラップします。
-REPLACE VIEW cities_geo AS
-SEL city_name, country_name, region_name, code_country_isoa3, GeomFromGeoJSON(geom, 4326) city_coord
-FROM JSON_Table
-(ON (
- SEL
- geojson_nm id
- ,cast(geojson_clob as JSON) jsonCol
- FROM geojson_src where geojson_nm='cities'
-)
-USING rowexpr('$.features[*]')
- colexpr('[ {"jsonpath" : "$.geometry",
- "type" : "VARCHAR(32000)"},
- {"jsonpath" : "$.properties.NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.SOV0NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.ADM1NAME",
- "type" : "VARCHAR(50)"},
- {"jsonpath" : "$.properties.SOV_A3",
- "type" : "VARCHAR(50)"}]')
-) AS JT(id, geom, city_name, country_name, region_name, code_country_isoa3);これで、準備された地理データをテーブルとして表示できるようになり、分析を強化する準備が整いました。
-SEL TOP 5 * FROM cities_geo;結果:
-| city_name | -country_name | -region_name | -code_country_isoa3 | -city_coord | -
|---|---|---|---|---|
Potenza |
-Italy |
-Basilicata |
-ITA |
-POINT (15.798996495640267 40.642002130098206) |
-
Mariehamn |
-Finland |
-Finström |
-ALD |
-POINT (19.949004471869102 60.096996184895431) |
-
Ramallah |
-Indeterminate |
-- | PSE |
-POINT (35.206209378189556 31.902944751424059) |
-
Poitier |
-French Republic |
-Poitou-Charentes |
-FRA |
-POINT (0.333276528534554 46.583292255736581) |
-
Clermont-Ferrand |
-French Republic |
-Auvergne |
-FRA |
-POINT (3.080008095928406 45.779982115759424) |
-
2 つの都市間の距離を計算します。
-SEL b.city_coord.ST_SphericalDistance(l.city_coord)
-FROM
-(SEL city_coord FROM cities_geo WHERE city_name='Bordeaux') b
-CROSS JOIN (SEL city_coord FROM cities_geo WHERE city_name='Lvov') l結果:
-city_coord.ST_SPHERICALDISTANCE(city_coord) |
-
1.9265006861079421e+06 |
-
前の例では、完全なドキュメントをラージ オブジェクトとして Teradata Vantage にロードし、組み込みの分析関数を使用してそれを解析して使用可能なデータセットにする方法を示しました。
-元のドキュメントは分析に直接使用できないため、JSONドキュメントは現在Vantageで16MBに制限されており、CLOBとして保存されているドキュメント内のデータ品質やフォーマットの問題を修正するのは不便な場合があるため、使用するたびにこのドキュメントを解析する必要があります。
-この例では、Python json パッケージを使用して JSON ドキュメントを解析し、分析に直接かつ効率的に使用できるテーブルとしてロードします。
-Python json およびリスト操作関数と Python 用の Teradata SQL ドライバを使用すると、このプロセスが非常にシンプルかつ効率的になります。
-この例では、https://datahub.io で利用可能な世界の国の境界を使用します。
-さっそく見ていきましょう。
-お気に入りの Python 3 インタープリタ を開いて、以下のパッケージがインストールされていることを確認してください:
-wget
-teradatasql
-getpass
-import wget
-countries_geojson=wget.download('https://datahub.io/core/geo-countries/r/countries.geojson')import json -with open(countries_geojson) as geo_json: - countries_json = json.load(geo_json)
-インタラクティブな Python ターミナルを使用している場合、この JSON をメモリにロードすると、ドキュメントを探索してその構造を理解できるようになります。例えば
-print(countries_json.keys())
-print(countries_json['type'])
-print(countries_json['features'][0]['properties'].keys())
-print(countries_json['features'][0]['geometry']['coordinates'])ここにあるのは、(前述のように) GeoFeature のコレクションです。
-そのために、このデータを Vantage テーブルで簡単にモデル化します。
-各機能を生としてロードします。
-すぐに分析できるように興味深いプロパティを抽出します (この例では、国名と ISO コード)。
-ジオメトリ自体を抽出し、別の列としてロードします。
-teradatasql カーソルを使用して行のセットをロードするには、各行を値の配列 (またはタプル) として表し、完全なデータセットをすべての行配列の配列として表す必要があります。 -これはリスト理解としてはかなり簡単です。
-例:
-[(f['properties']['ADMIN'], f['properties']['ISO_A3'], f['geometry']) for f in countries_json['features'][:1]]注記: ここでは取り上げていませんが、より豊富なデータセットの場合は、元の特徴ペイロード全体を別の列 (これは JSON ドキュメントです) としてロードすることを検討してください。これにより、ファイル全体を再ロードすることなく、元のレコードに戻って、最初の分析では見逃したものの関連性が高まった新しいプロパティを SQL で直接抽出できるようになります。
-必要に応じて、Vantage のホスト名、ユーザー名を使用してこのコードを変更し、logmech パラメータを使用して高度なログイン メカニズム (LDAP、Kerberos など) を指定します。 -すべての接続パラメータは、teradatasql PyPi ページに文書化されています。 https://pypi.org/project/teradatasql/
-以下のコードは、単に Vantage 接続を作成し、カーソルを開いてテーブルを作成し、それをリストとともにロードします。
-import teradatasql
-import getpass
-tdhost='<Your-Vantage-System-HostName-Here>'
-tdUser='<Your-Vantage-User-Name-Here>'
-
-# Create a connection to Teradata Vantage
-con = teradatasql.connect(None, host=tdhost, user=tdUser, password=tdPassword)
-
-# Create a table and load our country names, codes, and geometries.
-with con.cursor () as cur:
- cur.execute ("create table stg_countries_map (country_nm VARCHAR(32), ISO_A3_cd VARCHAR(32), boundaries_geo CLOB CHARACTER SET UNICODE);")
- r=cur.execute ("insert into stg_countries_map (?, ?, ?)", [(f['properties']['ADMIN'], f['properties']['ISO_A3'], str(f['geometry'])) for f in countries_json['features']])以下のコードは、Python インタープリターからテーブルの作成を実行します。また、お好みの SQL クライアントで以下に定義された sql ステートメントを実行することもできます。このテーブルを更新する必要がないように、単純にこのロジックを SQL ビューとして定義することもできます。
-ClearScape 分析の GeomFromGeoJSON 関数を使用して、ジオメトリをネイティブ Vantage ジオメトリ データ型 (ST_GEOMETRY) としてキャストします。
-# Now create our final reference table, casting the geometry CLOB as a ST_GEOMETRY object
-sql='''
-CREATE TABLE ref_countries_map AS
-(
-SEL
-ISO_A3_cd
-,country_nm
-,GeomFromGeoJSON(boundaries_geo, 4326) boundaries_geo
-FROM stg_countries_map
-) WITH DATA
-'''
-
-WITH con.cursor () AS cur:
- cur.execute (sql)これで、お気に入りの SQL クライアント と Teradata の優れた 地理空間データ型と分析関数 を使用してテーブルにクエリーを実行できるようになります。
-例えば、このチュートリアル中にロードした 2 つのデータセットを使用して、どの国が存在するかをチェックインします。
-SEL cty.city_name, cty.city_coord, ctry.country_nm
-FROM cities_geo cty
-LEFT JOIN ref_countries_map ctry
- ON ctry.boundaries_geo.ST_Contains(cty.city_coord)=1
-WHERE cty.city_name LIKE 'a%'city_name |
-city_coord |
-country_nm |
-
Acapulco |
-POINT (-99.915979046410712 16.849990864016206) |
-Mexico -Aosta |
-
POINT (7.315002595706176 45.737001067072299) |
-Italy -Ancona |
-POINT (13.499940550397127 43.600373554552903) |
-
Italy -Albany |
-POINT (117.891604776075155 -35.016946595501224) |
-Australia |
-
上記のコードはいずれも、ターゲット テーブルの状態の管理、ロックの管理、エラー コードの制御などを行うための制御プロシージャやチェックを実装していないことに注記してください。これは、地理空間参照データを取得して使用するために利用できる機能をデモンストレーションすることを目的としています。
-Python、dbt、またはお気に入りの ELT およびオーケストレーション ツールセットでパイプラインを定義して運用可能な製品を作成している場合は、https://pypi.org/project/teradatasqlalchemy/[SQLAlchemy ORM] の使用を検討してください。
-これで、オープンな地理データセットを取得し、それを使用して Teradata Vantage で分析を強化する方法を理解できるようになりました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- ClearScape AnalyticsTM は、https://www.teradata.com/platform/vantagecloud[Teradata VantageCloud] の強力な分析エンジンです。市場で最も強力でオープンで接続された AI/ML 機能により、企業全体に画期的なパフォーマンス、価値、成長をもたらします。https://www.teradata.com/experience[ClearScape Analytics Experience] を通じて、ClearScape AnalyticsTM および Teradata Vantage を非運用設定で体験できます。
-このハウツーでは、ClearScapeアナリティクスエクスペリエンスで環境構築のステップを実行し、デモにアクセスする。
-
-ClearScape Analytics Experience に移動し、無料アカウントを作成します。
-
-ClearScape Analytics アカウントにサインインして環境を作成し、デモにアクセスします。
-
-サインインしたら次をクリックします。 CREATE ENVIRONMENT
-
-次の情報を提供する必要がある。
-| 変数 | -値 | -
|---|---|
environment name |
-環境の名前(例:「demo」) |
-
database password |
-選択したパスワード。このパスワードは、 |
-
Region |
-ドロップダウンからリージョンを選択します。 |
-
| - - | --データベースのパスワードを書き留めます。データベースに接続するために必要になる。 - | -
-CREATE ボタンをクリックして環境の作成を完了すると、環境の詳細が表示されます。
-
-ClearScape Analytics Experience 環境には、分析を使用してさまざまな業界のビジネス上の問題を解決する方法を紹介するさまざまなデモが含まれています。
-+
-デモにアクセスするには、RUN DEMOS USING JUPYTER ボタンをクリックします。ブラウザの新しいタブで Jupyter 環境が開きます。
-+
-| - - | --デモの詳細はすべて、デモ インデックス ページでご覧いただけます。 - | -
-
- Teradata VantageCloud Lakeは、Teradataの次世代のクラウドネイティブな分析およびデータプラットフォームです。これは、オブジェクト ストレージ中心の設計を使用して、独立した柔軟なワークロードを実行する機能とともに、レイクハウス デプロイメント パターンを提供します。
-これにより、組織はデータのロックを解除し、分析をアクティブ化し、価値を加速できるようになります。お客様は、ワークロード要件に最適なように特別に構成されたコンピューティング クラスタ リソースを使用して、分析環境を最適化できます。
-VantageCloud Lake は、クラウド ソリューションに期待されるすべてのメリットに加え、業界をリードする Analytics Database、ClearScape Analytics、QueryGrid データ ファブリックなどの Teradata の差別化されたテクノロジー スタックを提供します。
-| - - | --VantageCloud Lake のサインオン リンクと資格情報を取得するには、https://www.teradata.com/about-us/contact[お問い合わせフォーム]に記入して Teradata チームに連絡してください。 - | -
Teradataが提供するURL(*ourcompany.innovationlabs.teradata.com*など)に移動し、サインオンします。
-既存の顧客は、組織管理者のユーザー名 (電子メール アドレス) とパスワードを使用してサインオンできます。
-新しい顧客は、組織管理者のユーザー名 (ウェルカム レターから: 電子メール アドレス) と作成したパスワードを使用してサインオンできます。
-| - - | --ここ をクリックして、組織の管理者パスワードをリセットします。 - | -
-サインオンすると、VantageCloud Lakeのようこそページに移動します。
-
-ようこそページにはナビゲーション メニューがあり、環境を完全に制御できるだけでなく、さまざまな必要なツールも提供されます。
-
-Vantage-VantageCloud Lakeポータルのホームページ
-環境 - 環境を作成し、作成されたすべての環境を確認する
-組織 - 組織の構成の表示、組織管理者の管理、アカウントの構成とステータスを表示する
-消費量 - 組織がコンピューティングリソースとストレージリソースをどのように消費しているかを監視する
-コスト試算 - 環境と組織全体のコストと消費量を計算する。
-クエリー - 環境のクエリーを検査して、その効率を理解する。
-エディタ - エディタでクエリーを作成して実行する。
-データ コピー - VantageCloud Lake コンソールからデータ コピー (Data Mover とも呼ばれる) ジョブをプロビジョニング、構成、実行しする。
-プライマリ クラスタ環境を作成するには、ナビゲーション メニューの [環境] をクリックします。新しく開いたビューで、ページの右上にある「作成」ボタンをクリックします。
-
-環境の構成フィールドに入力します。
-| アイテム | -説明 | -
|---|---|
環境名 |
-新しい環境のコンテキスト名 |
-
リージョン |
-利用可能なリージョン リストは、販売プロセス中に事前に決定されます。 |
-
パッケージ |
-次の2つのサービスパッケージから選択できます。 |
-
-| - - | --推定消費量 (右側)は、環境作成のためのガイダンスを提供します。詳細については、https://docs.teradata.com/r/Teradata-VantageCloud-Lake/Using-VantageCloud-Lake-Console-to-Manage-VantageCloud-Lake/Using-the-Consumption-Estimates[推定消費量の使用] を参照してください。 - | -
プライマリ クラスタの構成フィールドに入力します。
-| アイテム | -説明 | -||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
インスタンス サイズ |
-
-
-ユースケースに適したインスタンス サイズを選択します。
|
-||||||||||||||||||||||||||||||||
インスタンス数 |
-
- 2から64 |
-||||||||||||||||||||||||||||||||
インスタンス ストレージ |
-
- インスタンスあたり1～72 TB - |
-
-すぐに開始するには、デフォルトを使用 を選択するか、追加のオプション設定を定義することができる。
-
-| アイテム | -説明 | -
|---|---|
インスタンスあたりのAMP数 |
-ワークロード管理 |
-
AWS:ストレージの暗号化 |
-顧客データの暗号化を設定します。https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html[キー ID とキー ARN を検索する] を参照してください |
-
-すべての情報を確認し、CREATE ENVIRONMENT ボタンをクリックします。
-
-デプロイには数分かかります。完了すると、作成された環境がカード ビューとして 環境 セクションに表示されます (環境の名前は Quickstart_demo)。
-
-作成された環境には、コンソールからのみアクセスできます。これを変更するには、作成された環境変数をクリックして、設定 タブに移動します。
-
-設定 で インターネット接続 チェックボックスをオンにし、環境へのアクセスに使用する IP アドレスを CIDR 形式で指定します (たとえば、192.168.2.0/24 は 192.168.2.0 から 192.168.2.255 の範囲内のすべての IP アドレスを指定します)
-| - - | --インターネット接続の設定の詳細については、https://docs.teradata.com/r/Teradata-VantageCloud-Lake/Getting-Started-First-Sign-On-by-Organization-Admin/Step-2-Setting-the-Environment-Connection-Type/Setting-Up-an-Internet-Connection[こちら] をご覧ください。 - | -
-ページの右上にある 保存 ボタンをクリックして、変更を確認します。
-+
-環境 のセクションに戻って、環境庁カードを確認してください。現在、パブリック インターネット にアクセスできます。
-
-
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Teradata データベースをローカル マシン上で実行してアクセスする方法を示します。手順を完了すると、コンピュータ上で動作する Teradata Vantage Express データベースが作成されます。
-| - - | --バージョン 17.20 以降、Vantage Express には以下の分析パッケージが含まれています。 Vantage Analytics Library、 Bring Your Own Model (BYOM)、 API Integration with AWS SageMaker。 - | -
Macコンピュータ。IntelとM1/2チップの両方がサポートされている。
-| - - | --Vantage Expressはx86アーキテクチャで動作する。VMをM1/2チップ上で実行する場合、UTMはx86をエミュレートする必要がある。これは仮想化よりも大幅に低速です。M1/M2 上の Vantage Express がニーズに対して遅すぎると判断した場合は、クラウド ( AWS、 Azure、 Google Cloud )で Vantage Express を実行することを検討してください。 - | -
少なくとも 1 つのコアと 4GB RAM を仮想マシン専用にできる 30GB のディスク領域と十分な CPU および RAM。
-ソフトウェアをインストールして実行できる管理者権限。
-| - - | --ローカルマシンに管理者権限がありませんか?AWS、Azure、Google CloudでVantage Expressを実行する方法を見てください。 - | -
Vantage Express の最新バージョン。これまでに Teradata Downloads Web サイトを使用したことがない場合は、登録する必要があります。
-UTM の最新バージョン。
-Vantage Expressをダウンロードしたディレクトリに移動し、ダウンロードしたファイルを解凍します。
-UTM を起動し、 + の記号をクリックして、 Virtualize (Intel Mac の場合) または Emulate (M1 Mac の場合) を選択します。
Operating System 画面で `Other`を選択します。
Other 画面で `Skip ISO Boot`を選択します。
`Hardware`画面で、少なくとも4 GBのメモリと少なくとも1つのCPUコアを割り当てます。10GB RAM と 2 つの CPU を推奨します。
-
-Storage 画面で Next をクリックして、デフォルトを受け入れます。
Shared Direct 画面で Next をクリックします。
Summary 画面で Open VM Settings にチェックを入れ、 `Save`をクリックします。
セットアップウィザードを実行します。以下のタブを調整するだけで済みます。
-QEMU - UEFI Boot オプションを無効にします。
Network - ホスト コンピューター上で ssh (22) ポートと Vantage (1025) ポートを公開します。
-
-ドライブをマップします。
-デフォルトの IDE Drive を削除します。
ダウンロードした VM zip ファイルからディスク ファイルをインポートして、3 つの Vantage Express ドライブをマッピングします。-disk1、-disk2、-disk3 の正しい順序でマッピングするようにしてください。最初のディスクはブート可能であり、データベース自体が含まれています。Disks 2と3はいわゆる pdisks と呼ばれ、データを含んでいます。ファイルをインポートすると、UTMは自動的に vmdk から qcow2 形式に変換する。各ディスクが IDE インターフェースを使用して構成されていることを確認してください。
-3 つのドライブすべてのマッピングが完了すると、構成は次のようになります。
-
-構成を保存し、VM を起動します。
-ENTERを押して、強調表示されている LINUX ブートパーティションを選択します。
-以下の画面で、もう一度 ENTER を押して、デフォルトの SUSE Linux カーネルを選択します。
-
-起動シーケンスが完了すると、以下のスクリーンショットに示すような端末ログイン プロンプトが表示されます。ターミナルには何も入力しないでください。システムが GUI を開始するまで待ちます。
-
-しばらくすると、以下のプロンプトが表示されます。上記のコマンド ログイン プロンプトの後に何も入力しなかったと仮定します。下の画面で`okay`ボタンを押す。
-
-VM が起動すると、そのデスクトップ環境が表示されます。username/password の入力を求められたら、両方に root と入力します。
-データベースは VM とともに自動起動するように構成されています。データベースが開始されたことを確認するには、仮想デスクトップに移動し、Gnome Terminal を起動します。
-ターミナルで pdestate コマンドを実行すると、Vantage がすでに起動しているかどうかが通知されます。
| - - | --Gnome Terminalに貼り付けるには、SHIFT+CTRL+V を押します。 - | -
-watch pdestate -a以下のメッセージが表示されるまで待ちます。
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate返すメッセージの例を参照してください。
-PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
データベースが起動したので、仮想デスクトップに戻って`Teradata Studio Express`を起動します。
-
-初めて開始すると、ツアーが提供されます。ツアーを終了すると、新しい接続を追加するためのウィザードウィンドウが表示さます。 `Teradata`を選択します。
-
-以下の画面で、ユーザー名とパスワードに dbc を使用してローカルホスト上のデータベースに接続します。
-次に、VM でいくつかのクエリーを実行します。ホストと VM 間のコピー/ペーストの問題を回避するために、VM でこのクイック スタートを開きます。仮想デスクトップに移動し、Firefox を起動して、このクイック スタートを指定します。
-Teradata Studio Expressで、クエリー開発`パースペクティブに移動すします(トップメニューに移動して、`Window → クエリー開発 を選択)。
データベース接続 → `新規Teradata`をダブルクリックして、以前に作成した接続プロファイルを使用して接続します。
`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/ペーストし、Run Query (
) ボタンまたはF5キーを押します。
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
このガイドでは、動作する Teradata 環境を迅速に作成する方法について説明しました。VMware 上で実行されている VM で Teradata Vantage Express を使用しました。同じ VM で Teradata Studio Express を実行してクエリーを発行しました。すべてのソフトウェアをローカルにインストールしたため、クラウド リソースの料金を支払う必要はありませんでした。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Teradata データベースをローカル マシン上で実行してアクセスする方法を示します。手順を完了すると、コンピュータ上で動作する Teradata Vantage Express データベースが作成されます。
-| - - | --バージョン 17.20 以降、Vantage Express には以下の分析パッケージが含まれています。 Vantage Analytics Library、 Bring Your Own Model (BYOM)、 API Integration with AWS SageMaker。 - | -
以下のオペレーティング システムのいずれかを使用するコンピューター: Windows 10、Linux、または Intel ベースの MacOS。
-| - - | --M1/M2 MacOSシステムについては、Run Vantage Express on UTM を参照してください。 - | -
少なくとも 1 つのコアと 6GB RAM を仮想マシン専用にできる 30GB のディスク領域と十分な CPU および RAM。
-ソフトウェアをインストールして実行できる管理者権限。
-Vantage Express VirtualBox Open Virtual Appliance (OVA)の最新バージョン 。
-| - - | --これまでに Teradata Downloads Web サイトを使用したことがない場合は、まず登録する必要があります。 - | -
VirtualBox、バージョン6.1。
-| - - | -
-brew およびその他のパッケージ マネージャを使用して VirtualBox をインストールすることもできます。
- |
-
インストーラーを実行し、デフォルト値を受け入れて、VirtualBox をインストールします。
-| - - | --VirtualBox には、高い権限を必要とする機能が含まれています。VirtualBox を初めて起動するときは、この昇格されたアクセスを確認するように求められます。VirtualBox カーネル プラグインをアクティブにするためにマシンを再起動する必要がある場合もあります。 - | -
VirtualBoxを起動します。
-`File → Import Appliance…`メニューに移動します。
-File フィールドで、ダウンロードしたOVAファイルを選択します。
以下の画面で、デフォルトを受け入れて `Import`をクリックします。
-メインの VirtualBox パネルに戻り、VM Vantage 17.20 をダブルクリックして Vantage Express アプライアンスを起動します。
-ENTERを押して、強調表示されている LINUX ブートパーティションを選択します。
-以下の画面で、もう一度 ENTER を押して、デフォルトの SUSE Linux カーネルを選択します。
-
-起動シーケンスが完了すると、以下のスクリーンショットに示すような端末ログイン プロンプトが表示されます。ターミナルには何も入力しないでください。システムが GUI を開始するまで待ちます。
-
-しばらくすると、以下のプロンプトが表示されます。上記のコマンド ログイン プロンプトの後に何も入力しなかったと仮定します。下の画面で`okay`ボタンを押す。
-
-VM が起動すると、そのデスクトップ環境が表示されます。username/password の入力を求められたら、両方に root と入力します。
-データベースは VM とともに自動起動するように構成されています。データベースが開始されたことを確認するには、仮想デスクトップに移動し、Gnome Terminal を起動します。
-ターミナルで pdestate コマンドを実行すると、Vantage がすでに起動しているかどうかが通知されます。
| - - | --Gnome Terminalに貼り付けるには、SHIFT+CTRL+V を押します。 - | -
watch pdestate -a以下のメッセージが表示されるまで待ちます。
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate返すメッセージの例を参照してください。
-PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
データベースが起動したので、仮想デスクトップに戻って`Teradata Studio Express`を起動します。
-
-初めて開始すると、ツアーが提供されます。ツアーを終了すると、新しい接続を追加するためのウィザードウィンドウが表示さます。 `Teradata`を選択します。
-
-以下の画面で、ユーザー名とパスワードに dbc を使用してローカルホスト上のデータベースに接続します。
-Teradata Studio Expressで、クエリー開発`パースペクティブに移動すします(トップメニューに移動して、`Window → クエリー開発 を選択)。
データベース接続 → `新規Teradata`をダブルクリックして、以前に作成した接続プロファイルを使用して接続します。
`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/ペーストし、Run Query () ボタンまたはF5キーを押します。
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VirtualBox ゲスト拡張機能は、VM 内で実行されるソフトウェアです。これにより、VirtualBox上でのVMの実行が高速化されます。また、VM 画面の解像度とサイズ変更に対する応答性も向上します。双方向のクリップボードを実装し、ホストとゲストの間でドラッグ アンド ドロップを行います。VM 内の VirtualBox ゲスト拡張機能は、VirtualBox インストールのバージョンと一致する必要があります。最適なパフォーマンスを得るには、VirtualBox ゲスト拡張機能を更新する必要がある場合があります。
-VirtualBox ゲスト拡張機能を更新するには:
-Storage セクションの SATA Port 3: [Optical Drive] をクリックして、VirtualBox ゲスト拡張機能DVD を挿入します。
-VMウィンドウに戻り、Gnome ターミナル アプリケーションを起動します。
ターミナルで以下のコマンドを実行します。
-mount /dev/cdrom /media/dvd; /media/dvd/VBoxLinuxAdditions.runこのガイドでは、動作する Teradata 環境を迅速に作成する方法について説明しました。VMware 上で実行されている VM で Teradata Vantage Express を使用しました。同じ VM で Teradata Studio Express を実行してクエリーを発行しました。すべてのソフトウェアをローカルにインストールしたため、クラウド リソースの料金を支払う必要はありませんでした。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Teradata データベースをローカル マシン上で実行してアクセスする方法を示します。手順を完了すると、コンピュータ上で動作する Teradata Vantage Express データベースが作成されます。
-| - - | --バージョン 17.20 以降、Vantage Express には以下の分析パッケージが含まれています。 Vantage Analytics Library、 Bring Your Own Model (BYOM)、 API Integration with AWS SageMaker。 - | -
次のオペレーティング システムのいずれかを使用するコンピュータ: Windows、Linux、または Intel ベースの MacOS。
-| - - | --M1/M2 MacOSシステムについては、Run Vantage Express on UTM を参照してください。 - | -
少なくとも 1 つのコアと 6GB RAM を仮想マシン専用にできる 30GB のディスク領域と十分な CPU および RAM。
-ソフトウェアをインストールして実行できる管理者権限。
-Vantage Express の最新バージョン。これまでに Teradata Downloads Web サイトを使用したことがない場合は、登録する必要があります。
-| - - | --営利団体では、VMware Workstation Playerを使用するために商用ライセンスが必要です。VMwareライセンスを取得しない場合は、VirtualBox でVantage Expressを実行できます。 - | -
| - - | --VMware は、MacOS 用の VMware Workstation Player を提供していません。Macを使用している場合は、代わりに VMware Fusion をインストールする必要があります。これは有料製品ですが、VMware では 30 日間の無料試用版を提供しています。または、VirtualBox または UTM 上でVantage Expressを実行することもできます。 - | -
Windowsでは、Vantage Expressを解凍するために 7 zip も必要です。
-インストーラを実行し、デフォルト値を受け入れて、VMware Player または VMware Fusion をインストールします。
-Windowsの場合は、7zip をインストールします。
Vantage Expressをダウンロードしたディレクトリに移動し、ダウンロードしたファイルを解凍します。
-.vmx ファイルをダブルクリックします。これにより、VMware Player/FusionでVMイメージが起動されます。
ENTERを押して、強調表示されている LINUX ブートパーティションを選択します。
-以下の画面で、もう一度 ENTER を押して、デフォルトの SUSE Linux カーネルを選択します。
-
-起動シーケンスが完了すると、以下のスクリーンショットに示すような端末ログイン プロンプトが表示されます。ターミナルには何も入力しないでください。システムが GUI を開始するまで待ちます。
-
-しばらくすると、以下のプロンプトが表示されます。上記のコマンド ログイン プロンプトの後に何も入力しなかったと仮定します。下の画面で`okay`ボタンを押す。
-
-VM が起動すると、そのデスクトップ環境が表示されます。username/password の入力を求められたら、両方に root と入力します。
-データベースは VM とともに自動起動するように構成されています。データベースが開始されたことを確認するには、仮想デスクトップに移動し、Gnome Terminal を起動します。
-ターミナルで pdestate コマンドを実行すると、Vantage がすでに起動しているかどうかが通知されます。
| - - | --Gnome Terminalに貼り付けるには、SHIFT+CTRL+V を押します。 - | -
watch pdestate -a以下のメッセージが表示されるまで待ちます。
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate返すメッセージの例を参照してください。
-PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
データベースが起動したので、仮想デスクトップに戻って`Teradata Studio Express`を起動します。
-
-初めて開始すると、ツアーが提供されます。ツアーを終了すると、新しい接続を追加するためのウィザードウィンドウが表示さます。 `Teradata`を選択します。
-
-以下の画面で、ユーザー名とパスワードに dbc を使用してローカルホスト上のデータベースに接続します。
-次に、VM でいくつかのクエリーを実行します。ホストと VM 間のコピー/ペーストの問題を回避するために、VM でこのクイック スタートを開きます。仮想デスクトップに移動し、Firefox を起動して、このクイック スタートを指定します。
-Teradata Studio Expressで、クエリー開発`パースペクティブに移動すします(トップメニューに移動して、`Window → クエリー開発 を選択)。
データベース接続 → `新規Teradata`をダブルクリックして、以前に作成した接続プロファイルを使用して接続します。
`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/ペーストし、Run Query () ボタンまたはF5キーを押します。
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
このガイドでは、動作する Teradata 環境を迅速に作成する方法について説明しました。VMware 上で実行されている VM で Teradata Vantage Express を使用しました。同じ VM で Teradata Studio Express を実行してクエリーを発行しました。すべてのソフトウェアをローカルにインストールしたため、クラウド リソースの料金を支払う必要はありませんでした。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このハウツーでは、Apple Mac M1/M2 マシンへの Teradata Studio および Teradata Studio Express のインストールについて説明します。
-Rosetta バイナリ トランスレータをインストールして有効にする。Apple Mac Rosetta インストールガイド に従います。
-お好みのベンダーから x86 64 ビット ベースの JDK 11 をダウンロードしてインストールします。例えば、x86 64 ビット JDK 11 を Azul -からダウンロードできます。
-Teradata ダウンロード ページから最新の Teradata Studio または Teradata Studio Express リリースをダウンロードします。
-Teradata Studio/Teradata Studio Expressをインストールします。詳細については 、Teradata Studio および Teradata Studio Express インストール ガイド を参照してください。
-Apple は、Apple MAC M1/M2 マシンに ARM ベースのプロセッサをデプロイメントしました。Intel x64 ベースのアプリケーションは、デフォルトでは ARM ベースのプロセッサでは動作しません。現在の Studio macOS ビルドは Intel x64 ベースのアプリケーションであるため、Teradata Studio または Teradata Studio Express もデフォルトでは動作しません。このハウツーでは、Intel x64 ベースの JDK と Teradata Studio または Teradata Studio Express を Apple Mac M1/M2 にインストールする方法を示します。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このハウツーでは、サンプルのJavaアプリケーションであるhttps://github.com/Teradata/jdbc-sample-appを使用して、JDBCを使用してTeradata Vantageに接続する方法を示します。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
JDK
-Maven
-| - - | -
-この手順では、Vantage データベースがポート 1025 の localhost で利用できることを前提としています。ラップトップでVantage Expressを実行している場合は、VMからホストマシンにポートを公開する必要があります。ポートを転送する方法については、仮想化ソフトウェアのドキュメントを参照してください。
- |
-
プロジェクトが設定されます。残っているのは、ドライバをロードし、接続パラメータと認証パラメータを渡し、クエリーを実行することだけです。
-このハウツーでは、JDBC を使用して Teradata Vantage に接続する方法を説明しました。ここでは、Teradata JDBC ドライバを使用して SQL クエリーを Teradata Vantage に送信するビルド ツールとして Maven を使用するサンプル Java アプリケーションについて説明しました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --このハウツーでは、Teradata Extensions を Jupyter Notebooks 環境に追加する方法を示します。Teradata Extensions および分析ツールと統合された Jupyter Notebooks のホストされたバージョンは、https://clearscape.teradata.comで無料で機能テストに利用できます。 - | -
このハウツーでは、Jupyter Notebookから Teradata Vantage に接続する手順を説明します。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Jupyter Notebook から Vantage に接続するには、いくつかの方法があります。
-通常の Python/R カーネル Notebookで Python または R ライブラリを使用する - このオプションは、独自のDockerイメージを生成できない制限された環境にいる場合にうまく機能します。また、Notebook内で SQL と Python/R を混在させる必要がある従来のデータサイエンス シナリオでも役立ちます。Jupyter に精通していて、独自の優先ライブラリと拡張機能のセットがある場合は、このオプションから始めてください。
-2.Teradata Jupyter Docker イメージを使用する - Teradata Jupyter Docker イメージには、Teradata SQL カーネル (詳細は後述)、teradataml および tdplyr ライブラリ、Python および R ドライバーがバンドルされています。また、Teradata 接続の管理、Vantage データベース内のオブジェクトの探索を可能にする Jupyter 拡張機能も含まれています。SQLを頻繁に使用する場合や、視覚的なナビゲータが役立つ場合に便利です。Jupyter を初めて使用する場合、またはライブラリと拡張機能の厳選されたアセンブリを入手したい場合は、このオプションから始めてください。
このオプションでは、通常の Jupyter Lab Notebookを使用します。Teradata Python ドライバをロードし、Python コードから使用する方法を見ていきます。また、SQLのみのセルのサポートを追加する ipython-sql 拡張に機能も検討します。
シンプルな Jupyter Lab Notebookから始めます。ここでは Dockerを使用していますが、Jupyter Hub、Google Cloud AI Platform Notebooks、AWS SageMaker Notebooks、Azure ML Notebooks など、Notebookを起動する任意のメソッドを使用できます。
-docker run --rm -p 8888:8888 -e JUPYTER_ENABLE_LAB=yes \
- -v "${PWD}":/home/jovyan/work jupyter/datascience-notebookDockerログには、アクセスする必要がある URL が表示されます。
-Entered start.sh with args: jupyter lab -Executing the command: jupyter lab -.... -To access the server, open this file in a browser: - file:///home/jovyan/.local/share/jupyter/runtime/jpserver-7-open.html -Or copy and paste one of these URLs: - http://d5c2323ae5db:8888/lab?token=5fb43e674367c6895e8c2404188aa550b5c7bdf96f5b4a3a - or http://127.0.0.1:8888/lab?token=5fb43e674367c6895e8c2404188aa550b5c7bdf96f5b4a3a-
新しいNotebookを開いて、必要なライブラリをインストールするためのセルを作成します。
-| - - | --以下に説明するすべてのセルを含むNotebookを GitHub で公開しました: https://github.com/Teradata/quickstarts/blob/main/modules/ROOT/attachments/vantage-with-python-libraries.ipynb - | -
import sys
-!{sys.executable} -m pip install teradatasqlalchemy次に、Pandas`をインポートし、Teradataに接続するための接続文字列を定義します。ローカル マシン上の Docker でNotebookを実行しており、ローカルの Vantage Express VM に接続したいため、Dockerによって提供される `host.docker.internal のDNS 名を使用してマシンの IP を参照しています。
import pandas as pd
-# Define the db connection string. Pandas uses SQLAlchemy connection strings.
-# For Teradata Vantage, it's teradatasql://username:password@host/database_name .
-# See https://pypi.org/project/teradatasqlalchemy/ for details.
-db_connection_string = "teradatasql://dbc:dbc@host.docker.internal/dbc"これで、Pandas を呼び出して Vantage をクエリーし、結果を Pandas データフレームに移動できるようになりました。
-pd.read_sql("SELECT * FROM dbc.dbcinfo", con = db_connection_string)上記の構文は簡潔ですが、Vantage でデータを探索することだけが必要な場合は、退屈になる可能性があります。ipython-sql とその %%sql マジックを使用して、SQLのみのセルを作成します。まず、必要なライブラリをインポートします。
import sys
-!{sys.executable} -m pip install ipython-sql teradatasqlalchemyipython-sql をロードし、db接続文字列を定義します。
%load_ext sql
-# Define the db connection string. The sql magic uses SQLAlchemy connection strings.
-# For Teradata Vantage, it's teradatasql://username:password@host/database_name .
-# See https://pypi.org/project/teradatasqlalchemy/ for details.
-%sql teradatasql://dbc:dbc@host.docker.internal/dbc%sql と %%sql の魔法が使えるようになりました。テーブル内のデータを調査したいとします。以下のようなセルを作成できます。
%%sql
-SELECT * FROM dbc.dbcinfoデータを Pandas フレームに移動したい場合は、以下のように言えます。
-result = %sql SELECT * FROM dbc.dbcinfo
-result.DataFrame()ipython-sql には、変数置換、matplotlib によるプロット、ローカル CSV ファイルへの結果の書き込みやデータベースへの結果の書き込みなど、他にも多くの機能があります。例については Notebookのデモ を 、完全なリファレンスについては ipython-sql github リポジトリ を参照してください。
Teradata Jupyter Dockerイメージは、 jupyter/datascience-notebook Dockerイメージに基づいて構築されています。Teradata SQL カーネル、Teradata Python および R ライブラリ、Jupyter 拡張機能が追加され、Teradata Vantage との対話時の生産性が向上します。このイメージには、SQL カーネルと Teradata ライブラリの使用方法を示すサンプル Notebookも含まれています。
SQL カーネルと Teradata Jupyter 拡張機能は、SQL インターフェースの使用に多くの時間を費やす人にとって役立ちます。これは、多くの場合、Teradata Studio を使用するよりも便利なNotebook エクスペリエンスと考えてください。Teradata Jupyter Docker イメージは、Teradata Studio を置き換えようとするものではありません。すべての機能が備わっているわけではありません。軽量の Web ベースのインターフェースを必要とし、Notebook UI を楽しむ人向けに設計されています。
-Teradata Jupyter Dockerイメージは、Jupyter をローカルで実行する場合、またはカスタム Jupyter Dockerイメージを実行できる場所がある場合に使用できます。以下の手順は、イメージをローカルで使用する方法を示しています。
-イメージを実行します。
-| - - | -
--e"accept_license=Y を渡すと、Teradata Jupyter Extensions の 使用許諾契約 に同意したことになります。
- |
-
docker volume create notebooks
-docker run -e "accept_license=Y" -p :8888:8888 \
- -v notebooks:/home/jovyan/JupyterLabRoot \
- teradata/jupyterlab-extensionsDockerログには、アクセスする必要がある URL が表示されます。例えば、これは私が持っているものです:
-Starting JupyterLab ... -Docker Build ID = 3.2.0-ec02012022 -Using unencrypted HTTP - -Enter this URL in your browser: http://localhost:8888?token=96a3ab874a03779c400966bf492fe270c2221cdcc74b61ed - -* Or enter this token when prompted by Jupyter: 96a3ab874a03779c400966bf492fe270c2221cdcc74b61ed -* If you used a different port to run your Docker, replace 8888 with your port number-
URL を開き、ファイル エクスプローラを使用してNotebook `jupyterextensions → notebooks → sql → GettingStartedDemo.ipynb`を開きます。
-Teradata SQL カーネルのデモを確認してください。
-
-このクイック スタートでは、Jupyter Notebook から Teradata Vantage に接続するためのさまざまなオプションについて説明しました。複数の Teradata Python および R ライブラリをバンドルする Teradata Jupyter Dockerイメージについて学びました。また、SQL カーネル、データベース オブジェクト エクスプローラ、接続管理も提供します。これらの機能は、SQL インターフェースを長時間使用する場合に役立ちます。より伝統的なデータ サイエンス シナリオについては、スタンドアロンの Teradata Python ドライバと、ipython sql 拡張機能を介した統合を検討しました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 独自のJupyterHubクラスタをお持ちのお客様には、Teradata Jupyterエクステンションを既存のクラスタに統合するための2つのオプションがあります。
-Teradata Jupyter Dockerイメージを使用する。
-既存のDockerイメージをカスタマイズして、Teradata 拡張機能を含める。
-このページでは、2つのオプションの詳細な手順を説明します。この手順は、手順は、お客様のJupyterHubのデプロイが Zero to JupyterHub with Kubernetes をベースにしていることを前提にしています。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Teradata は 、jupyter/datascience-notebook イメージをベースにした、すぐに実行可能なDockerイメージを提供しています。Teradata SQLカーネル、Teradata PythonおよびRライブラリとドライバー、Teradata Jupyter拡張をバンドルし、Teradataデータベースと対話しながら生産性を向上させることができます。また、このイメージには、SQLカーネル、拡張機能、Teradataライブラリの使用方法を示すサンプルノートブックが含まれています。
-このイメージは以下のように使用することができます。
-ローカルのDockerコンテナで個人用Jupyter Notebookサーバを起動する
-JupyterHubを使用してチームのJupyterLabサーバを実行する
-ローカルDockerコンテナで個人用JupyterLabサーバーを起動する手順については、インストール ガイドを参照してください。ここでは、お客様の既存のJupyterHub環境でTeradata Jupyter Dockerイメージを使用する方法を中心に説明します。
-Vantage Modules for Jupyter のページに移動し、Dockerイメージをダウンロードします。tarballで、teradatajupyterlabext_VERSION.tar.gz という形式になっています。
イメージをロードします。
-docker load -i teradatajupyterlabext_VERSION.tar.gzイメージをDockerレジストリにプッシュします。
-docker push| - - | -
-
-
-シンプルにするために、読み込んだ画像の名前を変更することを検討するとよいでしょう。 -
-
-
-
- |
-
Teradata Jupyter Dockerイメージを JupyterHub クラスタで直接使用するには、 JupyterHubドキュメント の説明に従ってオーバーライド ファイルを変更します。 REGISTRY_URL と VERSION を上記の手順で適切な値に置き換えてください。
singleuser:
- image:
- name: REGISTRY_URL/teradatajupyterlabext_VERSION
- tag: latestJupyterHub ドキュメント に記載されているように、クラスタに変更を適用します。
-| - - | --複数のプロファイルを使用することで、ユーザーがJupyterHubにログインする際に使用する画像を選択することができます。複数のプロファイルを設定する詳細な手順と例については、JupyterHub ドキュメント を参照してください。 - | -
Teradata Jupyter Dockerイメージにバンドルされていないパッケージやノートブックが必要な場合、Teradataイメージをベースイメージとして使用し、その上に新しいイメージをビルドすることをお勧めします。
-以下は、Teradataイメージの上にビルドし、追加のパッケージとノートブックを追加するDockerfileの例です。Dockerfileを使用して新しいDockerイメージを構築し、イメージを指定のレジストリにプッシュし、新しいイメージをシングルユーザーイメージとして使用するために上記のようにオーバーライドファイルを変更し、上記のようにクラスタに変更を適用します。 REGISTRY_URL と VERSION は適切な値に置き換えてください。
FROM REGISTRY_URL/teradatajupyterlabext_VERSION:latest
-
-# install additional packages
-RUN pip install --no-cache-dir astropy
-
-# copy notebooks
-COPY notebooks/. /tmp/JupyterLabRoot/DemoNotebooks/Teradata SQLカーネルとエクステンションは、現在使用している既存のイメージに含めることができます。
-Vantage Modules for Jupyter ページから、zip圧縮されたTeradata Jupyter extensionsパッケージバンドルがダウンロードできます。既存の -DockerイメージがLinuxベースである場合は、Linux版のダウンロードを使用します。そうでない場合は、使用しているプラットフォーム用にダウンロードします。.zipファイルには、Teradata SQL Kernel、エクステンション、サンプル -ノートブックが含まれています。
-バンドル ファイルを作業ディレクトリに解凍します。
-以下は、既存のDockerイメージにTeradata Jupyterエクステンションを追加するためのDockerfileの例です。Dockerfileを使用して新しいDockerイメージを構築し、イメージを指定のレジストリにプッシュし、新しいイメージをシングルユーザーイメージとして使用するために上記のようにオーバーライドファイルを変更し、変更をクラスタに適用します。
-FROM REGISTRY_URL/your-existing-image:tag
-ENV NB_USER=jovyan \
- HOME=/home/jovyan \
- EXT_DIR=/opt/teradata/jupyterext/packages
-
-USER root
-
-##############################################################
-# Install kernel and copy supporting files
-##############################################################
-
-# Copy the kernel
-COPY ./teradatakernel /usr/local/bin
-RUN chmod 755 /usr/local/bin/teradatakernel
-
-# Copy directory with kernel.json file into image
-COPY ./teradatasql teradatasql/
-
-##############################################################
-# Switch to user jovyan to copy the notebooks and license files.
-##############################################################
-
-USER $NB_USER
-
-# Copy notebooks
-COPY ./notebooks/ /tmp/JupyterLabRoot/TeradataSampleNotebooks/
-
-# Copy license files
-COPY ./ThirdPartyLicenses /tmp/JupyterLabRoot/ThirdPartyLicenses/
-
-USER root
-
-# Install the kernel file to /opt/conda jupyter lab instance
-RUN jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-##############################################################
-# Install Teradata extensions
-##############################################################
-
-COPY ./teradata_*.tgz $EXT_DIR
-
-WORKDIR $EXT_DIR
-
-RUN jupyter labextension install --no-build teradata_database* && \
- jupyter labextension install --no-build teradata_resultset* && \
- jupyter labextension install --no-build teradata_sqlhighlighter* && \
- jupyter labextension install --no-build teradata_connection_manager* && \
- jupyter labextension install --no-build teradata_preferences* && \
- jupyter lab build --dev-build=False --minimize=False && \
- rm -rf *
-
-WORKDIR $HOME
-
-# Give back ownership of /opt/conda to jovyan
-RUN chown -R jovyan:users /opt/conda
-
-# Jupyter will create .local directory
-RUN rm -rf $HOME/.localTeradata package for PythonとTeradata package for Rはオプションでインストールすることができます。詳細については、以下のページを参照してください。
- -| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 機械学習モデルのアイデアをすぐに検証したい場合があります。モデルの型を念頭に置いています。まだ ML パイプラインを運用する必要はありません。思い描いていたリレーションシップが存在するかどうかをテストしたいだけです。また、実働デプロイメントでも、MLops による継続的な再学習が必要ない場合もあります。このような場合、特徴量エンジニアリングにデータベース分析関数を使用し、さまざまな ML モデルをトレーニングし、モデルをスコア化し、さまざまなモデル評価関数でモデルを評価できます。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
この例では、val データベースのサンプルデータを使用します。accounts、customer、16transactions のテーブルを使用します。この過程でいくつかのテーブルを作成しますが、val データベースにテーブルを作成する際に問題が発生する可能性があるため、独自のデータベース td_analytics_functions_demo を作成しましょう。
CREATE DATABASE td_analytics_functions_demo
-AS PERMANENT = 110e6;| - - | --データベース分析関数を使用するには、データベースに対する CREATE TABLE アクセス権が必要です。 - | -
`val` データベース内の対応するテーブルから、データベース `td_analytics_functions_demo` に `accounts`、`customer` 、および `transactions` テーブルを作成しましょう。-
DATABASE td_analytics_functions_demo;
-
-CREATE TABLE customer AS (
-SELECT * FROM val.customer
-) WITH DATA;
-
-CREATE TABLE accounts AS (
-SELECT * FROM val.accounts
-) WITH DATA;
-
-CREATE TABLE transactions AS (
-SELECT * FROM val.transactions
-) WITH DATA;サンプルテーブルが td_analytics_functions_demo にロードされたので、データを調べてみましょう。これは、銀行の顧客(700行ほど)、口座(1400行ほど)、取引(77,000行ほど)の単純で架空のデータセットです。これらは以下のように相互に関連しています。
-このハウツーの後半では、テーブル内のクレジット カードに関連しないすべての変数に基づいて、銀行顧客のクレジット カードの月平均残高を予測するモデルを構築できるかどうかを検討していきます。
-3つの異なるテーブルにデータがあり、それらを結合してフィーチャを作成します。まず、結合されたテーブルを作成します。
--- Create a consolidated joined_table from customer, accounts and transactions table
-CREATE TABLE td_analytics_functions_demo.joined_table AS (
- SELECT
- T1.cust_id AS cust_id
- ,MIN(T1.income) AS tot_income
- ,MIN(T1.age) AS tot_age
- ,MIN(T1.years_with_bank) AS tot_cust_years
- ,MIN(T1.nbr_children) AS tot_children
- ,MIN(T1.marital_status)AS marital_status
- ,MIN(T1.gender) AS gender
- ,MAX(T1.state_code) AS state_code
- ,AVG(CASE WHEN T2.acct_type = 'CK' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS ck_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'SV' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS sv_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'CC' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS cc_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'CK' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS ck_avg_tran_amt
- ,AVG(CASE WHEN T2.acct_type = 'SV' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS sv_avg_tran_amt
- ,AVG(CASE WHEN T2.acct_type = 'CC' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS cc_avg_tran_amt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 1 THEN T3.tran_id ELSE NULL END) AS q1_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 2 THEN T3.tran_id ELSE NULL END) AS q2_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 3 THEN T3.tran_id ELSE NULL END) AS q3_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 4 THEN T3.tran_id ELSE NULL END) AS q4_trans_cnt
- FROM Customer AS T1
- LEFT OUTER JOIN Accounts AS T2
- ON T1.cust_id = T2.cust_id
- LEFT OUTER JOIN Transactions AS T3
- ON T2.acct_nbr = T3.acct_nbr
-GROUP BY T1.cust_id) WITH DATA UNIQUE PRIMARY INDEX (cust_id);次に、データがどのように見えるかを見てみましょう。データセットには、カテゴリ特徴この場合、従属変数は顧客の平均クレジット カード残高である cc_avg_bal です。
-データを見ると、`cc_avg_bal`を予測するために考慮できる特徴がいくつかあることがわかります。
-このデータセットには、gender、marital status、state code などのカテゴリ機能がある。データベース分析関数 TD_OneHotEncodingFit を 利用して、カテゴリをワンホット数値ベクトルにエンコードします。
CREATE VIEW td_analytics_functions_demo.one_hot_encoding_joined_table_input AS (
- SELECT * FROM TD_OneHotEncodingFit(
- ON td_analytics_functions_demo.joined_table AS InputTable
- USING
- IsInputDense ('true')
- TargetColumn ('gender','marital_status','state_code')
- CategoryCounts(2,4,33)
-Approach('Auto')
-) AS dt
-);データを見ると、tot_income、tot_age、ck_avg_bal などのいくつかの列は、異なる範囲の値を持っています。勾配降下法などの最適化アルゴリズムの場合、より高速な収束、スケールの一貫性、およびモデルのパフォーマンスの向上のために、値を同じスケールに正規化することが重要です。 TD_ScaleFit 関数を利用して、さまざまなスケールで値を正規化します。
CREATE VIEW td_analytics_functions_demo.scale_fit_joined_table_input AS (
- SELECT * FROM TD_ScaleFit(
- ON td_analytics_functions_demo.joined_table AS InputTable
- USING
- TargetColumns('tot_income','q1_trans_cnt','q2_trans_cnt','q3_trans_cnt','q4_trans_cnt','ck_avg_bal','sv_avg_bal','ck_avg_tran_amt', 'sv_avg_tran_amt', 'cc_avg_tran_amt')
- ScaleMethod('RANGE')
-) AS dt
-);Teradataのデータベース分析関数は、通常、データ変換のためにペアで動作します。最初のステップは、データの "fitting" に専念します。次に、第2の関数は、フィッティングプロセスから導出されたパラメータを利用して、データに対して実際の変換を実行します。 TD_ColumnTransformer は、 FIT テーブルを関数に受け取り、入力テーブルの列を 1 回の操作で変換します。
--- Using a consolidated transform function
-CREATE TABLE td_analytics_functions_demo.feature_enriched_accounts_consolidated AS (
-SELECT * FROM TD_ColumnTransformer(
-ON joined_table AS InputTable
-ON one_hot_encoding_joined_table_input AS OneHotEncodingFitTable DIMENSION
-ON scale_fit_joined_table_input AS ScaleFitTable DIMENSION
-) as dt
-) WITH DATA;変換を実行すると、以下のイメージに示すように、カテゴリ列がone-hot エンコードされ、数値がスケーリングされたことがわかります。たとえば、tot_income は[0,1]の範囲にあり、gender は`gender_0`、gender_1、gender_other に one-hot エンコードされます。
-
-スケーリングおよびエンコードされた特徴を備えたデータセットの準備ができたので、データセットをトレーニング (75%) 部分とテスト (25%) 部分に分割しましょう。Teradata のデータベース分析関数には、データセットの分割に利用する TD_TrainTestSplit 関数が用意されています。
--- Train Test Split on Input table
-CREATE VIEW td_analytics_functions_demo.train_test_split AS (
-SELECT * FROM TD_TrainTestSplit(
-ON td_analytics_functions_demo.feature_enriched_accounts_consolidated AS InputTable
-USING
-IDColumn('cust_id')
-trainSize(0.75)
-testSize(0.25)
-Seed (42)
-) AS dt
-);以下のイメージからわかるように、この関数は新しい列 TD_IsTrainRow を追加します。
-TD_IsTrainRow を使用して、トレーニング用とテスト用の2つのテーブルを作成します。
-- Creating Training Table
-CREATE TABLE td_analytics_functions_demo.training_table AS (
- SELECT * FROM td_analytics_functions_demo.train_test_split
- WHERE TD_IsTrainRow = 1
-) WITH DATA;
-
--- Creating Testing Table
-CREATE TABLE td_analytics_functions_demo.testing_table AS (
- SELECT * FROM td_analytics_functions_demo.train_test_split
- WHERE TD_IsTrainRow = 0
-) WITH DATA;ここで 、TD_GLM データベース分析関数を使用して、トレーニング データセットでトレーニングします。TD_GLM 関数は、データセットに対して回帰および分類の分析を実行する一般化線形モデル(GLM)です。ここでは、 tot_income、 ck_avg_bal、cc_avg_tran_amt、婚姻ステータス、性別、ステータスのワンホット エンコードされた値など、多数の入力列を使用しています。 cc_avg_bal は依存列または応答列であり、連続しているため、回帰問題となります。回帰には Family として Gaussian 、分類には Binomial として使用します。
パラメータ Tolerance は、反復を停止するためにモデルの予測精度に必要な最小限の改善を示し、 MaxIterNum は認証される反復の最大数を示します。モデルは、最初に満たされた条件に基づいてトレーニングを終了します。例えば、以下の例では、58 回の反復後のモデルは CONVERGED になります。
-- Training the GLM_Model with Training Dataset
-CREATE TABLE td_analytics_functions_demo.GLM_model_training AS (
-SELECT * FROM TD_GLM (
- ON td_analytics_functions_demo.training_table AS InputTable
- USING
- InputColumns('tot_income','ck_avg_bal','cc_avg_tran_amt','[19:26]')
- ResponseColumn('cc_avg_bal')
- Family ('Gaussian')
- MaxIterNum (300)
- Tolerance (0.001)
- Intercept ('true')
-) AS dt
-) WITH DATA;
-次に、モデル GLM_model_training を使用して 、TD_GLMPredict データベース分析関数を使用してテスト データセット testing_table をスコアリングします。
-- Scoring the GLM_Model with Testing Dataset
-CREATE TABLE td_analytics_functions_demo.GLM_model_test_prediction AS (
-SELECT * from TD_GLMPredict (
-ON td_analytics_functions_demo.testing_table AS InputTable
-ON td_analytics_functions_demo.GLM_model_training AS ModelTable DIMENSION
-USING
-IDColumn ('cust_id')
-Accumulate('cc_avg_bal')
-) AS dt
-) WITH DATA;
-最後に、スコア化された結果に基づいてモデルを評価します。ここでは TD_RegressionEvaluator 関数を使用しています。モデルは、 R2、 RMSE、 F_score などのパラメータに基づいて評価できます。
-- Evaluating the model
-SELECT * FROM TD_RegressionEvaluator(
-ON td_analytics_functions_demo.GLM_model_test_prediction AS InputTable
-USING
-ObservationColumn('cc_avg_bal')
-PredictionColumn('prediction')
-Metrics('RMSE','MAE','R2')
-) AS dt;
-| - - | --このハウツーの目的は、特徴量エンジニアリングを説明することではなく、Vantage でさまざまなデータベース分析関数を活用する方法を示すことです。モデルの結果は最適ではない可能性があり、最適なモデルを作成するプロセスはこの記事のスコープ外です。 - | -
このクイック スタートでは、Teradata Database Analytic 関数を使用して ML モデルを作成する方法を学習しました。val データベースから customer、accounts、 transactions のデータを使用して独自のデータベース td_analytics_functions_demo を構築しました。TD_OneHotEncodingFit、TD_ScaleFit、TD_ColumnTransformer を使用して列を変換することにより、特徴量エンジニアリングを実行しました。次に、テスト分割のトレーニングに TD_TrainTestSplit を使用しました。TD_GLM モデルを使用してトレーニングデータセットをトレーニングし、テストデータセットをスコア化しました。最後に、TD_RegressionEvaluator 機能を用いてスコア化した結果を評価しました。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- この例は、Mulesoft MySQL サンプル プロジェクトのクローンです。 -Teradata データベースにクエリーを実行し、REST API 経由で結果を公開する方法を示します。
-Mulesoft Anypoint Studio。https://www.mulesoft.com/platform/studio から30日間のTryアルをダウンロードできる。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
このサンプル Mule サービスは、HTTP リクエストを受け取り、Teradata Vantage データベースにクエリーを実行し、結果を JSON 形式で返します。
-
-Mule HTTP コネクタは、次の形式の HTTP GET リクエストをリッスンします。http://<host>:8081/?lastname=<parameter>;.
-HTTP コネクタは、メッセージ プロパティの 1 つとして <parameter> の値をデータベース コネクタに渡します。
-データベース コネクタは、この値を抽出して以下の SQL クエリーで使用するように構成されています。
SELECT * FROM hr.employees WHERE LastName = :lastNameご覧のとおり、HTTP コネクタに渡されたパラメータの値を参照してパラメータ化されたクエリーを使用しています。 -したがって、HTTP コネクタが http://localhost:8081/?lastname=Smithを受信すると、SQL クエリーは以下のようになります。
-SELECT * FROM employees WHERE last_name = Smithデータベース コネクタは、データベース サーバーに SQL クエリーを実行するように指示し、クエリーの結果を取得して、その結果を JSON に変換する変換メッセージ プロセッサに渡します。 -HTTP コネクタはリクエスト/応答として構成されているため、結果は元の HTTP クライアントに返されます。
-Teradata/mule-jdbc-example リポジトリのクローンを作成します。
git clone https://github.com/Teradata/mule-jdbc-examplesrc/main/mule/querying-a-teradata-database.xml を編集し、Teradata接続文字列 jdbc:teradata://<HOST>/user=<username>,password=<password> を検索し、Teradata接続パラメータを使用環境に合わせて置換します。
| - - | -
-
-
-ClearScape Analytics Experience 経由で Vantage インスタンスにアクセスできるようにする場合は、<HOST> を ClearScape Analytics Experience 環境のホスト URL に置き換える必要があります。さらに、ClearScape Analytics 環境のユーザー名とパスワードを反映するように「ユーザー」と「パスワード」を更新する必要があります。 - |
-
Vantageインスタンスでサンプルデータベースを作成します。 -サンプルデータを入力します。
- -- create database
- CREATE DATABASE HR
- AS PERMANENT = 60e6, SPOOL = 120e6;
-
- -- create table
- CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
- )
- UNIQUE PRIMARY INDEX ( GlobalID );
-
- -- insert a record
- INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
- ) VALUES (
- 101,
- 'Test',
- 'Testowsky',
- '1980-01-05',
- '2004-08-01',
- 01
- );Anypoint Studioでプロジェクトを開きます。
-Anypoint Studio に入ったら、 `Import projects..`をクリックします。
-
Anypoint Studio project from File System を選択します：
git リポジトリのクローンを作成したディレクトリを プロジェクトルート として使用します。その他の設定はデフォルトのままにしておきます。
Run メニューを使用して、Anypoint Studio でサンプル アプリケーションを実行します。
-これでプロジェクトがビルドされ、実行されます。1分ほどかかります。
Web ブラウザに移動し、以下のリクエストを送信します。 http://localhost:8081/?lastname=Testowsky。
-以下の JSON 応答を取得する必要があります。
-[
- {
- "JoinedDate": "2004-08-01T00:00:00",
- "DateOfBirth": "1980-01-05T00:00:00",
- "FirstName": "Test",
- "GlobalID": 101,
- "DepartmentCode": 1,
- "LastName": "Testowsky"
- }
-]| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Native Object Storage (NOS) は、AWS S3、Google GCS、Azure Blob、またはオンプレミス実装などのオブジェクト ストレージ内のファイルに保存されているデータをクエリできるようにする Vantage の機能です。これは、Vantage にデータを取り込むためのデータ パイプラインを構築せずにデータを探索するシナリオに役立ちます。
-Teradata Vantage インスタンスにアクセスする必要があります。NOS は、バージョン 17.10 以降、Vantage Express から Developer、DYI、Vantage as a Service までのすべての Vantage エディションで有効になります。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
| - - | --現在、NOS は CSV、JSON (配列または改行区切りとして)、および Parquet データ形式をサポートしています。 - | -
データセットが CSV ファイルとして S3 バケットに保存されているとします。データセットを Vantage に取り込むかどうかを決定する前に、データセットを探索したいと考えています。このシナリオでは、the -U.S. Geological Surveyによって収集された河川流量データを含む、Teradataによって公開された公開データセットを使用します。バケットは https://td-usgs-public.s3.amazonaws.com/ にあります。
-まずはCSVデータのサンプルを見てみましょう。Vantage がバケットからフェッチする最初の 10 行を取得します。
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d;私が持っているものは次のとおりです。
-GageHeight2 Flow site_no datetime Precipitation GageHeight ------------ ----- -------- ---------------- ------------- ----------- -10.9 15300 09380000 2018-06-28 00:30 671 9.80 -10.8 14500 09380000 2018-06-28 01:00 673 9.64 -10.7 14100 09380000 2018-06-28 01:15 672 9.56 -11.0 16200 09380000 2018-06-27 00:00 669 9.97 -10.9 15700 09380000 2018-06-27 00:30 668 9.88 -10.8 15400 09380000 2018-06-27 00:45 672 9.82 -10.8 15100 09380000 2018-06-27 01:00 672 9.77 -10.8 14700 09380000 2018-06-27 01:15 672 9.68 -10.9 16000 09380000 2018-06-27 00:15 668 9.93 -10.8 14900 09380000 2018-06-28 00:45 672 9.72-
たくさんの数字が出てきましたが、それは何を意味するのでしょうか？この質問に答えるために、Vantage に CSV ファイルのスキーマを検出するように依頼します。
-SELECT
- *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- RETURNTYPE='NOSREAD_SCHEMA'
-) AS d;Vantage はデータ サンプルをフェッチしてスキーマを分析し、結果を返します。
-Name Datatype FileType Location ---------------- ----------------------------------- --------- ------------------------------------------------------------------- -GageHeight2 decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Flow decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -site_no int csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -datetime TIMESTAMP(0) FORMAT'Y4-MM-DDBHH:MI' csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Precipitation decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -GageHeight decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv-
CSV ファイルには 6 つの列があることがわかります。各列について、スキーマを推測するために使用された名前、データ型、ファイル座標を取得します。
-スキーマがわかったので、データセットを通常の SQL テーブルであるかのように操作できます。その要点を証明するために、データの集計を行ってみましょう。気温を収集しているサイトについて、サイトごとの平均気温を取得してみましょう。
-SELECT
- site_no Site_no, AVG(Flow) Avg_Flow
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d
-GROUP BY
- site_no
-HAVING
- Avg_Flow IS NOT NULL;結果：
-Site_no Avg_Flow --------- --------- -09380000 11 -09423560 73 -09424900 93 -09429070 81-
アドホック探索アクティビティを永続ソースとして登録するには、それを外部テーブルとして作成します。
--- If you are running this sample as dbc user you will not have permissions
--- to create a table in dbc database. Instead, create a new database and use
--- the newly create database to create a foreign table.
-
-CREATE DATABASE Riverflow
- AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB
-
--- change current database to Riverflow
-DATABASE Riverflow;
-
-CREATE FOREIGN TABLE riverflow
- USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );
-
-SELECT top 10 * FROM riverflow;結果：
-Location GageHeight2 Flow site_no datetime Precipitation GageHeight -------------------------------------------------------------------- ----------- ---- ------- ------------------- ------------- ---------- -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:40:00 1.21 null -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:30:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:45:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 01:00:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:15:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:38:00 1.06 null-
今回の SELECT ステートメントは、データベース内のテーブルに対する通常の選択のように見えます。データのクエリー時に 1 秒未満の応答時間が必要な場合は、CSV データを Vantage に取り込んで処理を高速化する簡単な方法があります。その方法については、読み続けてください。
オブジェクト ストレージのクエリーには時間がかかります。データが興味深いと判断し、より迅速に答えが得られるソリューションを使用してさらに分析を行いたい場合はどうすればよいでしょうか? 良いニュースは、NOS で返されたデータを CREATE TABLE 文のソースとして使用できることです。CREATE TABLE 権限があると仮定すると、次を実行できます。
| - - | -
-このクエリは、前の手順でデータベース 河川流量 と 河川流量 という外部テーブルを作成したことを前提としています。
- |
-
-- This query assumes you created database `Riverflow`
--- and a foreign table called `riverflow` in the previous step.
-
-CREATE MULTISET TABLE riverflow_native (site_no, Flow, GageHeight, datetime)
-AS (
- SELECT site_no, Flow, GageHeight, datetime FROM riverflow
-) WITH DATA
-NO PRIMARY INDEX;
-
-SELECT TOP 10 * FROM riverflow_native;結果：
-site_no Flow GageHeight datetime -------- ----- ---------- ------------------- -9400815 .00 -.01 2018-07-10 00:30:00 -9400815 .00 -.01 2018-07-10 01:00:00 -9400815 .00 -.01 2018-07-10 01:15:00 -9400815 .00 -.01 2018-07-10 01:30:00 -9400815 .00 -.01 2018-07-10 02:00:00 -9400815 .00 -.01 2018-07-10 02:15:00 -9400815 .00 -.01 2018-07-10 01:45:00 -9400815 .00 -.01 2018-07-10 00:45:00 -9400815 .00 -.01 2018-07-10 00:15:00 -9400815 .00 -.01 2018-07-10 00:00:00-
今回は、 SELECT クエリーは 1 秒以内に返されました。Vantage は NOS からデータを取得する必要がありませんでした。代わりに、ノード上にすでに存在していたデータを使用して応答しました。
これまではパブリックバケットを使用してきました。プライベートバケットがある場合はどうなるでしょうか? どの認証情報を使用する必要があるかを Vantage にどのように指示しますか?
-資格情報をクエリーに直接インライン化することができます。
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- AUTHORIZATION='{"ACCESS_ID":"","ACCESS_KEY":""}'
-) AS d;これらの認証情報を常に入力するのは面倒であり、安全性も低下する可能性があります。Vantage では、資格情報のコンテナとして機能する認可オブジェクトを作成できます。
-CREATE AUTHORIZATION aws_authorization
- USER 'YOUR-ACCESS-KEY-ID'
- PASSWORD 'YOUR-SECRET-ACCESS-KEY';これにより、外部テーブルを作成するときに認可オブジェクトを参照できるようになります。
-CREATE FOREIGN TABLE riverflow
-, EXTERNAL SECURITY aws_authorization
-USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );ここまで、オブジェクト ストレージからのデータの読み取りとインポートについて説明してきました。SQL を使用して Vantage からオブジェクト ストレージにデータをエクスポートする方法があれば素晴らしいと思いませんか? これはまさに WRITE_NOS 機能のためのものです。riverflow_native テーブルからオブジェクト ストレージにデータをエクスポートする場合を考えてみましょう。以下のクエリーを使用してこれを行うことができます。
SELECT * FROM WRITE_NOS (
- ON ( SELECT * FROM riverflow_native )
- PARTITION BY site_no ORDER BY site_no
- USING
- LOCATION('YOUR-OBJECT-STORE-URI')
- AUTHORIZATION(aws_authorization)
- STOREDAS('PARQUET')
- COMPRESSION('SNAPPY')
- NAMING('RANGE')
- INCLUDE_ORDERING('TRUE')
-) AS d;ここでは、riverflow_native からデータを取得し、parquet 形式を使用して YOUR-OBJECT-STORE-URI バケットに保存するように Vantage に指示します。データは site_no 属性によってファイルに分割されます。ファイルは圧縮されます。
このクイック スタートでは、Vantage のネイティブ オブジェクト ストレージ (NOS) 機能を使用してオブジェクト ストレージからデータを読み取る方法を学習しました。NOS は、CSV、JSON、および Parquet 形式で保存されたデータの読み取りとインポートをサポートしています。NOS は、Vantage からオブジェクト ストレージにデータをエクスポートすることもできます。
-
- Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Ubuntuマシンへのルートアクセス。
-依存関係のインストール:
-apt update && DEBIAN_FRONTEND=noninteractive apt install -y wget unixodbc unixodbc-dev iodbc python3-pipUbuntu 用の Teradata ODBC ドライバをインストールします。
-wget https://downloads.teradata.com/download/cdn/connectivity/odbc/17.10.x.x/tdodbc1710__ubuntu_x8664.17.10.00.14-1.tar.gz \
- && tar -xzf tdodbc1710__ubuntu_x8664.17.10.00.14-1.tar.gz \
- && dpkg -i tdodbc1710/tdodbc1710-17.10.00.14-1.x86_64.debODBCの設定は、/etc/odbcinst.ini を作成して、以下の内容で行います。
[ODBC Drivers]
-Teradata Database ODBC Driver 17.10=Installed
-
-[Teradata Database ODBC Driver 17.10]
-Description=Teradata Database ODBC Driver 17.10
-Driver=/opt/teradata/client/17.10/odbc_64/lib/tdataodbc_sb64.soサンプルのPythonアプリケーションを使用して、インストールを検証します。次の内容の test.py ファイルを作成します。
-DBCName=192.168.86.33;UID=dbc;PWD=dbc を Teradata Vantage インスタンスの IP アドレス、ユーザー名、およびパスワードに置き換えます。
import pyodbc
-
-print(pyodbc.drivers())
-
-cnxn = pyodbc.connect('DRIVER={Teradata Database ODBC Driver 17.10};DBCName=192.168.86.33;UID=dbc;PWD=dbc;')
-cursor = cnxn.cursor()
-
-cursor.execute("SELECT CURRENT_DATE")
-for row in cursor.fetchall():
- print(row)
-EOFテストアプリケーションを実行します。
-python3 test.py以下のような出力が得られるはずです。
-['ODBC Drivers', 'Teradata Database ODBC Driver 17.10'] -(datetime.date(2022, 1, 5), )-
このハウツーでは、Ubuntu上のTeradata VantageでODBCを使用する方法について説明しました。このハウツーでは、ODBC Teradataドライバと依存関係をインストールする方法を説明します。また、ODBCを設定し、シンプルなPythonアプリケーションで接続を検証する方法を示します。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 時系列は、時間順にインデックス付けされた一連のデータポイントです。これは、モノのインターネットを含むがこれに限定されない広範なアプリケーションやデバイスによって継続的に生成され、収集されるデータです。Teradata Vantage は、時系列データ分析を簡略化するためのさまざまな機能を提供します。
-Teradata Vantageインスタンスへのアクセス。時系列機能と NOS は、バージョン 17.10 以降、Vantage Express から Developer、DYI、Vantage as a Service までのすべての Vantage エディションで有効になります。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
サンプル データ セットは S3 バケットで利用でき、Vantage NOS を使用して Vantage から直接アクセスできます。データは CSV 形式なので、時系列分析のために Vantage に取り込んでみましょう。
-まずデータを見てみよう。以下のクエリーは S3 バケットから 10 行をフェッチします。
-SELECT TOP 10 * FROM (
- LOCATION='/s3/nos-demo-apj.s3.amazonaws.com/taxi/2014/11/data_2014-11-25.csv'
-) AS d;得られたものは以下のとおりです。
-Location vendor_id pickup_datetime dropoff_datetime passenger_count trip_distance pickup_longitude pickup_latitude rate_code store_and_fwd_flag dropoff_longitude dropoff_latitude payment_type fare_amount surcharge mta_tax tip_amount tolls_amount total_amount ------------------------------------------------------------------- --------- ----------------- ----------------- ---------------- -------------- ----------------- ---------------- ---------- ------------------- ------------------ ----------------- ------------- ------------ ---------- -------- ---------- ------------ ------------ -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:18 25/11/2013 15:33 1 1 -73.992423 40.749517 1 N -73.98816 40.746557 CRD 10 0 0.5 2.22 0 12.72 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 5:34 25/11/2013 5:48 1 3.6 -73.971555 40.794548 1 N -73.975399 40.755404 CRD 14.5 0.5 0.5 1 0 16.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 8:31 25/11/2013 8:55 1 5.9 -73.94764 40.830465 1 N -73.972323 40.76332 CRD 21 0 0.5 3 0 24.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 7:00 25/11/2013 7:04 1 1.2 -73.983357 40.767193 1 N -73.978394 40.75558 CRD 5.5 0 0.5 1 0 7 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:24 25/11/2013 15:30 1 0.5 -73.982313 40.764827 1 N -73.982129 40.758889 CRD 5.5 0 0.5 3 0 9 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:53 25/11/2013 16:00 1 0.6 -73.978104 40.752966 1 N -73.985756 40.762685 CRD 6 1 0.5 1 0 8.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 6:49 25/11/2013 7:04 1 3.8 -73.976005 40.744481 1 N -74.016063 40.717298 CRD 14 0 0.5 2.9 0 17.4 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 21:20 25/11/2013 21:26 1 1.1 -73.946371 40.775369 1 N -73.95309 40.785103 CRD 6.5 0.5 0.5 1.5 0 9 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 10:02 25/11/2013 10:17 1 2.2 -73.952625 40.780962 1 N -73.98163 40.777978 CRD 12 0 0.5 2 0 14.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 9:43 25/11/2013 10:02 1 3.3 -73.982013 40.762507 1 N -74.006854 40.719582 CRD 15 0 0.5 2 0 17.5-
完全なデータを抽出し、さらに分析するためにVantageに取り込む。
-CREATE TABLE trip
-(
- vendor_id varchar(10) character set latin NOT casespecific,
- rate_code integer,
- pickup_datetime timestamp(6),
- dropoff_datetime timestamp(6),
- passenger_count smallint,
- trip_distance float,
- pickup_longitude float,
- pickup_latitude float,
- dropoff_longitude float,
- dropoff_latitude float
-)
-NO PRIMARY INDEX ;
-
-
-
-INSERT INTO trip
-SELECT TOP 200000 vendor_id ,
- rate_code,
- pickup_datetime,
- dropoff_datetime ,
- passenger_count,
- trip_distance ,
- pickup_longitude,
- pickup_latitude ,
- dropoff_longitude ,
- dropoff_latitude FROM (
- LOCATION='/s3/nos-demo-apj.s3.amazonaws.com/taxi/2014/11/data_2014-11-25.csv'
-) AS d;結果:
-200000 rows affected.-
Vantageは、S3からデータを取得し、作成したばかりのトリップテーブルに挿入します。
-データセットに慣れたので、Vantage機能を使用してデータセットを迅速に分析できます。まず、11 月に時間ごとに何人の乗客が乗車しているかを識別しましょう。
-SELECT TOP 10
- $TD_TIMECODE_RANGE
- ,begin($TD_TIMECODE_RANGE) time_bucket_start
- ,sum(passenger_count) passenger_count
-FROM trip
-WHERE extract(month from pickup_datetime)=11
-GROUP BY TIME(HOURS(1))
-USING TIMECODE(pickup_datetime)
-ORDER BY 1;GROUP BY TIMEについてさらに読む。
-結果:
-TIMECODE_RANGE time_bucket_start passenger_count ---------------------------------------------------------- --------------------------------- ---------------- -(2013-11-04 11:00:00.000000, 2013-11-04 12:00:00.000000) 2013-11-04 11:00:00.000000-05:00 4 -(2013-11-04 12:00:00.000000, 2013-11-04 13:00:00.000000) 2013-11-04 12:00:00.000000-05:00 2 -(2013-11-04 14:00:00.000000, 2013-11-04 15:00:00.000000) 2013-11-04 14:00:00.000000-05:00 5 -(2013-11-04 15:00:00.000000, 2013-11-04 16:00:00.000000) 2013-11-04 15:00:00.000000-05:00 2 -(2013-11-04 16:00:00.000000, 2013-11-04 17:00:00.000000) 2013-11-04 16:00:00.000000-05:00 9 -(2013-11-04 17:00:00.000000, 2013-11-04 18:00:00.000000) 2013-11-04 17:00:00.000000-05:00 11 -(2013-11-04 18:00:00.000000, 2013-11-04 19:00:00.000000) 2013-11-04 18:00:00.000000-05:00 41 -(2013-11-04 19:00:00.000000, 2013-11-04 20:00:00.000000) 2013-11-04 19:00:00.000000-05:00 2791 -(2013-11-04 20:00:00.000000, 2013-11-04 21:00:00.000000) 2013-11-04 20:00:00.000000-05:00 15185 -(2013-11-04 21:00:00.000000, 2013-11-04 22:00:00.000000) 2013-11-04 21:00:00.000000-05:00 27500-
はい、これは、時間から時間を抽出して集計することによっても実現できる。これは追加のコード/作業であるが、時系列固有の機能がなくても実行できます。
-しかし、ここでさらに一歩進んで、11 月に何人の乗客が乗車しているか、またベンダー別の 15 分ごとの平均移動所要期間はどれくらいかを識別してみましょう。
-SELECT TOP 10
- $TD_TIMECODE_RANGE,
- vendor_id,
- SUM(passenger_count),
- AVG((dropoff_datetime - pickup_datetime ) MINUTE (4)) AS avg_trip_time_in_mins
-FROM trip
-GROUP BY TIME (MINUTES(15) AND vendor_id)
-USING TIMECODE(pickup_datetime)
-WHERE EXTRACT(MONTH FROM pickup_datetime)=11
-ORDER BY 1,2;結果:
-TIMECODE_RANGE vendor_id passenger_count avg_trip_time_in_mins --------------------------------------------------------- ---------- ---------------- ---------------------- -(2013-11-04 11:00:00.000000, 2013-11-04 11:15:00.000000) VTS 1 16 -(2013-11-04 11:15:00.000000, 2013-11-04 11:30:00.000000) VTS 1 10 -(2013-11-04 11:45:00.000000, 2013-11-04 12:00:00.000000) VTS 2 6 -(2013-11-04 12:00:00.000000, 2013-11-04 12:15:00.000000) VTS 1 11 -(2013-11-04 12:15:00.000000, 2013-11-04 12:30:00.000000) VTS 1 57 -(2013-11-04 14:15:00.000000, 2013-11-04 14:30:00.000000) VTS 1 3 -(2013-11-04 14:30:00.000000, 2013-11-04 14:45:00.000000) VTS 2 19 -(2013-11-04 14:45:00.000000, 2013-11-04 15:00:00.000000) VTS 2 9 -(2013-11-04 15:15:00.000000, 2013-11-04 15:30:00.000000) VTS 1 11 -(2013-11-04 15:30:00.000000, 2013-11-04 15:45:00.000000) VTS 1 31-
これがVantageの時系列機能の威力です。複雑で面倒なロジックを必要とせず、時間ごとのグループ句を変更するだけで、ベンダーごとの平均移動期間を 15 分ごとに見つけることができます。これに基づいて移動平均を作成するのがいかに簡単かを見てみましょう。まず、次のようにビューを作成することから始めましょう。
-REPLACE VIEW NYC_taxi_trip_ts as
-SELECT
- $TD_TIMECODE_RANGE time_bucket_per
- ,vendor_id
- ,sum(passenger_count) passenger_cnt
- ,avg(CAST((dropoff_datetime - pickup_datetime MINUTE(4) ) AS INTEGER)) avg_trip_time_in_mins
-FROM trip
-GROUP BY TIME (MINUTES(15) and vendor_id)
-USING TIMECODE(pickup_datetime)
-WHERE extract(month from pickup_datetime)=1115分の時系列で2時間の移動平均を計算してみよう。 2時間は8*15分の期間です。
-SELECT * FROM MovingAverage (
- ON NYC_taxi_trip_ts PARTITION BY vendor_id ORDER BY time_bucket_per
- USING
- MAvgType ('S')
- WindowSize (8)
- TargetColumns ('passenger_cnt')
-) AS dt
-WHERE begin(time_bucket_per)(date) = '2014-11-25'
-ORDER BY vendor_id, time_bucket_per;結果:
-time_bucket_per vendor_id passenger_cnt avg_trip_time_in_mins passenger_cnt_smavg ---------------------------------------------------------- -------------- ---------------------- -------------------- -------------------- -(2013-11-04 14:45:00.000000, 2013-11-04 15:00:00.000000) VTS 2 9 1.375 -(2013-11-04 15:15:00.000000, 2013-11-04 15:30:00.000000) VTS 1 11 1.375 -(2013-11-04 15:30:00.000000, 2013-11-04 15:45:00.000000) VTS 1 31 1.375 -(2013-11-04 16:15:00.000000, 2013-11-04 16:30:00.000000) VTS 2 16 1.375 -(2013-11-04 16:30:00.000000, 2013-11-04 16:45:00.000000) VTS 1 3 1.375 -(2013-11-04 16:45:00.000000, 2013-11-04 17:00:00.000000) VTS 6 38 2 -(2013-11-04 17:15:00.000000, 2013-11-04 17:30:00.000000) VTS 2 29.5 2.125 -(2013-11-04 17:45:00.000000, 2013-11-04 18:00:00.000000) VTS 9 20.33333333 3 -(2013-11-04 18:00:00.000000, 2013-11-04 18:15:00.000000) VTS 6 23.4 3.5 -(2013-11-04 18:15:00.000000, 2013-11-04 18:30:00.000000) VTS 4 15.66666667 3.875 -(2013-11-04 18:30:00.000000, 2013-11-04 18:45:00.000000) VTS 8 24.5 4.75 -(2013-11-04 18:45:00.000000, 2013-11-04 19:00:00.000000) VTS 23 38.33333333 7.375 -(2013-11-04 19:00:00.000000, 2013-11-04 19:15:00.000000) VTS 195 26.61538462 31.625 -(2013-11-04 19:15:00.000000, 2013-11-04 19:30:00.000000) VTS 774 13.70083102 127.625 -(2013-11-04 19:30:00.000000, 2013-11-04 19:45:00.000000) VTS 586 12.38095238 200.625 -(2013-11-04 19:45:00.000000, 2013-11-04 20:00:00.000000) VTS 1236 15.54742097 354 -(2013-11-04 20:00:00.000000, 2013-11-04 20:15:00.000000) VTS 3339 11.78947368 770.625 -(2013-11-04 20:15:00.000000, 2013-11-04 20:30:00.000000) VTS 3474 10.5603396 1204.375 -(2013-11-04 20:30:00.000000, 2013-11-04 20:45:00.000000) VTS 3260 12.26484323 1610.875 -(2013-11-04 20:45:00.000000, 2013-11-04 21:00:00.000000) VTS 5112 12.05590062 2247-
| - - | --上記の時系列操作に加えて、Vantage はプライマリ タイム インデックス (PTI) を備えた特別な時系列テーブルも提供します。これらは、プライマリインデックス(PI)ではなくPTIが定義された通常のバンテージテーブルです。PTI を含むテーブルは時系列の機能/操作には必須ではありませんが、PTI は時系列データの物理的な保存方法を最適化するため、通常のテーブルと比較してパフォーマンスが大幅に向上します。 - | -
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、AWS で Vantage Express を実行する方法を示します。Vantage Express は、完全に機能する Teradata SQL Engineを含む、設置面積が小さい構成です。
-| - - | -
- クラウド料金
-
-
-Vantage Express は仮想マシン イメージとして配布されます。このハウツーでは EC2
-
-より安価なオプションが必要な場合は、ネストされた仮想化をサポートし、安価なVMでVantage Expressを実行できるGoogle Cloud と Azure を試してください。 -
-
-クラウド利用に対して料金を払いたくない場合は、https://clearscape.teradata.com/ でVantageの無料ホストインスタンスを入手できます。または、VMware、VirtualBox、または UTM を使用してVantage Expressをローカルにインストールすることもできます。 - |
-
AWS アカウント。新しいアカウントを作成する必要がある場合は、 AWS の公式手順 に従ってください。
-awscli コマンド ライン ユーティリティがマシンにインストールされ、設定されていること。インストール手順はここで見つけることができます。https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
インターネットに接続するサブネットを持つVPCが必要です。利用可能なものがない場合は、以下の方法で作成できます。
-# Copied from https://cloudaffaire.com/how-to-create-a-custom-vpc-using-aws-cli/
-
-# Create VPC
-AWS_VPC_ID=$(aws ec2 create-vpc \
- --cidr-block 10.0.0.0/16 \
- --query 'Vpc.{VpcId:VpcId}' \
- --output text)
-
-# Enable DNS hostname for your VPC
-aws ec2 modify-vpc-attribute \
- --vpc-id $AWS_VPC_ID \
- --enable-dns-hostnames "{\"Value\":true}"
-
-# Create a public subnet
-AWS_SUBNET_PUBLIC_ID=$(aws ec2 create-subnet \
- --vpc-id $AWS_VPC_ID --cidr-block 10.0.1.0/24 \
- --query 'Subnet.{SubnetId:SubnetId}' \
- --output text)
-
-# Enable Auto-assign Public IP on Public Subnet
-aws ec2 modify-subnet-attribute \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --map-public-ip-on-launch
-
-# Create an Internet Gateway
-AWS_INTERNET_GATEWAY_ID=$(aws ec2 create-internet-gateway \
- --query 'InternetGateway.{InternetGatewayId:InternetGatewayId}' \
- --output text)
-
-# Attach Internet gateway to your VPC
-aws ec2 attach-internet-gateway \
- --vpc-id $AWS_VPC_ID \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID
-
-# Create a route table
-AWS_CUSTOM_ROUTE_TABLE_ID=$(aws ec2 create-route-table \
- --vpc-id $AWS_VPC_ID \
- --query 'RouteTable.{RouteTableId:RouteTableId}' \
- --output text )
-
-# Create route to Internet Gateway
-aws ec2 create-route \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID \
- --destination-cidr-block 0.0.0.0/0 \
- --gateway-id $AWS_INTERNET_GATEWAY_ID \
- --output text
-
-# Associate the public subnet with route table
-AWS_ROUTE_TABLE_ASSOID=$(aws ec2 associate-route-table \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID \
- --output text | head -1)
-
-# Create a security group
-aws ec2 create-security-group \
- --vpc-id $AWS_VPC_ID \
- --group-name myvpc-security-group \
- --description 'My VPC non default security group' \
- --output text
-
-# Get security group ID's
-AWS_DEFAULT_SECURITY_GROUP_ID=$(aws ec2 describe-security-groups \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'SecurityGroups[?GroupName == `default`].GroupId' \
- --output text) &&
- AWS_CUSTOM_SECURITY_GROUP_ID=$(aws ec2 describe-security-groups \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'SecurityGroups[?GroupName == `myvpc-security-group`].GroupId' \
- --output text)
-
-# Create security group ingress rules
-aws ec2 authorize-security-group-ingress \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID \
- --ip-permissions '[{"IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "Allow SSH"}]}]' \
- --output text
-
-# Add a tag to the VPC
-aws ec2 create-tags \
- --resources $AWS_VPC_ID \
- --tags "Key=Name,Value=vantage-express-vpc"
-
-# Add a tag to public subnet
-aws ec2 create-tags \
- --resources $AWS_SUBNET_PUBLIC_ID \
- --tags "Key=Name,Value=vantage-express-vpc-public-subnet"
-
-# Add a tag to the Internet-Gateway
-aws ec2 create-tags \
- --resources $AWS_INTERNET_GATEWAY_ID \
- --tags "Key=Name,Value=vantage-express-vpc-internet-gateway"
-
-# Add a tag to the default route table
-AWS_DEFAULT_ROUTE_TABLE_ID=$(aws ec2 describe-route-tables \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'RouteTables[?Associations[0].Main != `false`].RouteTableId' \
- --output text) &&
- aws ec2 create-tags \
- --resources $AWS_DEFAULT_ROUTE_TABLE_ID \
- --tags "Key=Name,Value=vantage-express-vpc-default-route-table"
-
-# Add a tag to the public route table
-aws ec2 create-tags \
- --resources $AWS_CUSTOM_ROUTE_TABLE_ID \
- --tags "Key=Name,Value=vantage-express-vpc-public-route-table"
-
-# Add a tags to security groups
-aws ec2 create-tags \
- --resources $AWS_CUSTOM_SECURITY_GROUP_ID \
- --tags "Key=Name,Value=vantage-express-vpc-security-group" &&
- aws ec2 create-tags \
- --resources $AWS_DEFAULT_SECURITY_GROUP_ID \
- --tags "Key=Name,Value=vantage-express-vpc-default-security-group"VMを作成するには、sshキーペアが必要です。まだ持っていない場合は、作成してください。
-aws ec2 create-key-pair --key-name vantage-key --query 'KeyMaterial' --output text > vantage-key.pem秘密キーへのアクセスを制限してください。 <path_to_private_key_file> を前述のコマンドで返された秘密キーのパスに置き換えます。
chmod 600 vantage-key.pemリージョンの最新のUbuntuイメージのAMI IDを取得します。
-AWS_AMI_ID=$(aws ec2 describe-images \
- --filters 'Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-*amd64*' \
- --query 'Images[*].[Name,ImageId,CreationDate]' --output text \
- | sort -k3 -r | head -n1 | cut -f 2)4 つの CPU、8 GB の RAM、および 70 GB のディスクを備えた Ubuntu VM を作成します。
-AWS_INSTANCE_ID=$(aws ec2 run-instances \
- --image-id $AWS_AMI_ID \
- --count 1 \
- --instance-type c5n.metal \
- --block-device-mapping DeviceName=/dev/sda1,Ebs={VolumeSize=70} \
- --key-name vantage-key \
- --security-group-ids $AWS_CUSTOM_SECURITY_GROUP_ID \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --query 'Instances[0].InstanceId' \
- --output text)VMにsshで接続します。
-AWS_INSTANCE_PUBLIC_IP=$(aws ec2 describe-instances \
- --query "Reservations[*].Instances[*].PublicIpAddress" \
- --output=text --instance-ids $AWS_INSTANCE_ID)
-ssh -i vantage-key.pem ubuntu@$AWS_INSTANCE_PUBLIC_IPVM に接続したら、 root ユーザーに切り替えます。
sudo -iVantage Express のダウンロード ディレクトリを準備します。
-mkdir /opt/downloads
-cd /opt/downloadsVirtualBoxと7 zipをインストールします。
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -ycurlコマンドを取得して、Vantage Expressをダウンロードします。
-Vantage Expess のダウンロード ページに移動します (登録が必要です)。
-「Vantage Express 17.20」などの最新のダウンロードリンクをクリックします。使用許諾契約のポップアップが表示されます。まだライセンスを受け入れません。
-ブラウザでネットワークビューを開きます。例えば、Chrome で F12 を押し「 Network」タブに移動します。
-`I Agree (同意する)`ボタンをクリックしてライセンスを受け入れ、ダウンロードをキャンセルします。
-ネットワーク ビューで、 `VantageExpress`で始まる最後のリクエストを見つけます。それを右クリックして `Copy → Copy as cURL`を選択します。
-
-ssh セッションに戻り、curl コマンドを貼り付けて Vantage Express をダウンロードします。ダウンロードを ve.7z という名前のファイルに保存するには、コマンドに -o ve.7z を追加します。次のように、すべてのHTTPヘッダーを削除できます。
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'ダウンロードしたファイルを解凍します。数分かかります。
-7z x ve.7zVirtualBox で VM を起動しますコマンドはすぐに返されますが、VM の初期化プロセスには数分かかります。
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cVantage Express VM に ssh で接続します。 root をパスワードとして使用します。
ssh -p 4422 root@localhostDBがアップしていることを確認します。
-pdestate -aコマンドが`PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent`を返す場合は、Vantage Expressが起動したことを意味します。
-状態が異なる場合は、正しいステータスが得られるまで pdestate -a を繰り返します。
Vantage Expressが起動して実行されたら、bteq クライアントのコマンドラインクライアントを起動します。BTEQ (「ビーテック」と発音) は、Teradata Database に SQL クエリーを送信するために使用される、汎用のコマンド ベースのクライアント ツールです。
bteqbteqに入ったら、Vantage Expressインスタンスに接続します。パスワードを求められたら、 `dbc`を入力します。
-.logon localhost/dbc`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/貼り付けて、Enter を押して実行します。
-CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VM を停止して起動する場合は、Vantage Express を自動起動に追加することをお勧めします。 VM に ssh で接続し、以下のコマンドを実行します。
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressインターネットから Vantage Express に接続したい場合は、VM にファイアウォールの穴を開ける必要があります。また、デフォルトのパスワードを dbc ユーザーに変更する必要があります。
dbc ユーザーのパスワードを変更するには、VM に移動して bteq を開始します。
bteqユーザー名とパスワードとして dbc を使用してデータベースにログインします。
.logon localhost/dbcdbc ユーザーのパスワードを変更します。
MODIFY USER dbc AS PASSWORD = new_password;これで、ポート 1025 をインターネットに開くことができます。
-aws ec2 authorize-security-group-ingress \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID \
- --ip-permissions '[{"IpProtocol": "tcp", "FromPort": 1025, "ToPort": 1025, "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "Allow Teradata port"}]}]'課金を停止するには、すべてのリソースを削除します。
-# Delete the VM
-aws ec2 terminate-instances --instance-ids $AWS_INSTANCE_ID --output text
-
-# Wait for the VM to terminate
-
-# Delete custom security group
-aws ec2 delete-security-group \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID
-
-# Delete internet gateway
-aws ec2 detach-internet-gateway \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID \
- --vpc-id $AWS_VPC_ID &&
- aws ec2 delete-internet-gateway \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID
-
-# Delete the custom route table
-aws ec2 disassociate-route-table \
- --association-id $AWS_ROUTE_TABLE_ASSOID &&
- aws ec2 delete-route-table \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID
-
-# Delete the public subnet
-aws ec2 delete-subnet \
- --subnet-id $AWS_SUBNET_PUBLIC_ID
-
-# Delete the vpc
-aws ec2 delete-vpc \
- --vpc-id $AWS_VPC_ID| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Microsoft Azure で Vantage Express を実行する方法を示します。Vantage Express には、完全に機能する Teradata SQL Engineが含まれています。
-Azureアカウント。ここで作成できます。 https://azure.microsoft.com/en-us/free/
-az コマンド ラインユーティリティがマシンにインストールされています。インストール手順はここで見つけることができます。https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
デフォルトのリージョンを自分に最も近いリージョンに設定します (場所をリストするには az account list-locations -o table を実行します)。
az config set defaults.location=<location>tdve-resource-group という名前の新しいリソース グループを作成し、デフォルトに追加します。
az group create -n tdve-resource-group
-az config set defaults.group=tdve-resource-groupVMを作成するには、sshキーペアが必要です。まだ持っていない場合は、作成する。
-az sshkey create --name vantage-ssh-key秘密キーへのアクセスを制限する。 <path_to_private_key_file> を前述のコマンドで返された秘密キーのパスに置き換えます。
chmod 600 <path_to_private_key_file>4つの CPU と 8GB の RAM、30GB の OS ディスク、60GB のデータディスクを備えた Ubuntu VM を作成します。
-az disk create -n teradata-vantage-express --size-gb 60
-az vm create `
- --name teradata-vantage-express `
- --image UbuntuLTS `
- --admin-username azureuser `
- --ssh-key-name vantage-ssh-key `
- --size Standard_F4s_v2 `
- --public-ip-sku Standard
-
-$diskId = (az disk show -n teradata-vantage-express --query 'id' -o tsv) | Out-String
-az vm disk attach --vm-name teradata-vantage-express --name $diskIdaz disk create -n teradata-vantage-express --size-gb 60
-az vm create \
- --name teradata-vantage-express \
- --image UbuntuLTS \
- --admin-username azureuser \
- --ssh-key-name vantage-ssh-key \
- --size Standard_F4s_v2 \
- --public-ip-sku Standard
-
-DISK_ID=$(az disk show -n teradata-vantage-express --query 'id' -o tsv)
-az vm disk attach --vm-name teradata-vantage-express --name $DISK_IDaz disk create -n teradata-vantage-express --size-gb 60
-az vm create \
- --name teradata-vantage-express \
- --image UbuntuLTS \
- --admin-username azureuser \
- --ssh-key-name vantage-ssh-key \
- --size Standard_F4s_v2 \
- --public-ip-sku Standard
-
-DISK_ID=$(az disk show -n teradata-vantage-express --query 'id' -o tsv)
-az vm disk attach --vm-name teradata-vantage-express --name $DISK_IDVMにsshで接続します。 <path_to_private_key_file> と <vm_ip> を環境に一致する値に置き換えます。
ssh -i <path_to_private_key_file> azureuser@<vm_ip>VM に接続したら、root ユーザーに切り替えます。
sudo -iVantage Express用のダウンロードディレクトリを準備します。
-mkdir /opt/downloads
-cd /opt/downloadsデータ ディスクをマウントします。
-parted /dev/sdc --script mklabel gpt mkpart xfspart xfs 0% 100%
-mkfs.xfs /dev/sdc1
-partprobe /dev/sdc1
-export DISK_UUID=$(blkid | grep sdc1 | cut -d"\"" -f2)
-echo "UUID=$DISK_UUID /opt/downloads xfs defaults,nofail 1 2" >> /etc/fstabVirtualBoxと7 zipをインストールします。
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -ycurlコマンドを取得して、Vantage Expressをダウンロードします。
-Vantage Expess のダウンロード ページに移動します (登録が必要です)。
-「Vantage Express 17.20」などの最新のダウンロードリンクをクリックします。使用許諾契約のポップアップが表示されます。まだライセンスを受け入れません。
-ブラウザでネットワークビューを開きます。例えば、Chrome で F12 を押し「 Network」タブに移動します。
-`I Agree (同意する)`ボタンをクリックしてライセンスを受け入れ、ダウンロードをキャンセルします。
-ネットワーク ビューで、 `VantageExpress`で始まる最後のリクエストを見つけます。それを右クリックして `Copy → Copy as cURL`を選択します。
-
-ssh セッションに戻り、curl コマンドを貼り付けて Vantage Express をダウンロードします。ダウンロードを ve.7z という名前のファイルに保存するには、コマンドに -o ve.7z を追加します。次のように、すべてのHTTPヘッダーを削除できます。
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'ダウンロードしたファイルを解凍します。数分かかります。
-7z x ve.7zVirtualBox で VM を起動しますコマンドはすぐに返されますが、VM の初期化プロセスには数分かかります。
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cVantage Express VM に ssh で接続します。 root をパスワードとして使用します。
ssh -p 4422 root@localhostDBがアップしていることを確認します。
-pdestate -aコマンドが`PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent`を返す場合は、Vantage Expressが起動したことを意味します。
-状態が異なる場合は、正しいステータスが得られるまで pdestate -a を繰り返します。
Vantage Expressが起動して実行されたら、bteq クライアントのコマンドラインクライアントを起動します。BTEQ (「ビーテック」と発音) は、Teradata Database に SQL クエリーを送信するために使用される、汎用のコマンド ベースのクライアント ツールです。
bteqbteqに入ったら、Vantage Expressインスタンスに接続します。パスワードを求められたら、 `dbc`を入力します。
-.logon localhost/dbc`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/貼り付けて、Enter を押して実行します。
-CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VM を停止して起動する場合は、Vantage Express を自動起動に追加することをお勧めします。 VM に ssh で接続し、以下のコマンドを実行します。
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressインターネットからVantage Expressに接続したい場合は、VMに対してファイアウォールの穴を開ける必要がある。また、デフォルトのパスワードを dbc ユーザーに変更する必要があります。
dbc ユーザーのパスワードを変更するには、VM に移動して bteq を開始します。
bteqユーザー名とパスワードとして dbc を使用してデータベースにログインします。
.logon localhost/dbcdbc ユーザーのパスワードを変更します。
MODIFY USER dbc AS PASSWORD = new_password;gcloud コマンドを使用して、ポート 1025 をインターネットに開くことができるようになりました。
-az vm open-port --name teradata-vantage-express --port 1025料金の発生を停止するには、リソース グループに関連付けられているすべてのリソースを削除します。
-az group delete --no-wait -n tdve-resource-group| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このソリューションは、Twilio Segmentからのイベントをリッスンし、Teradata Vantage インスタンスにデータを書き込みます。この例ではGoogle Cloudを使用しているが、任意のクラウドプラットフォームに変換できます。
-このソリューションでは、Twilio Segmentが生のイベント データを Google Cloud Pub/Sub に書き込みます。Pub/SubはイベントをCloud Runアプリケーションに転送します。Cloud Runアプリは、Teradata Vantageデータベースにデータを書き込みます。これは、VMの割り当てや管理を必要としないサーバレスソリューションです。
-
-Google Cloudアカウント。アカウントをお持ちでない場合は、https://console.cloud.google.com/ で作成できます。
-gcloud がインストールされている。https://cloud.google.com/sdk/docs/install を参照してください。
Google Cloud Runが対話できるTeradata Vantageインスタンス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
サンプル リポジトリのクローンを作成します。
-git clone git@github.com:Teradata/segment-integration-tutorial.gitリポジトリには、データベースを設定する segment.sql ファイルが含まれています。 お気に入りの SQL IDE、Teradata Studio (https://downloads.teradata.com/download/tools/teradata-studio)、または bteq というコマンド ライン ツール (Windows、https://downloads.teradata.com/node/200442[Linux]、https://downloads.teradata.com/node/201214[macOS ]用にダウンロード) を使用して、Vantage データベース上のスクリプトを実行します。
-SQL スクリプトは、Segment と呼ばれる新しいデータベースと、セグメント イベントを保存するためのテーブルのセットを作成します。
デフォルトのプロジェクトとリージョンを設定します。
-gcloud config set project <PROJECT_ID>
-gcloud config set compute/region <REGION>プロジェクトのIDと番号を取得します。これは後続のステップで必要になります。
-export PROJECT_ID=$(gcloud config get-value project)
-
-export PROJECT_NUMBER=$(gcloud projects list \
- --filter="$(gcloud config get-value project)" \
- --format="value(PROJECT_NUMBER)")必要な Google Cloud サービスを有効にします。
-gcloud services enable cloudbuild.googleapis.com containerregistry.googleapis.com run.googleapis.com secretmanager.googleapis.com pubsub.googleapis.comアプリケーションを構築します。
-gcloud builds submit --tag gcr.io/$PROJECT_ID/segment-listenerSegmentと共有する API キーを定義します。APIキーをGoogle Cloud Secret Managerに保存します。
-gcloud secrets create VANTAGE_USER_SECRET
-echo -n 'dbc' > /tmp/vantage_user.txt
-gcloud secrets versions add VANTAGE_USER_SECRET --data-file=/tmp/vantage_user.txt
-
-gcloud secrets create VANTAGE_PASSWORD_SECRET
-echo -n 'dbc' > /tmp/vantage_password.txt
-gcloud secrets versions add VANTAGE_PASSWORD_SECRET --data-file=/tmp/vantage_password.txtSegment データを Vantage に書き込むアプリケーションは Cloud Run を使用します。まず、Cloud Runがシークレットにアクセスできるようにする必要があります。
-gcloud projects add-iam-policy-binding $PROJECT_ID \
- --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
- --role=roles/secretmanager.secretAccessorアプリを Cloud Run にデプロイします (<VANTAGE_HOST> を Teradata Vantage データベースのホスト名または IP に置き換えます)。2 番目のエクスポート文は、後続のコマンドで必要になるサービス URL を保存します。
gcloud run deploy --image gcr.io/$PROJECT_ID/segment-listener segment-listener \
- --region $(gcloud config get-value compute/region) \
- --update-env-vars VANTAGE_HOST=35.239.251.1 \
- --update-secrets 'VANTAGE_USER=VANTAGE_USER_SECRET:1, VANTAGE_PASSWORD=VANTAGE_PASSWORD_SECRET:1' \
- --no-allow-unauthenticated
-
-export SERVICE_URL=$(gcloud run services describe segment-listener --platform managed --region $(gcloud config get-value compute/region) --format 'value(status.url)')Segmentからイベントを受信する Pub/Sub トピックを作成します。
-gcloud pubsub topics create segment-eventsPub/Sub が Cloud Run アプリを呼び出すために使用するサービス アカウントを作成します。
-gcloud iam service-accounts create cloud-run-pubsub-invoker \
- --display-name "Cloud Run Pub/Sub Invoker"サービス アカウントに Cloud Run を呼び出すアクセス権を付与します。
-gcloud run services add-iam-policy-binding segment-listener \
- --region $(gcloud config get-value compute/region) \
- --member=serviceAccount:cloud-run-pubsub-invoker@$PROJECT_ID.iam.gserviceaccount.com \
- --role=roles/run.invokerPub/Sub がプロジェクト内に認証トークンを作成できるようにします。
-gcloud projects add-iam-policy-binding $PROJECT_ID \
- --member=serviceAccount:service-$PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
- --role=roles/iam.serviceAccountTokenCreatorサービス アカウントを使用してPub/Subサブスクリプションを作成します。
-gcloud pubsub subscriptions create segment-events-cloudrun-subscription --topic projects/$PROJECT_ID/topics/segment-events \
- --push-endpoint=$SERVICE_URL \
- --push-auth-service-account=cloud-run-pubsub-invoker@$PROJECT_ID.iam.gserviceaccount.com \
- --max-retry-delay 600 \
- --min-retry-delay 30Segmentがトピックに公開できるようにします。これを行うには、https://console.cloud.google.com/cloudpubsub/topic/list のプロジェクトの pubsub@segment-integrations.iam.gserviceaccount.com ロール Pub/Sub Publisher を割り当てます。詳細は Segment マニュアル を参照してください。
Google Cloud Pub/Sub をSegmentの宛先として構成します。完全なトピック projects/<PROJECT_ID>/topics/segment-events を使用し、すべてのSegment イベント型 ( * 文字を使用) をトピックにマップします。
Segmentのイベント テスター機能を使用して、サンプル ペイロードをトピックに送信します。サンプルデータがVantageに保存されていることを確認します。
-この例では、アプリを単一リージョンにデプロイする方法を示します。多くの場合、この設定では十分な稼働時間は保証されません。Cloud Run アプリは、グローバル ロード バランサの背後にある複数のリージョンにデプロイする必要があります。
-このハウツーでは、Segment イベントを Teradata Vantage に送信する方法を説明します。この構成では、イベントがSegmentから Google Cloud Pub/Sub に転送され、さらに Cloud Run アプリケーションに転送されます。アプリケーションは Teradata Vantage にデータを書き込みます。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 今回は、データの取り込みに関するさまざまなユースケースについて概説します。利用可能なソリューションをリストし、各ユースケースに最適なソリューションを推奨します。
-利用可能なソリューション:
-Teradata Parallel Transporter API -を使用する* データをオブジェクト ストレージにストリームし、 Teradata Native Object Store (NOS) を使用して取り込む。
-Teradata Parallel Transporter (TPT) のコマンドラインユーティリティを使用する
-JDBC (Java)、teradatasql (Python)、Node.js ドライバ、ODBC、.NET データ プロバイダなどの Teradata データベース ドライバを使用する。
-Teradata Parallel Transport API は、通常、高スループットと最小限の待機時間を提供する最もパフォーマンスの高いソリューションです。1 秒あたり数万行を取り込む必要がある場合、および C 言語の使用に慣れている場合は、これを使用してください。
-イベント数が 1 秒あたり数千単位になる場合は、Teradata データベース ドライバを使用してください。JDBC、Python などの最も一般的なドライバで利用可能な Fastload プロトコルの使用を検討してください。
-ソリューションがより高い待機時間を許容できる場合、イベントをオブジェクト ストレージにストリームし、NOS を使用してデータを読み取ることが良い選択肢となります。通常、この解決策は最小限の労力で済みます。
-利用可能なソリューション:
-NOS はすべての Teradata ノードを利用して取り込みを実行できるため、オブジェクト ストレージに保存されたファイルからデータを取り込むには、Teradata NOS が推奨されるオプションです。Teradata Parallel Transporter (TPT) はクライアント側で実行されます。NOS からオブジェクト ストレージへの接続がない場合に使用できます。
-利用可能なソリューション:
-TPTは、ローカルファイルからデータをロードするための推奨オプションです。TPT はスケーラビリティと並列処理に関して最適化されているため、利用可能なすべてのオプションの中で最高のスループットを備えています。BTEQ は、取り込みプロセスでスクリプトが必要な場合に使用できます。また、他のすべての取り込みパイプラインが BTEQ で実行されている場合は、 BTEQ を使用し続けることも意味があります。
-利用可能なソリューション:
-Airbyte、 Precog、 Nexla、 Fivetran -などの複数のサードパーティ ツール* SaaS アプリからローカル ファイルにエクスポートし、https://docs.teradata.com/r/Teradata-Parallel-Transporter-User-Guide/June-2022/Introduction-to-Teradata-PT[Teradata Parallel Transporter (TPT),window="_blank"] -を使用して取り込む* SaaS アプリからオブジェクト ストレージにエクスポートし、 Teradata Native Object Store (NOS)を使用して取り込む
-SaaS アプリからオブジェクト ストレージにエクスポートしてから、 SaaS アプリケーションから Teradata Vantage にデータを移動するには、通常、サードパーティ ツールの方が適しています。データ ソースに対する広範なサポートを提供し、エクスポートやエクスポートされたデータセットの格納などの中間ステップを管理する必要がなくなります。
-利用可能なソリューション:
-他のデータベースからローカル ファイルにエクスポートし、 Teradata Parallel Transporter (TPT) -を使用して取り込む* 他のデータベースからオブジェクト ストレージにエクスポートし、 Teradata Native Object Store (NOS) を使用して取り込む
-QueryGrid は、異なるシステム/プラットフォーム間で限られた量のデータを移動する場合に推奨されるオプションです。これには、Vantage インスタンス、Apache Spark、Oracle、Presto など内の移動が含まれます。これは、同期する必要があるものが SQL で表現できる複雑な条件で記述されている状況に特に適しています。
-
- 場合によっては、SQL では簡単に表現できない複雑なロジックをデータに適用する必要があります。1つのオプションは、ユーザー定義関数(UDF)でロジックをラップすることです。このロジックが UDF でサポートされていない言語で既にコーディングされている場合はどうなるでしょうか? Script Table Operator は、ロジックをデータに取り込んで Vantage 上で実行できるようにする Vantage の機能です。このアプローチの利点は、操作するために Vantage からデータを取得する必要がないことです。また、Vantage でデータ アプリケーションを実行することにより、その並列性を活用できます。アプリケーションがどのように拡張されるかを考える必要はありません。Vantage にお任せください。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
簡単なことから始めましょう。データベースに「Hello World」を出力させたい場合はどうすればよいでしょうか?
-SELECT *
-FROM
- SCRIPT(
- SCRIPT_COMMAND('echo Hello World!')
- RETURNS ('Message varchar(512)'));以下のとおりです。
-Message ------------- -Hello World! -Hello World!-
ここで何が起こったのか分析してみましょう。SQLには`echo Hello World!`が含まれています。これはBashコマンドです。さて、Bash コマンドを実行する方法がわかりました。しかし、なぜ 1 行ではなく 2 行が取得されたのでしょうか? これは、単純なスクリプトが各 AMP で 1 回実行され、たまたま 2 つの AMP があるためです。
--- Teradata magic that returns the number of AMPs in a system
-SELECT hashamp()+1 AS number_of_amps;Returns:
-number_of_amps --------------- - 2-
この単純なスクリプトは、Script Table Operator (STO) の背後にある考え方を示しています。スクリプトを提供すると、データベースはそれを AMP ごとに 1 回ずつ並行して実行します。これは、スクリプト内に変換ロジックがあり、処理するデータが大量にある場合に魅力的なモデルです。通常、アプリケーションに同時並行性を組み込む必要があります。STO にそれを実行させることで、Teradata がデータに適切な同時並行性レベルを選択できるようになります。
-さて、Bash で echo を行いましたが、Bash は複雑なロジックを表現するための生産的な環境とは言えません。 では、他にどのような言語がサポートされているのでしょうか? 幸いなことに、Vantage ノードで実行できるバイナリはすべて STO で使用できることです。バイナリとそのすべての依存関係をすべての Vantage ノードにインストールする必要があることに注意してください。実際には、これは、管理者がサーバー上で維持したいと考え、維持できるものにオプションが制限されることを意味します。Python は非常に人気のある選択肢です。
Hello World は非常にエキサイティングですが、大きなファイルに既存のロジックがある場合はどうなるでしょうか。確かに、スクリプト全体を貼り付けたり、SQL クエリーで引用符をエスケープしたりする必要はありません。スクリプトのアップロードの問題は、ユーザーインストールファイル(UIF)機能で解決します。
-以下の内容の helloworld.py スクリプトがあるとします。
print("Hello World!")スクリプトが /tmp/helloworld.py のローカルマシンにあると仮定します。
まず、Vantage でアクセス権を設定する必要があります。クリーンな状態を保つために、新しいデータベースを使用してこれを実行します。
--- Create a new database called sto
-CREATE DATABASE STO
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB
-
--- Allow dbc user to create scripts in database STO
-GRANT CREATE EXTERNAL PROCEDURE ON STO to dbc;以下のプロシージャ コールを使用して、スクリプトを Vantage にアップロードできます。
-call SYSUIF.install_file('helloworld',
- 'helloworld.py', 'cz!/tmp/helloworld.py');スクリプトがアップロードされたので、以下のように呼び出すことができます。
--- We switch to STO database
-DATABASE STO
-
--- We tell Vantage where to look for the script. This can be
--- any string and it will create a symbolic link to the directory
--- where our script got uploaded. By convention, we use the
--- database name.
-SET SESSION SEARCHUIFDBPATH = sto;
-
--- We now call the script. Note, how we use a relative path that
--- starts with `./sto/`, which is where SEARCHUIFDBPATH
--- is pointing.
-SELECT *
-FROM SCRIPT(
- SCRIPT_COMMAND('python3 ./sto/helloworld.py')
- RETURNS ('Message varchar(512)'));最後の呼び出しでは次が返されます。
-Message ------------- -Hello World! -Hello World!-
これは大変な作業でしたが、まだ Hello World に到達しています。SCRIPT にデータを渡してみましょう。
これまで、スタンドアロン スクリプトを実行するために SCRIPT オペレータを使用してきました。ただし、Vantage でスクリプトを実行する主な目的は、Vantage 内のデータを処理することです。Vantageからデータを取得して、SCRIPT に渡す方法を見てみましょう。
まず、数行のテーブルを作成します。
--- Switch to STO database.
-DATABASE STO
-
--- Create a table with a few urls
-CREATE TABLE urls(url varchar(10000));
-INS urls('https://www.google.com/finance?q=NYSE:TDC');
-INS urls('http://www.ebay.com/sch/i.html?_trksid=p2050601.m570.l1313.TR0.TRC0.H0.Xteradata+merchandise&_nkw=teradata+merchandise&_sacat=0&_from=R40');
-INS urls('https://www.youtube.com/results?search_query=teradata%20commercial&sm=3');
-INS urls('https://www.contrivedexample.com/example?mylist=1&mylist=2&mylist=...testing');以下のスクリプトを使用してクエリーパラメータを解析します。
-from urllib.parse import urlparse
-from urllib.parse import parse_qsl
-import sys
-
-for line in sys.stdin:
- # remove leading and trailing whitespace
- url = line.strip()
- parsed_url = urlparse(url)
- query_params = parse_qsl(parsed_url.query)
-
- for element in query_params:
- print("\t".join(element))スクリプトでは、URLが1行ずつ stdin に入力されると仮定していることに注記してください。また、値の間の区切り記号としてタブ文字を使用して、結果を 1 行ずつ出力する方法にも注目してください。
スクリプトをインストールしましょう。ここでは、スクリプト ファイルがローカル マシンの /tmp/urlparser.py にあると仮定します。
CALL SYSUIF.install_file('urlparser',
- 'urlparser.py', 'cz!/tmp/urlparser.py');スクリプトがインストールされたら、 urls テーブルからデータを取得し、それをスクリプトに入力してクエリーパラメータを取得します。
-- We inform Vantage to create a symbolic link from the UIF directory to ./sto/
-SET SESSION SEARCHUIFDBPATH = sto ;
-
-SELECT *
- FROM SCRIPT(
- ON(SELECT url FROM urls)
- SCRIPT_COMMAND('python3 ./sto/urlparser.py')
- RETURNS ('param_key varchar(512)', 'param_value varchar(512)'));その結果、クエリーパラメータとその値を取得します。行の数は、キーと値のペアの数と同じです。また、スクリプトで出力されるキーと値の間にタブを挿入したため、STO から 2 つの列が取得されます。
-param_key |param_value -------------+----------------------------------------------------- -q |NYSE:TDC -_trksid |p2050601.m570.l1313.TR0.TRC0.H0.Xteradata merchandise -search_query|teradata commercial -_nkw |teradata merchandise -sm |3 -_sacat |0 -mylist |1 -_from |R40 -mylist |2 -mylist |...testing-
Vantage からデータを取得し、それをスクリプトに渡して出力を取得する方法を学びました。この出力をテーブルに保存する簡単な方法はありますか? もちろん、あります。上記の 選択 を CREATE TABLE 文と組み合わせることができます。
-- We inform Vantage to create a symbolic link from the UIF directory to ./sto/
-SET SESSION SEARCHUIFDBPATH = sto ;
-
-CREATE MULTISET TABLE
- url_params(param_key, param_value)
-AS (
- SELECT *
- FROM SCRIPT(
- ON(SELECT url FROM urls)
- SCRIPT_COMMAND('python3 ./sto/urlparser.py')
- RETURNS ('param_key varchar(512)', 'param_value varchar(512)'))
-) WITH DATA
-NO PRIMARY INDEX;では、`url_params`テーブルの内容を検査してみましょう。
-SELECT * FROM url_params;以下の出力が表示されるはずです。
-param_key |param_value -------------+----------------------------------------------------- -q |NYSE:TDC -_trksid |p2050601.m570.l1313.TR0.TRC0.H0.Xteradata merchandise -search_query|teradata commercial -_nkw |teradata merchandise -sm |3 -_sacat |0 -mylist |1 -_from |R40 -mylist |2 -mylist |...testing-
このクイック スタートでは、Vantage のデータに対してスクリプトを実行する方法を学習しました。Script Table Operator (STO) を使用してスクリプトを実行しました。オペレータを使用すると、データにロジックを適用できます。スクリプトを AMP ごとに 1 つずつ並行して実行することで、同時並行性の考慮事項をデータベースにオフロードします。スクリプトを指定するだけで、データベースがそれを並行して実行します。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- 今回は、Teradata Vantage エンジン アーキテクチャの基礎となる概念について説明します。VantageCloud Lake のプライマリ クラスタを含む Vantage のすべてのエディションは、同じエンジンを利用します。
-Teradataのアーキテクチャは、超並列処理(MPP)、シェアードナッシングアーキテクチャを中心に設計されており、高性能なデータ処理と分析を可能にします。MPP アーキテクチャは、ワークロードを複数の vproc または仮想プロセッサに分散します。クエリー処理が行われる仮想プロセッサは、一般にアクセス モジュール プロセッサ (AMP) と呼ばれます。各 AMP は他の AMP から分離されており、クエリーを並行して処理するため、Teradata は大量のデータを迅速に処理できます。
-Teradata Vantage エンジンの主要なアーキテクチャ構成要素には、Parsing Engine (PE)、BYNET、アクセス モジュール プロセッサ (AMP)、および仮想ディスク (Vdisk) が含まれます。 Vdisk は、エンタープライズ プラットフォームの AMP に割り当てられ、VantageCloud Lake 環境の場合はプライマリ クラスタに割り当てられます。
-
-Teradata Vantage エンジンは、以下の構成要素で構成されています。
-SQL クエリーが Teradata で実行されると、まずParsing Engineに到達します。Parsing Engineの機能は以下のとおりです。
-個々のユーザー セッション (最大 120) を管理します。
-SQL クエリーで使用されているオブジェクトが存在するかどうかを確認します。
-ユーザーが SQL クエリーで使用されるオブジェクトに対して必要な権限を持っているかどうかを確認します。
-SQL クエリーを解析して最適化します。
-SQL クエリーを実行するための実行プランを準備し、それを対応する AMP に渡します。
-AMP から応答を受信し、それを要求元のクライアントに送り返します。
-BYNET は構成要素通信を可能にするシステムです。BYNET システムは、高速双方向ブロードキャスト、マルチキャスト、ポイント ツー ポイント通信およびマージ機能を提供します。マルチ AMP クエリーの調整、複数の AMP からのデータの読み取り、輻輳を防ぐためのメッセージ フローの調整、プラットフォームのスループットの処理という 3 つの主要な機能を実行します。BYNET のこれらの機能により、Vantage は非常にスケーラブルになり、超並列処理 (MPP) 機能が有効になります。
-並列データベース拡張機能 (PDE) は、オペレーティング システムと Teradata Vantage データベースの間に位置する中間ソフトウェア層です。PDE により、MPP システムは BYNET や共有ディスクなどの機能を使用できるようになります。これにより、Teradata Vantage データベースの速度と線形スケーラビリティを実現する並列処理が促進されます。
-AMP は、データの保存と取得を行います。各AMPは、データが格納される独自の仮想ディスク(Vdisk)セットに関連付けられており、他のAMPはシェアードナッシングアーキテクチャに従ってそのコンテンツにアクセスできません。AMP の機能は以下のとおりです。
-Vantage の Block File System ソフトウェアを使用してストレージにアクセスする
-ロックを管理する
-行の並べ替え
-列の集約
-結合処理
-出力変換
-ディスク領の管理
-アカウンティング
-リカバリ処理
-| - - | -
-
-
-VantageCore IntelliFlex、VantageCore VMware、VantageCloud Enterprise、および VantageCloud Lake の場合のプライマリ クラスタの AMP は、データをブロック ファイル システム (BFS) 形式で Vdisk に保存します。VantageCloud Lake 上のコンピューティング クラスタおよびコンピューティング ワーカー ノードの AMP には BFS がなく、オブジェクト ファイル システム (OFS) を使用してオブジェクト ストレージ内のデータにのみアクセスできます。 - |
-
以下の概念は Teradata Vantage に適用されます
-Teradata は、直線的に拡張可能な RDBMS です。ワークロードとデータ量が増加するにつれて、サーバーやノードなどのハードウェア リソースを追加すると、パフォーマンスと容量も比例して増加します。線形スケーラビリティにより、スループットを低下させることなくワークロードを増加できます。
-Teradata の並列処理とは、複数のノードまたは構成要素間で同時にデータとクエリーの並列処理を実行する Teradata Database の固有の機能を指します。
-Teradata の各Parsing Engine (PE) には、最大 120 のセッションを同時に処理する機能があります。
-Teradata の BYNET により、後続のタスクのデータ再配置を含む、すべてのメッセージ アクティビティの並列処理が可能になります。
-Teradata のすべてのアクセス モジュール プロセッサ (AMP) は、並行して連携して受信リクエストに対応できます。
-各 AMP は複数のリクエストを同時に処理できるため、効率的な並列処理が可能になります。
-
-Teradata Retrieval Architecture (取得アーキテクチャ)に含まれる主な手順は以下のとおりです。
-Parsing Engineは、1 つ以上の行を取得するリクエストを送信する。
-BYNETは、処理のために関連するAMPを活性化する。
-AMPは、並列アクセスを介して、目的の行を同時に見つけて検索する。
-BYNET は、取得した行をParsing Engineに返す。
-次に、Parsing Engineは、リクエスト元のクライアント アプリケーションに行を返す。
-
-Teradata の MPP アーキテクチャでは、データを分散および取得する効率的な手段が必要であり、これをハッシュ パーティショニングを使用して行います。Vantage のほとんどのテーブルは、ハッシュを使用して行のプライマリ インデックス (PI) の値に基づいてテーブルのデータをブロック ファイル システム (BFS) のディスク記憶装置に分散し、テーブル全体をスキャンしたり、インデックスを使用してデータにアクセスしたりする場合があります。このアプローチにより、スケーラブルなパフォーマンスと効率的なデータ アクセスが保証されます。
-プライマリ インデックスが一意である場合、テーブル内の行はハッシュ パーティション化によって自動的に均等に分散されます。
-指定されたプライマリ インデックス列はハッシュされ、同じ値に対して一貫したハッシュ コードが生成されます。
-再編成、再パーティション化、またはスペース管理は必要ありません。
-通常、各 AMP にはすべてのテーブルの行が含まれており、効率的なデータ アクセスと処理が保証されます。
-
-この記事では、Parsing Engines (PE)、BYNET、Access Module Processors (AMP)、Virtual Disk (Vdisk)などのTeradata Vantageの主要なアーキテクチャ コンポーネント、Parallel Database Extension(PDE)、Nodeなどのその他のアーキテクチャ コンポーネント、および線形拡張と拡張性、並列処理、データ取得、データ分散などのTeradata Vantageの基本的な概念について説明しました。
-
- このハウツーでは、Teradata Vantage 用の Python データベース ドライバ teradatasql を使用して Vantage に接続する方法を示します。
-64ビットPython 3.4以降。
-teradatasql システムにインストールされているドライバ:
pip install teradatasql| - - | -
-
-
-
|
-
Teradata Vantageインスタンスへのアクセス。現在、ドライバは Teradata Database 16.10 以降のリリースでの使用がサポートされています。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
これは、teradatasql を使用してTeradata Vantageに接続するための単純なPythonコードです。残っているのは、接続パラメータと認証パラメータを渡してクエリーを実行することだけです。
このハウツーでは、 teradatasql Python データベース ドライバを使用して Teradata Vantage に接続する方法を説明しました。 teradatasql を使用して SQL クエリーを Teradata Vantage に送信するサンプル Python コードについて説明しました。
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- | - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Google Cloud Platform で Vantage Express を実行する方法を説明します。Vantage Express には、完全に機能する Teradata SQL Engineが含まれています。
-| - - | --クラウドの使用料を支払いたくない場合は、VMware、VirtualBox、UTM を使用して Vantage Express をローカルにインストールできます。 - | -
Googleクラウドアカウント。
-gcloud コマンド ラインユーティリティがマシンにインストールされている。インストール手順はここで見つけることができます。https://cloud.google.com/sdk/docs/install
4 つの CPU と 8 GB の RAM、70 GB のバランス ディスクを備えた Ubuntu VM を作成します。以下のコマンドは、 us-central1 リージョンに VM を作成します。最高のパフォーマンスを得るには、 リージョンを最も近いリージョンに置き換えてください。サポートされているリージョンのリストについては、 Google Cloud リージョンのドキュメント をご覧ください。
Powershell で実行する。
-gcloud compute instances create teradata-vantage-express `
- --zone=us-central1-a `
- --machine-type=n2-custom-4-8192 `
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced `
- --enable-nested-virtualization `
- --tags=vegcloud compute instances create teradata-vantage-express \
- --zone=us-central1-a \
- --machine-type=n2-custom-4-8192 \
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced \
- --enable-nested-virtualization \
- --tags=vegcloud compute instances create teradata-vantage-express \
- --zone=us-central1-a \
- --machine-type=n2-custom-4-8192 \
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced \
- --enable-nested-virtualization \
- --tags=veVMにsshで接続する。
-gcloud compute ssh teradata-vantage-express --zone=us-central1-aroot ユーザーに切り替えます。
sudo -iVantage Express用のダウンロードディレクトリを準備する。
-mkdir /opt/downloads
-cd /opt/downloadsVirtualBoxと7 zipをインストールします。
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -ycurlコマンドを取得して、Vantage Expressをダウンロードします。
-Vantage Expess のダウンロード ページに移動します (登録が必要です)。
-「Vantage Express 17.20」などの最新のダウンロードリンクをクリックします。使用許諾契約のポップアップが表示されます。まだライセンスを受け入れません。
-ブラウザでネットワークビューを開きます。例えば、Chrome で F12 を押し「 Network」タブに移動します。
-`I Agree (同意する)`ボタンをクリックしてライセンスを受け入れ、ダウンロードをキャンセルします。
-ネットワーク ビューで、 `VantageExpress`で始まる最後のリクエストを見つけます。それを右クリックして `Copy → Copy as cURL`を選択します。
-
-ssh セッションに戻り、curl コマンドを貼り付けて Vantage Express をダウンロードします。ダウンロードを ve.7z という名前のファイルに保存するには、コマンドに -o ve.7z を追加します。次のように、すべてのHTTPヘッダーを削除できます。
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'ダウンロードしたファイルを解凍します。数分かかります。
-7z x ve.7zVirtualBox で VM を起動しますコマンドはすぐに返されますが、VM の初期化プロセスには数分かかります。
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cVantage Express VM に ssh で接続します。 root をパスワードとして使用します。
ssh -p 4422 root@localhostDBがアップしていることを確認します。
-pdestate -aコマンドが`PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent`を返す場合は、Vantage Expressが起動したことを意味します。
-状態が異なる場合は、正しいステータスが得られるまで pdestate -a を繰り返します。
Vantage Expressが起動して実行されたら、bteq クライアントのコマンドラインクライアントを起動します。BTEQ (「ビーテック」と発音) は、Teradata Database に SQL クエリーを送信するために使用される、汎用のコマンド ベースのクライアント ツールです。
bteqbteqに入ったら、Vantage Expressインスタンスに接続します。パスワードを求められたら、 `dbc`を入力します。
-.logon localhost/dbc`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/貼り付けて、Enter を押して実行します。
-CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VM を停止して起動する場合は、Vantage Express を自動起動に追加することをお勧めします。 VM に ssh で接続し、以下のコマンドを実行します。
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressインターネットからVantage Expressに接続したい場合は、VMに対してファイアウォールの穴を開ける必要がある。また、デフォルトのパスワードを dbc ユーザーに変更する必要がある。
dbc ユーザーのパスワードを変更するには、VM に移動して bteq を開始する。
bteqユーザー名とパスワードとして dbc を使用してデータベースにログインする。
.logon localhost/dbcdbc ユーザーのパスワードを変更する。
MODIFY USER dbc AS PASSWORD = new_password;gcloud コマンドを使用して、ポート 1025 をインターネットに開くことができるようになりました。
-gcloud compute firewall-rules create vantage-express --allow=tcp:1025 --direction=IN --target-tags=ve料金の発生を停止するには、VM を削除する。
-gcloud compute instances delete teradata-vantage-express --zone=us-central1-aまた、追加したファイアウォール ルールも忘れずに削除してください。例:
-gcloud compute firewall-rules delete vantage-express| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
-
- | - 探しているデモが見つかりませんでしたか? - | -- デモに貢献またはリクエストする - | -- request - contribute - | -
- これは、ClearScape Analytics ModelOps を初めてご利用になる方を対象としたハウツーです。このチュートリアルでは、ModelOpsで新しいプロジェクトを作成し、必要なデータをVantageにアップロードし、BYOMメカニズムを使用してインポートしたDiabetesデモモデルのライフサイクルを完全に追跡することができます。
-Teradata VantageインスタンスとClearScape Analytics（ModelOpsを含む）へのアクセス。
-Jupyter Notebookを実行する機能
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
必要なファイル
-まず、このチュートリアルに必要なファイルをダウンロードすることから始めましょう。これら4つの添付ファイルをダウンロードし、Notebookのファイルシステムにアップロードしてください。ModelOpsのバージョンに応じてファイルを選択します。
-ModelOpsバージョン6 (2022 年 10 月):
-または、以下のレポをgit cloneしてください。
-git clone https://github.com/willfleury/modelops-getting-started
-git clone https://github.com/Teradata/modelops-demo-models/ModelOpsバージョン7 (2023 年 4 月):
-git clone -b v7 https://github.com/willfleury/modelops-getting-started.git -git clone https://github.com/Teradata/modelops-demo-models/-
データベースと Jupyter 環境のセットアップ
-ModelOps_Training Jupyter Notebookに従って、デモに必要なデータベース、テーブル、ライブラリのセットアップを行います。
-新しいプロジェクトを追加する
-プロジェクトを作成する
-詳細
-名前: Demo: your-name
-説明: ModelOps Demo
-グループ: your-name
-信頼証明: 信頼証明なし
-ブランチ: master
-ここで git 接続をテストできます。緑色の場合は、保存して続行します。ここではサービス接続設定をスキップします。
-新しいプロジェクトを作成するとき、ModelOpsは新しい接続をリクエストします。
-パーソナル接続
-名前: Vantage personal your-name
-説明: Vantage デモ環境
-ホスト: tdprd.td.teradata.com (teradata transcendの内部のみ)
-データベース: your-db
-VAL データベース: TRNG_XSP (teradata transcendの内部のみ)
-BYOM データベース: TRNG_BYOM (teradata transcendの内部のみ)
-ログインメカニズム: TDNEGO
-ユーザー名/パスワード
-新しいデータセット テンプレートを作成してから、トレーニング用に 1 つのデータセット、評価用に 2 つのデータセットを作成して、2 つの異なるデータセットでモデルの品質メトリクスを監視できるようにしましょう。
-データセットの追加
-データセットテンプレートの作成
-カタログ
-名前: PIMA
-説明: PIMA Diabetes
-フィーチャカタログ: Vantage
-データベース: your-db
-テーブル: aoa_feature_metadata
-フィーチャ -クエリー:
-
-
-SELECT * FROM {your-db}.pima_patient_featuresエンティティ キー: PatientId -フィーチャ: NumTimesPrg、PlGlcConc、BloodP、SkinThick、TwoHourSerIns、BMI、DiPedFunc、Age
-エンティティとターゲット -クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnosesエンティティキー: PatientId -Target: HasDiabetes
-予測
-データベース: your-db
-表:pima_patient_predictions
-エンティティの選択:
-クエリー:
-SELECT * FROM pima_patient_features WHERE patientid MOD 5 = 0v6のみ(v7では、これをBYOMのコードなし画面で定義する):BYOMターゲットカラム:CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes')AS INT)
-ベーシック
-名前: トレーニング
-説明: トレーニングデータセット
-スコープ: トレーニング
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 1ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 2ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 3必要なファイルをダウンロードして解凍します。リンクはチュートリアルの上部にあります。PMML ファイルについては、GIT モデルのトレーニングで生成された PMML をダウンロードすることもできます。
-BYOM.ipynb
-model.pmml
-requirements.txt
-evaluation.py
-data_stats.json
-init.py
-評価と監視による BYOM モデルの定義
-インポートバージョン
-v7 の場合 - BYOM コードは使用できません - 自動評価とデータ ドリフト監視を有効にすることができます。 -Monitoring ページで、BYOM ターゲット列を使用します。 CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes') AS INT)
-評価する
-データセット統計を含む評価レポートを確認する
-承認する
-Vantage でのデプロイ - エンジン、パブリッシュ、スケジュール。スコアリング データセットが必要です。 -接続を使用してデータベースを選択してください。例: "aoa_byom_models"
-デプロイメント/実行
-dataset2 を使用して再度評価します - モデル メトリクスの動作を監視します
-モデルドリフトの監視 - データとメトリクス
-v7 の場合 - Deployments → Job ページから予測を直接確認します。
-BYOM Notebookを開き、SQL コードから PMML 予測を実行します。
-リタイアする
-このクイックスタートではBYOMモデルの完全なライフサイクルをModelOpsで実行する方法とそれをVantageにデプロイする方法について学びました。そしてバッチスコアリング、レストフルまたはオンデマンドスコアリングのテスト、データドリフトとモデル品質メトリックのモニタリングの開始をスケジュールする方法を紹介しました。
-リンク:https://docs.teradata.com/search/documents?query=ModelOps&sort=last_update&virtual-field=title_only&content-lang=
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- これは、ClearScape Analytics ModelOps を初めてご利用になる方を対象としたハウツーです。このチュートリアルでは、ModelOpsで新しいプロジェクトを作成し、必要なデータをVantageにアップロードし、コードテンプレートを使用してModelOpsのGITモデルの方法論に従ってデモモデルのライフサイクルを完全に追跡することができるようになります。
-Teradata VantageインスタンスとClearScape Analytics（ModelOpsを含む）へのアクセス。
-Jupyter Notebookを実行する機能
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
必要なファイル
-まず、このチュートリアルに必要なファイルをダウンロードすることから始めましょう。これら4つの添付ファイルをダウンロードし、Notebookのファイルシステムにアップロードしてください。ModelOpsのバージョンに応じてファイルを選択します。
-ModelOpsバージョン6(2022年10月):
-または、以下のレポをgit cloneしてください。
-git clone https://github.com/willfleury/modelops-getting-started
-git clone https://github.com/Teradata/modelops-demo-models/ModelOpsバージョン7 (2023 年 4 月):
-git clone -b v7 https://github.com/willfleury/modelops-getting-started.git -git clone https://github.com/Teradata/modelops-demo-models/-
データベースとJupyter環境のセットアップ
-ModelOps_Training Jupyter Notebook に従って、デモに必要なデータベース、テーブル、ライブラリのセットアップを行います。
-新しいプロジェクトを追加する
-プロジェクトを作成する
-詳細
-名前: Demo: your-name
-説明: ModelOps Demo
-グループ: your-name
-信頼証明: 信頼証明なし
-ブランチ: master
-ここで git 接続をテストできます。緑色の場合は、保存して続行します。ここではサービス接続設定をスキップします。
-新しいプロジェクトを作成するとき、ModelOpsは新しい接続をリクエストします。
-パーソナル接続
-名前: Vantage personal your-name
-説明: Vantage デモ環境
-ホスト: tdprd.td.teradata.com (teradata transcendの内部のみ)
-データベース: your-db
-VAL データベース: TRNG_XSP (teradata transcendの内部のみ)
-BYOM データベース: TRNG_BYOM (teradata transcendの内部のみ)
-ログインメカニズム: TDNEGO
-ユーザー名/パスワード
-新しいデータセット テンプレートを作成してから、トレーニング用に 1 つのデータセット、評価用に 2 つのデータセットを作成して、2 つの異なるデータセットでモデルの品質メトリクスを監視できるようにしましょう。
-データセットの追加
-データセットテンプレートの作成
-カタログ
-名前: PIMA
-説明: PIMA Diabetes
-フィーチャカタログ: Vantage
-データベース: your-db
-テーブル: aoa_feature_metadata
-フィーチャ -クエリー:
-
-SELECT * FROM {your-db}.pima_patient_featuresエンティティ キー: PatientId -フィーチャ: NumTimesPrg、PlGlcConc、BloodP、SkinThick、TwoHourSerIns、BMI、DiPedFunc、Age
-エンティティとターゲット -クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnosesエンティティキー: PatientId -Target: HasDiabetes
-予測
-データベース: your-db
-表:pima_patient_predictions
-エンティティの選択:
-クエリー:
-SELECT * FROM pima_patient_features WHERE patientid MOD 5 = 0v6のみ(v7では、これをBYOMのコードなし画面で定義する):BYOMターゲットカラム:CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes')AS INT)
-ベーシック
-名前: トレーニング
-説明: トレーニングデータセット
-スコープ: トレーニング
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 1ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 2ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 3Gitモデルでは、新しいモデルを追加するときに使用可能なコードテンプレートを入力する必要があります。
-これらのコードスクリプトは、gitリポジトリのmodel_definitions/your-model/model_modules/に保存されます。
-init.py: これはPythonモジュールに必要な空のファイルです
-training.py: このスクリプトには train 関数が含まれています
-def train(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # your training code
-
- # save your model
- joblib.dump(model, f"{context.artifact_output_path}/model.joblib")
-
- record_training_stats(...)Operationalize Notebookを参照して、ModelOps UI の代替として CLI またはNotebookからこれを実行する方法を確認してください。
-evaluation.py:このスクリプトには評価関数が含まれています
-def evaluate(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # read your model
- model = joblib.load(f"{context.artifact_input_path}/model.joblib")
-
- # your evaluation logic
-
- record_evaluation_stats(...)Operationalize Notebookを参照して、ModelOps UI の代わりに CLI またはNotebookからこれを実行する方法を確認してください。
-scoring.py: このスクリプトにはスコア関数が含まれています
-def score(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # read your model
- model = joblib.load(f"{context.artifact_input_path}/model.joblib")
-
- # your evaluation logic
-
- record_scoring_stats(...)Operationalize Notebookを参照して、ModelOps UI の代替として CLI またはNotebookからこれを実行する方法を確認してください。
-requirements.txt:このファイルには、コードスクリプトに必要なライブラリ名とバージョンが含まれています。例:
-%%writefile ../model_modules/requirements.txt
-xgboost==0.90
-scikit-learn==0.24.2
-shap==0.36.0
-matplotlib==3.3.1
-teradataml==17.0.0.4
-nyoka==4.3.0
-aoa==6.0.0config.json: 親フォルダ (モデルフォルダ) にあるこのファイルには、デフォルトのハイパーパラメータが含まれています
-%%writefile ../config.json
-{
- "hyperParameters": {
- "eta": 0.2,
- "max_depth": 6
- }
-}リポジトリにあるデモモデルのコードスクリプトを確認します。 https://github.com/Teradata/modelops-demo-models/
-model_definitions→python-diabetes→model_modulesに移動します。
-プロジェクトを開いて、GIT から利用可能なモデルを確認する
-新しいモデルのバージョンをトレーニングする
-コードリポジトリからのCommitIDがどのように追跡されているかを確認する
-評価する
-データセットの統計情報やモデルのメトリクスを含む評価レポートを確認する
-他のモデルバージョンと比較する
-承認する
-Vantage でデプロイする - エンジン、パブリッシュ、スケジュール。スコアリング データセットが必要です。 -接続を使用してデータベースを選択してください。例: "aoa_byom_models"
-Docker Batch でデプロイする - エンジン、パブリッシュ、スケジュール。スコアリング データセットが必要です。 -接続を使用してデータベースを選択してください。例: "aoa_byom_models"
-Restful Batchでデプロイする - エンジン、パブリッシュ、スケジュール。スコアリング データセットが必要です。 -接続を使用してデータベースを選択してください。例: "aoa_byom_models"
-デプロイメント/実行する
-dataset2 を使用して再度評価する - モデル メトリクスの動作を監視します
-Model Driftを監視する - データとメトリクス
-Vantage にデプロイされている場合、BYOM Notebookを開いて、SQL コードから PMML 予測を実行します。
-ModelOps UIまたはcurlコマンドからRestfulをテストする
-デプロイメントをリタイアする
-このクイック スタートでは、GIT モデルのライフサイクル全体をたどって ModelOps にデプロイメントする方法と、GIT モデルを Edge デプロイメント用の Vantage または Dockerコンテナにデプロイする方法を学びました。次に、バッチ スコアリングをスケジュールしたり、レストフル スコアリングまたはオンデマンド スコアリングをテストしたり、データ ドリフトとモデル品質のメトリクスの監視を監視したりする方法を説明します。
-リンク:https://docs.teradata.com/search/documents?query=ModelOps&sort=last_update&virtual-field=title_only&content-lang=
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
新しいプロジェクトを追加する
-プロジェクトを作成する
-詳細
-名前: Demo: your-name
-説明: ModelOps Demo
-グループ: your-name
-信頼証明: 信頼証明なし
-ブランチ: master
-ここで git 接続をテストできます。緑色の場合は、保存して続行します。ここではサービス接続設定をスキップします。
-新しいプロジェクトを作成するとき、ModelOpsは新しい接続をリクエストします。
-パーソナル接続
-名前: Vantage personal your-name
-説明: Vantage デモ環境
-ホスト: tdprd.td.teradata.com (teradata transcendの内部のみ)
-データベース: your-db
-VAL データベース: TRNG_XSP (teradata transcendの内部のみ)
-BYOM データベース: TRNG_BYOM (teradata transcendの内部のみ)
-ログインメカニズム: TDNEGO
-ユーザー名/パスワード
-新しいデータセット テンプレートを作成してから、トレーニング用に 1 つのデータセット、評価用に 2 つのデータセットを作成して、2 つの異なるデータセットでモデルの品質メトリクスを監視できるようにしましょう。
-データセットの追加
-データセットテンプレートの作成
-カタログ
-名前: PIMA
-説明: PIMA Diabetes
-フィーチャカタログ: Vantage
-データベース: your-db
-テーブル: aoa_feature_metadata
-フィーチャ -クエリー:
-
-SELECT * FROM {your-db}.pima_patient_featuresエンティティ キー: PatientId -フィーチャ: NumTimesPrg、PlGlcConc、BloodP、SkinThick、TwoHourSerIns、BMI、DiPedFunc、Age
-エンティティとターゲット -クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnosesエンティティキー: PatientId -Target: HasDiabetes
-予測
-データベース: your-db
-表:pima_patient_predictions
-エンティティの選択:
-クエリー:
-SELECT * FROM pima_patient_features WHERE patientid MOD 5 = 0v6のみ(v7では、これをBYOMのコードなし画面で定義する):BYOMターゲットカラム:CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes')AS INT)
-ベーシック
-名前: トレーニング
-説明: トレーニングデータセット
-スコープ: トレーニング
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 1ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 2ベーシック
-名前: Evaluate
-説明: Evaluate データセット
-スコープ: Evaluation
-エンティティとターゲット
-クエリー:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 3Feast の Teradata 用コネクタは、すべての機能をサポートする完全な実装であり、Teradata Vantage をオンラインおよびオフライン ストアとして使用します。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
このハウツーでは、feastの用語をご存知であることを前提に説明しています。復習が必要な場合は、 FEAST ドキュメント
- をご覧ください。
-このドキュメントは、開発者が Teradataのオフラインおよびオンライン ストア をFeastに統合する方法を説明します。Teradataのオフラインストアにより、ユーザーは任意のデータストアをオフラインフィーチャーストアとして使用することができます。モデル学習のためにオフラインストアからフィーチャーを取得し、モデル推論時に使用するためにオンラインフィーチャーストアに実体化させることができます。
一方、オンラインストアは、低レイテンシーで機能を提供するために使用されます。 materialize コマンドは、データソース（またはオフラインストア）からオンラインストアに特徴量をロードするために使用されます。
`feast-teradata` ライブラリは、Teradata のサポートを以下のように追加します。-
オフラインストア
オンラインストア
さらに、レジストリ(カタログ)としてTeradataを使用することは、registry_type: sql を介して既にサポートされており、我々のサンプルに含まれています。これは、すべてがTeradataに配置されることを意味します。しかし、要件やインストールなどによっては、他のシステムと適宜混在させることが可能です。
まず、 feast-teradata ライブラリをインストールします。
pip install feast-teradata標準ドライバのデータセットを使用して、Teradataとの簡単なfeast設定を作成してみましょう。feast init は、feastコアライブラリの一部であるテンプレートに対してのみ機能するため、使用できないことに注記してください。このライブラリはいずれfeast coreにマージされる予定ですが、今のところ、この特定のタスクには次のcliコマンドを使用する必要があります。その他の`feast` cli コマンドは期待通りに動作します。
feast-td init-repoすると、Teradataシステムの必要な情報を入力するプロンプトが表示され、サンプルデータセットがアップロードされます。上記のコマンドを実行する際に、レポ名 demo を使用したと仮定します。リポジトリ ファイルと、 test_workflow.py というファイルが表示されます。この test_workflow.py を実行すると、Teradataをレジストリ、OfflineStore、OnlineStoreとして、饗宴のための完全なワークフローが実行されます。
demo/
- feature_repo/
- driver_repo.py
- feature_store.yml
- test_workflow.py`demo/feature_repo` ディレクトリから、以下の feast コマンドを実行して、レポ定義をレジストリに適用（import/update）してください。このコマンドを実行すると、teradataデータベースのレジストリのメタデータテーブルを確認することができます。-
feast applyレジストリ情報をfeast UIで見るには、以下のコマンドを実行します。デフォルトでは5秒ごとにポーリングするので、--registry_ttl_secが重要であることに注記してください。
-feast ui --registry_ttl_sec=120project: <name of project>
-registry: <registry>
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <db host>
- database: <db name>
- user: <username>
- password: <password>
- log_mech: <connection mechanism>以下はdefinition.pyの例で、エンティティ、ソースコネクタ、 -フィーチャービューの設定方法を詳しく説明しています。
-次に、それぞれのコンポーネントを説明します。
-TeradataSource。 Teradata (Enterprise または Lake) に格納された機能、または Teradata (NOS, QueryGrid) からの外部テーブルを介してアクセス可能な機能のデータソース
エンティティ。 意味的に関連するフィーチャーの集合体
フィーチャー ビュー: フィーチャー ビューは、特定のデータソースからのフィーチャーデータのグループです。フィーチャー ビューにより、フィーチャーとそのデータソースを一貫して定義できるため、プロジェクト全体でフィーチャー グループを再利用できる。
driver = Entity(name="driver", join_keys=["driver_id"])
-project_name = yaml.safe_load(open("feature_store.yaml"))["project"]
-
-driver_stats_source = TeradataSource(
- database=yaml.safe_load(open("feature_store.yaml"))["offline_store"]["database"],
- table=f"{project_name}_feast_driver_hourly_stats",
- timestamp_field="event_timestamp",
- created_timestamp_column="created",
-)
-
-driver_stats_fv = FeatureView(
- name="driver_hourly_stats",
- entities=[driver],
- ttl=timedelta(weeks=52 * 10),
- schema=[
- Field(name="driver_id", dtype=Int64),
- Field(name="conv_rate", dtype=Float32),
- Field(name="acc_rate", dtype=Float32),
- Field(name="avg_daily_trips", dtype=Int64),
- ],
- source=driver_stats_source,
- tags={"team": "driver_performance"},
-)オフラインストアのテストには、以下に説明するように2種類の方法があります。しかし、その前に、いくつかの必須ステップがあります。
-では、過去 60 日間にイベントを見たことのあるエンティティ（母集団）のみを使って、学習用の素性を一括して読み込んでみましょう。使用する述語（フィルタ）は、与えられた学習用データセットのエンティティ（母集団）選択に関連するものであれば何でも構いません。event_timestamp は例示のためだけのものです。
from feast import FeatureStore
-store = FeatureStore(repo_path="feature_repo")
-training_df = store.get_historical_features(
- entity_df=f"""
- SELECT
- driver_id,
- event_timestamp
- FROM demo_feast_driver_hourly_stats
- WHERE event_timestamp BETWEEN (CURRENT_TIMESTAMP - INTERVAL '60' DAY) AND CURRENT_TIMESTAMP
- """,
- features=[
- "driver_hourly_stats:conv_rate",
- "driver_hourly_stats:acc_rate",
- "driver_hourly_stats:avg_daily_trips"
- ],
-).to_df()
-print(training_df.head())`feast-teradata`ライブラリを使用すると、豊富なAPIと機能の完全なセットを使用することができます。できることの詳細については、公式のfeastの クイックスタート を参照してください。
-Feastは、モデル推論時に低レイテンシーで検索できるように、データをオンラインストアに実体化します。一般に、オンラインストアにはKey-Valueストアが使用されますが、リレーショナルデータベースもこの目的に使用することができます。
-OnlineStoreクラスのコントラクトを実装したクラスを作成することで、ユーザは独自のオンラインストアを開発することができます。
-project: <name of project>
-registry: <registry>
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <db host>
- database: <db name>
- user: <username>
- password: <password>
- log_mech: <connection mechanism>オンラインストアをテストする前に、いくつか必須の手順があります。
-materialize_incremental コマンドは、オンラインストアの機能を徐々にマテリアライズドするために使用されます。追加する新しい特徴がない場合、このコマンドは基本的に何も行いません。feast `materialize_incremental`では、開始時間はnow-ttl(フィーチャビューで定義したttl)または最新の実体化の時間のいずれかです。少なくとも一度でも機能をマテリアライズしていれば、それ以降のマテリアライズは、前回のマテリアライズの時点でストアに存在しなかった機能のみをフェッチすることになります。
CURRENT_TIME=$(date +'%Y-%m-%dT%H:%M:%S')
-feast materialize-incremental $CURRENT_TIME次に、オンライン機能を取得する際に、features と entity_rows の2つのパラメータを用意します。 features パラメータはリストで、df_feature_view に存在する特徴を任意の数だけ取ることができます。上の例では、4つの特徴しかありませんが、4つ以下でもかまいません。次に、 entity_rows パラメータもリストで、{feature_identifier_column: value_to_be_fetched} という形式のディクショナリーを取ります。この場合、driver_id列は、エンティティドライバの異なる行を一意に識別するために使用されます。現在、driver_idが5に等しいフィーチャーの値をフェッチしています。また、このような行を複数取得することもできます。 [{driver_id: val_1}, {driver_id: val_2}, .., {driver_id: val_n}] [{driver_id: val_1}, {driver_id: val_2}, .., {driver_id: val_n}]
entity_rows = [
- {
- "driver_id": 1001,
- },
- {
- "driver_id": 1002,
- },
- ]
-features_to_fetch = [
- "driver_hourly_stats:acc_rate",
- "driver_hourly_stats:conv_rate",
- "driver_hourly_stats:avg_daily_trips"
- ]
-returned_features = store.get_online_features(
- features=features_to_fetch,
- entity_rows=entity_rows,
-).to_dict()
-for key, value in sorted(returned_features.items()):
- print(key, " : ", value)もう一つ重要なのは、SQLレジストリです。まず、ユーザー名、パスワード、データベース名などを使って接続文字列を作るパス変数を作り、それを使ってTeradataのDatabaseへの接続を確立しています。
-path = 'teradatasql://'+ teradata_user +':' + teradata_password + '@'+host + '/?database=' + teradata_database + '&LOGMECH=' + teradata_log_mechこれにより、データベースに以下のようなテーブルが作成されます。
-Entities (entity_name,project_id,last_updated_timestamp,entity_proto)
-Data_sources (data_source_name,project_id,last_updated_timestamp,data_source_proto)
-Feature_views (feature_view_name,project_id,last_updated_timestamp,materialized_intervals,feature_view_proto,user_metadata)
-Request_feature_views (feature_view_name,project_id,last_updated_timestamp,feature_view_proto,user_metadata)
-Stream_feature_views (feature_view_name,project_id,last_updated_timestamp,feature_view_proto,user_metadata)
-managed_infra (infra_name, project_id, last_updated_timestamp, infra_proto)
-validation_references (validation_reference_name, project_id, last_updated_timestamp, validation_reference_proto)
-saved_datasets (saved_dataset_name, project_id, last_updated_timestamp, saved_dataset_proto)
-feature_services (feature_service_name, project_id, last_updated_timestamp, feature_service_proto)
-on_demand_feature_views (feature_view_name, project_id, last_updated_timestamp, feature_view_proto, user_metadata)
-さらに、完全な（しかし実世界ではない）、エンドツーエンドのワークフローの例を見たい場合は、demo/test_workflow.py スクリプトを参照してください。これは、完全な饗宴の機能をテストするために使用されます。
Enterprise Feature Store は、データ分析の重要な段階で価値を獲得するプロセスを加速します。生産性が向上し、製品を市場にデプロイメントするまでの時間が短縮されます。Teradataとfeastを統合することで、Teradataの高効率な並列処理をFeature Store内で利用できるようになり、パフォーマンスの向上が期待されます。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このハウツーでは、DataHub を使用して Teradata Vantage への接続を作成し、テーブルとビューに関するメタデータを使用状況と系統情報とともに取り込む方法を示します。
-Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
DataHubがインストールされている。 DataHubクイックスタートガイド - を参照してください。 -== DataHubの設定
-DataHubがインストールされている環境にDataHub用のTeradataプラグインをインストールする
-pip install 'acryl-datahub[teradata]'Teradataユーザーを設定し、そのユーザーがディクショナリ テーブルを読み取ることができるように権限を設定する
-CREATE USER datahub FROM <database> AS PASSWORD = <password> PERM = 20000000;
-
-GRANT SELECT ON dbc.columns TO datahub;
-GRANT SELECT ON dbc.databases TO datahub;
-GRANT SELECT ON dbc.tables TO datahub;
-GRANT SELECT ON DBC.All_RI_ChildrenV TO datahub;
-GRANT SELECT ON DBC.ColumnsV TO datahub;
-GRANT SELECT ON DBC.IndicesV TO datahub;
-GRANT SELECT ON dbc.TableTextV TO datahub;
-GRANT SELECT ON dbc.TablesV TO datahub;
-GRANT SELECT ON dbc.dbqlogtbl TO datahub; -- if lineage or usage extraction is enabledプロファイリングを実行する場合は、プロファイリングするすべてのテーブルに対する選択権限を付与する必要があります。
-Lineageまたは使用状況のメタデータを抽出する場合は、クエリー ログを有効にし、クエリーに適したサイズに設定する必要があります (Teradata がキャプチャするデフォルトのクエリー テキスト サイズは最大 200 文字です)。すべてのユーザーに対して設定する方法の例 :
--- set up query logging on all
-
-REPLACE QUERY LOGGING LIMIT SQLTEXT=2000 ON ALL;DataHubが実行されている状態で、DataHub GUIを開き、ログインします。 この例では、localhost:9002 で実行されています。
-インジェストプラグアイコンをクリックして、新しい接続ウィザードを開始します。
-
-「Create new source」を選択します。
-
-使用可能なソースのリストをスクロールし、[Other]を選択します。
-
-Teradata への接続を構成し、テーブルと列の系統をキャプチャするか、データのプロファイリングを行うか、使用統計を取得するかなど、必要なオプションを定義するには、Recipeが必要です。 以下は、簡単なRecipeです。ホスト、ユーザー名、パスワードは環境に合わせて変更する必要があります。
-pipeline_name: my-teradata-ingestion-pipeline
-source:
- type: teradata
- config:
- host_port: "myteradatainstance.teradata.com:1025"
- username: myuser
- password: mypassword
- #database_pattern:
- # allow:
- # - "my_database"
- # ignoreCase: true
- include_table_lineage: true
- include_usage_statistics: true
- stateful_ingestion:
- enabled: trueRecipeをウィンドウに貼り付けると、次のようになります。
-
-[Next]をクリックして、必要なスケジュールを設定します。
-
-[Next]をクリックして[Finish Up]を選択し、接続に名前を付けます。[Advanced]をクリックして、正しい CLI バージョンを設定できるようにします。DataHub による Teradata のサポートは、CLI 0.12.x で利用可能になりました。 最適な互換性を確保するには、最新バージョンを選択することをお勧めします。
-
-新しいソースを保存したら、「Run」をクリックして手動で実行できます。
-
-実行が成功した後に「Succeeded」をクリックすると、これと同様のダイアログが表示され、DataHub に取り込まれたデータベース、テーブル、ビューが表示されます。
-
-GUI で以下を参照してメタデータを探索できるようになりました。
-DataSets は、ロードされたデータセット (テーブルとビュー) のリストを提供します。
-
-データベースから取得されたエンティティ
-
-列/フィールド名、データ型、およびキャプチャされている場合の使用法を示すエンティティのスキーマ
-
-Lineageは、テーブルとビューの間でデータがどのようにリンクされているかを視覚的に表現します。
-
-このハウツーでは、テーブル、ビューのメタデータをリネージおよび使用統計とともにキャプチャするために、DataHub を使用して Teradata Vantage への接続を作成する方法を説明しました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
DBeaverがインストールされていること。インストール方法については、DBeaver Community または DBeaver PRO を参照してください。
-アプリケーション ウィンドウの左上隅にあるプラグ アイコン (
) をクリックして、新しい接続ウィザードを開始するか、 Database → New Database Connection に移動します。
Select your database 画面で teradata と入力し、Teradataアイコンを選択します。
-メインタブでは、すべてのプライマリ接続設定を設定する必要があります。必要なものには、Host、Port、Database、Username、および Password があります。
| - - | -
-Teradata Vantageでは、ユーザが作成されると、それに対応するデータベースも作成されます。DBeaver では、データベースに接続する必要があります。接続先のデータベースがわからない場合は、database フィールドにユーザー名を入力します。
- |
-
| - - | -
-DBeaver PRO を使用すると、テーブルの標準的な順序を使用できるだけでなく、テーブルを特定のデータベースまたはユーザーに階層的にリンクすることもできます。データベースまたはユーザーをデプロイしたり折りたたんだりすると、データベース ナビゲータ ウィンドウをいっぱいにすることなく、あるリージョンから別のリージョンに移動できるようになります。この設定を有効にするには、 Show databases and users hierarchically ボックスをオンにします。
- |
-
| - - | --多くの環境では、Teradata Vantage には TLS プロトコルを使用してのみアクセスできます。DB aver PROでは、`Use TLS protocol`オプションをチェックしてTLSを有効にする。 - | -
-Finish をクリックします。
データベースに直接アクセスできない場合は、SSH トンネルを使用できます。すべての設定は、SSH タブで利用できます。DBeaver は、ユーザー/パスワード、公開キー、SSH エージェント認証の認証方法をサポートしています。
-このハウツーでは、DBeaver を使用して Teradata Vantage への接続を作成する方法を説明しました。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このチュートリアルでは、Airflow を AWS EC2 VM にインストールし、dbt を使用するようにワークフローを構成し、Teradata Vantage データベースに対して実行する方法を示します。Airflowは、データを処理しロードするためのデータパイプラインを構築するために通常使用されるタスクスケジューリングツールです。この例ではDockerベースのAirflow環境を作成するAirflowのインストールプロセスを実行します。Airflowをインストールしたら、Teradata VantageデータベースにデータをロードするAirflow DAG（Direct Acyclic Graph、または単にワークフロー）の例をいくつか実行します。
-AWS（Amazon Web Services）にアクセスしVMを作成するための権限を持つこと
-| - - | --このチュートリアルは、このドキュメントで紹介したマシン（AWS上のt2.2xlarge EC2、ストレージは約100GB）と同等の計算能力とストレージを持ち、インターネットに接続されていれば、他の計算プラットフォームやベアメタルマシンでも調整することが可能です。もし、別の計算機プラットフォームを使用する場合は、チュートリアルのいくつかのステップを変更する必要があります。 - | -
SSHクライアントが必要です。
- -Teradata Vantageインスタンスにアクセスする必要があります。Teradata Vantage をご利用でない場合は、開発者向けの無償版である Vantage Express を探索してください。
-AWS EC2コンソールに移動し、`Launch instance`をクリックします。
-オペレーティングシステムイメージの`Red Hat`を選択します。
-インスタンスタイプは t2.2xlarge を選択します。
新しいキー ペアを作成するか、既存のキー ペアを使用します。
-ネットワーク設定を適用して、サーバーにsshでアクセスできるようにし、サーバーがインターネットにアウトバウンド接続できるようにします。通常、デフォルトの設定を適用します。
-100 GBのストレージを割り当てます。
-`ec2-user`ユーザーを使用してマシンにsshします。
-pythonがインストールされているか確認します（Python3.7以上である必要があります）。コマンド ラインから python または python3 入力してください。
Python がインストールされていない場合 ( コマンドが見つからない というメッセージが出る場合)は、以下のコマンドを実行してインストールします。コマンドは、 y と入力してインストールを確認するようリクエストする場合があります。
sudo yum install python3
-# create a virtual environment for the project
-sudo yum install python3-pip
-sudo pip3 install virtualenvAirflowディレクトリ構造を作成します(ec2-userホームディレクトリ/home/ec2-userから)
-mkdir airflow
-cd airflow
-mkdir -p ./dags ./logs ./plugins ./data ./config ./data
-echo -e "AIRFLOW_UID=$(id -u)" > .envお好みのファイル転送ツール ( scp、 PuTTY、 MobaXterm など) を使用して、 airflow.cfg ファイルを airflow/config ディレクトリにアップロードします。
Dockerはコンテナ化ツールであり、Airflowをコンテナ環境にインストールすることができます。
-| - - | -
-手順は、airflow ディレクトリで実行する必要があります。
- |
-
podman (RHELのコンテナ化ツール)をアンインストールします。
-sudo yum remove docker \
-docker-client \
-docker-client-latest \
-docker-common \
-docker-latest \
-docker-latest-logrotate \
-docker-logrotate \
-docker-engine \
-podman \
-runcyumユーティリティをインストールします。
-sudo yum install -y yum-utilsDockerを yum リポジトリに追加します。
-sudo yum-config-manager \
---add-repo \
-https://download.docker.com/linux/centos/docker-ce.repoDockerをインストールします。
-sudo yum install docker-ce docker-ce-cli containerd.ioサービスとしてDockerを起動します。最初のコマンドは、次回システムが起動するときにDockerサービスを自動的に実行します。2 番目のコマンドはDockerを起動します。
-sudo systemctl enable docker
-sudo systemctl start dockerDockerが正しくインストールされているかどうかを確認します。このコマンドは、コンテナの空のリストを返すはずです (まだコンテナを開始していないため)。
-sudo docker psdocker-compose とDocker環境設定ファイルのインストールdocker-compose.yaml と Dockerfile ファイルを VM にアップロードし、 airflow ディレクトリに保存します。
| - - | -
- 「docker-compose.yaml」と「Dockerfile」の機能
-
-
-
-
-
-
-`docker-compose.yaml` と `Dockerfile` が何をするファイルなのか、もっと詳しく知りたい方はこれらのファイルをご覧ください。何がなぜインストールされるのかを明確にするためのコメントもあります。- |
-
docker-composeをインストールします(yamlファイルを実行するために必要)。
-| - - | --この手順は、バージョン 1.29.2 に基づいています。最新のリリースは https://github.com/docker/compose/releases で確認し、必要に応じて以下のコマンドを更新してください。 - | -
sudo curl -L https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
-sudo chmod +x /usr/local/bin/docker-compose
-sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-composedocker-composeのインストールをテストします。このコマンドは、docker-composeバージョンを返す必要があります。たとえば、docker-compose version 1.29.2, build 5becea4c:
docker-compose --version| - - | -
-これらの手順では、サンプル dbt プロジェクトをセットアップします。 dbt ツール自体は、後で `docker-compose`によってコンテナにインストールされます。
- |
-
gitをインストールします。
-sudo yum install gitjaffle shop の dbt プロジェクトのサンプルを入手します。
-| - - | -
-dbt ディレクトリは、ホーム ディレクトリの下に作成されます ( airflow`の下ではありません)。この例では、ホームディレクトリは/home/ec2-user`です。
- |
-
# move to home dir
-cd
-mkdir dbt
-cd dbt
-git clone https://github.com/Teradata/jaffle_shop-dev.git jaffle_shop
-cd jaffle_shop
-mkdir target
-chmod 777 target
-echo '' > target/index.html
-chmod o+w target/index.htmlTeradata Studio Express、bteq などのデータベースツールを使用して、Teradataデータベース上に airflowtest と jaffle_shop のユーザー/データベースを作成します。 dbc としてデータベースにログインし、コマンドを実行します（必要に応じてパスワードを変更します）。
CREATE USER "airflowtest" FROM "dbc" AS PERM=5000000000 PASSWORD="abcd";
-CREATE USER "jaffle_shop" FROM "dbc" AS PERM=5000000000 PASSWORD="abcd";dbt構成ディレクトリを作成します。
-cd
-mkdir .dbtprofiles.yml を .dbt ディレクトリにコピーします。
Teradataデータベースの設定に対応するように、ファイルを編集します。最低でも、ホスト、ユーザー、パスワードは変更する必要があります。手順 3 で設定した jaffle_shop のユーザー信頼証明を使用します。
Dockerfile と docker-compose.yaml がある airflow ディレクトリで、Docker環境作成スクリプトを実行します。
cd ~/airflow
-sudo docker-compose up --buildこれには 5 ～ 10 分かかる場合があります。インストールが完了すると、画面に次のようなメッセージが表示されます。
-airflow-webserver_1 | 127.0.0.1 - - [13/Sep/2022:00:20:48 +0000] "GET /health HTTP/1.1" 200 187 "-" "curl/7.74.0"これは、Airflow Webサーバがコールを受け入れる準備ができていることを意味する。
-これで、Airflowが起動したはずです。インストール時に使用していたターミナルセッションは、ログメッセージの表示に使用されますので、 -以降の手順では別のターミナルセッションを開くことをお勧めします。Airflow の設置型を確認します。
-sudo docker ps結果は以下のようになります。
-CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
-60d50d9f43f5 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-scheduler_1
-e2b46ec98274 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_3_1
-7b44004c7277 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_1_1
-4017b8ce9235 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp airflow_airflow-webserver_1
-3cc407e2d565 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:5555->5555/tcp, :::5555->5555/tcp, 8080/tcp airflow_flower_1
-340a83b202e3 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-triggerer_1
-82198f0d8b84 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_2_1
-382c3077c1e5 redis:latest "docker-entrypoint.s…" 18 minutes ago Up 18 minutes (healthy) 6379/tcp airflow_redis_1
-8a3be8d8a7f4 nginx "/docker-entrypoint.…" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:4000->80/tcp, :::4000->80/tcp airflow_nginx_1
-9ca888e9e8df postgres:13 "docker-entrypoint.s…" 18 minutes ago Up 18 minutes (healthy) 5432/tcp airflow_postgres_1Dockerのインストールを削除したい場合（例えば、docker-compose.yamlとDockerfileファイルを更新して別の環境を再作成する場合）、コマンドは（これらのファイルがあるairflowディレクトリから）です。
-sudo docker-compose down --volumes --rmi allスタックが停止したら、設定ファイルを更新し、手順 1 のコマンドを実行して再起動します。
-AirflowのWeb UIが動作するかどうかをテストするには、ブラウザで次のURLを入力します。 <VM_IP_ADDRESS> をVMの外部IPアドレスに置き換えてください。
DAG UI: http://<YOUR_IP_ADDRESS>; :8080/home - username: airflow / password: airflow
Flower Airflow UI (worker control): http://<YOUR_IP_ADDRESS>:5555/
airflow_dbt_integration.py、 db_test_example_dag.py、 discover_dag.txt、 variables.json ファイルを `/home/ec2-user/airflow/dags`にコピーします。
-ファイルを確認します。
-airflow_dbt_integration.py - いくつかのテーブルを作成し、クエリーを実行する簡単な Teradata SQL の例です。
db_test_example_dag.py - dbtのサンプル（dbtとairflowをTeradataデータベースと統合する）を実行します。この例では、架空のjaffle_shopデータモデルが作成、ロードされ、このプロジェクトのドキュメントが作成されます（ブラウザで http://<VM_IP_ADDRESS>:4000/) を指定すると見ることができます）。
| - - | -
- `db_test_example_dag.py`を調整
-
-
-
|
-
discover_dag.py - 様々なタイプのデータファイル（CSV, Parquet, JSON）を読み込む方法の例です。ソースコードファイルには、プログラムが何を行い、どのようにそれを使用するかを説明するコメントが含まれています。この例では、`variables.json`ファイルを使用します。このファイルは、Airflowにインポートする必要があります。それは後続のステップで行われます。
これらのdagファイルがエアフローツールに拾われるまで数分待ちます。これらのファイルがピックアップされると、Airflow ホームページのダグリストに表示されます。
-variables.json ファイルを変数ファイルとして Airflow にインポートします。
Admin → Variables メニューアイテムをクリックし、Variables ページに移動します。
-Choose File をクリックし、ファイル エクスプローラで variable.json を選択して Import Variables
-をクリックします。
-お使いの環境に合わせて、変数を編集します。
-UIからDAGを実行し、ログを確認します。
-このチュートリアルは、Linux サーバーに Airflow 環境をインストールする方法と、Airflow を使用して Teradata Vantage データベースと対話する方法について、実践的な演習を提供することを目的とし ています。また、Airflow とデータモデリングおよびメンテナンスツールである dbt を統合して、Teradata Vantage データベースを作成およびロードする方法についての例も提供されます。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このチュートリアルでは、生データを取得して FEAST フィーチャに変換する dbt パイプラインを作成するアプローチを示します。パイプラインは、データ変換に ClearScape分析関数 を活用します。変換の出力は FEAST にロードされ、ML モデルで使用できるフィーチャがマテリアライズドされます。
-dbt(データ構築ツール)は、最新のデータスタックの基礎となるデータ変換ツールです。ELT (Extract Load Transform) の T を処理します。他のプロセスが生データをデータ ウェアハウスまたはレイクに取り込むことが前提です。次に、このデータを変換する必要があります。
-Feast (Feature Store) は、既存のテクノロジーを利用して機械学習フィーチャを管理し、リアルタイム モデルに提供する柔軟なデータ システムです。特定のニーズに合わせてカスタマイズできます。また、特徴をトレーニングと提供に一貫して利用できるようにし、データ漏洩を回避し、ML をデータ インフラストラクチャから切り離すこともできます。
-Teradata Vantageインスタンスへのアクセス。 -NOTE: Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。
-Feast-Teradata がローカルにインストールされている。 Feast-Teradata のインストール手順 -を参照してください。
-dbt はローカルにインストールされている。 dbtのインストール手順 -を参照してください。 -== 目的 -目的は、Teradata Vantageをソースとするデータ パイプラインを作成し、dbt内のいくつかの変数に対してデータ変換を実行することです。dbt で行うデータの基本的な変換は、性別、婚姻ステータス、州コードなどの複数の列のワンホット エンコーディングです。さらに、アカウント型の列データは、いくつかの列に対して集計操作を実行することによって変換されます。これらすべてが一緒になって、変換されたデータを持つ目的のデータセットを生成します。変換されたデータセットは、特徴を保存するためのFEASTへの入力として使用されます。次に、特徴を使用してモデルのトレーニング データセットを生成します。
-dbt、feast、およびそれらの依存関係を管理するための新しい Python 環境を作成します。環境を有効化します。
-python3 -m venv env
-source env/bin/activateチュートリアル リポジトリのクローンを作成し、ディレクトリをプロジェクト ディレクトリに変更します。
-git clone https://github.com/Teradata/tdata-pipeline.gitクローンされたプロジェクトのディレクトリ構造は以下のようになります。
-tdata-pipeline/ - feature_repo/ - feature_views.py - feature_store.yml - dbt_transformation/ - ... - macros - models - ... - generate_training_data.py - CreateDB.sql - dbt_project.yml-
teddy_bank は銀行顧客の架空のデータセット -で、主に顧客、口座、トランザクションの 3 つのテーブルで構成され、以下のようなエンティティリレーションシップ図があります。
-
-dbt はこの生データを取得し、ML モデリングおよび分析ツールにより適した以下のモデルを構築します。
-
-以下の内容のファイル $HOME/.dbt/profiles.yml を作成します。Teradata インスタンスに一致するように <host>、<user> 、<password> を調整します。
| - - | -
- データベースを設定する
-
-
-以下の dbt プロファイルは、 |
-
dbt_transformation:
- target: dev
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- schema: teddy_bank
- tmode: ANSI設定を検証します。
-dbt debugデバッグ コマンドがエラーを返した場合は、 `profiles.yml`の内容に問題がある可能性があります。
-Feastの構成は、Vantageデータベースへの接続に対応しています。feast
-プロジェクトの初期化中に作成された yaml ファイル $HOME/.feast/feature_repo/feature_store.yml には、オフライン ストレージ、オンライン ストレージ、プロバイダ
-、およびレジストリの詳細を保持できます。Teradata インスタンスに一致するように`<host>`、<user> 、<password> を調整します。
| - - | -
- データベースの設定
-
-
-以下の dbt プロファイルは、 `teddy_bank`というデータベースを指します。Teradata Vantage インスタンス内の既存の -データベースを指すように`schema`値を変更できます。 - |
-
project: td_pipeline
-registry:
- registry_type: sql
- path: teradatasql://<user>:<password>@<hostIP>/?database=teddy_bank&LOGMECH=TDNEGO
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <host>
- database: teddy_bank
- user: <user>
- password: <password>
- log_mech: TDNEGO
-entity_key_serialization_version: 2TeradataSource。 Teradata (Enterprise または Lake) に保存されている特徴量、または Teradata から外部テーブル経由でアクセスできる特徴量 (NOS、QueryGrid) のデータ ソース
エンティティ。 意味的に関連するフィーチャーの集合体
フィーチャー ビュー。 フィーチャー ビューは、特定のデータソースからのフィーチャーデータのグループです。特徴ビュー を使用すると、特徴量とそのデータ ソースを一貫して定義できるため、プロジェクト全体で特徴量グループを再利用できます。
DBT_source = TeradataSource( database=dbload, table=f"Analytic_Dataset", timestamp_field="event_timestamp")
-
-customer = Entity(name = "customer", join_keys = ['cust_id'])
-
-ads_fv = FeatureView(name="ads_fv",entities=[customer],source=DBT_source, schema=[
- Field(name="age", dtype=Float32),
- Field(name="income", dtype=Float32),
- Field(name="q1_trans_cnt", dtype=Int64),
- Field(name="q2_trans_cnt", dtype=Int64),
- Field(name="q3_trans_cnt", dtype=Int64),
- Field(name="q4_trans_cnt", dtype=Int64),
- ],)トレーニングデータを生成する方法はさまざまです。要件に応じて、「entitydf」は特徴ビュー マッピングを使用してソース データ テーブルと結合される場合があります。以下は、トレーニング データセットを生成するサンプル関数です。
-def get_Training_Data():
- # Initialize a FeatureStore with our current repository's configurations
- store = FeatureStore(repo_path="feature_repo")
- con = create_context(host = os.environ["latest_vm"], username = os.environ["dbc_pwd"],
- password = os.environ["dbc_pwd"], database = "EFS")
- entitydf = DataFrame('Analytic_Dataset').to_pandas()
- entitydf.reset_index(inplace=True)
- print(entitydf)
- entitydf = entitydf[['cust_id','event_timestamp']]
- training_data = store.get_historical_features(
- entity_df=entitydf,
- features=[
- "ads_fv:age"
- ,"ads_fv:income"
- ,"ads_fv:q1_trans_cnt"
- ,"ads_fv:q2_trans_cnt"
- ,"ads_fv:q3_trans_cnt"
- ,"ads_fv:q4_trans_cnt"
- ],
- full_feature_names=True
- ).to_df()
-
- return training_dataこのチュートリアルでは、Teradata Vantage で dbt と FEAST を使用する方法を説明しました。サンプル プロジェクトは、Teradata Vantage から生データを取得し、dbt を使用して特徴を生成します。次に、モデルのトレーニング データセットを生成するためのベースを形成する特徴のメタデータが FEAST で作成されました。フィーチャストアを作成する対応するすべてのテーブルも、ランタイムに同じデータベース内に生成されます。
-このプロジェクトの Gitリポジトリ 。
-
- Teradata Vantage インスタンス、バージョン 17.10 以降へのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
KNIME がローカルにインストールされている。詳細については 、 KNIME のインストール手順 を 参照してください。
-https://downloads.teradata.com/download/connectivity/jdbc-driver (初めての方は登録が必要です) にアクセスし、最新版のJDBCドライバをダウンロードします。
-ダウンロードしたファイルを解凍します。 terajdbc4.jar ファイルがあります。
KNIME で、 File → Preference をクリックします。 Databases の Add をクリックします。
-データベースドライバを新規に登録します。 ID、 Name 、 Description に以下のような値を指定します。Add file`をクリックし、前にダウンロードした.jarファイルをポイントします。 `Find driver classes をクリックすると、Driver class: に jdbc.TeraDriver が入力されます。
-Apply and Close をクリックします。
-接続をテストするために、新しいKNIMEワークフローを作成し、右側のワークスペースにドラッグして Database Reader (legacy) ノードを追加してください。
-
-Database Reader (legacy) を右クリックし、設定を行います。ドロップダウンから com.teradata.jdbc.Teradriver を選択します。
-Vantageサーバの名前とログインメカニズムを入力します。例:
-
-接続をテストするには、右下のボックスに SQL 文を入力します。例えば、 SELECT * FROM DBC.DBCInfoV と入力し、 Apply をクリックしてダイアログを閉じます。
-接続をテストするノードを実行します。
-
-正常に実行されると、ノードに緑色のランプが表示されます。右クリックして、 5Data from Database を選択すると、結果が表示されます。
-
-
- このハウツーでは、Teradata データベースをローカル マシン上で実行してアクセスする方法を示します。Teradata をインストールするにはさまざまな方法があります。このドキュメントでは、クラウド リソースにコストを費やすことなく、最初のクエリーまでの時間を最短にするように最適化します。手順を完了すると、コンピュータ上で動作する Teradata Vantage Express データベースが作成されます。
-| - - | --バージョン 17.20 以降、Vantage Express には次の分析パッケージが含まれています: Vantage Analytics Library、 Bring Your Own Model (BYOM)、 API Integration with AWS SageMaker。 - | -
| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
| - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
このハウツーでは、Teradata データベースをローカル マシン上で実行してアクセスする方法を示します。手順を完了すると、コンピュータ上で動作する Teradata Vantage Express データベースが作成されます。
-| - - | --バージョン 17.20 以降、Vantage Express には以下の分析パッケージが含まれています。 Vantage Analytics Library、 Bring Your Own Model (BYOM)、 API Integration with AWS SageMaker。 - | -
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB+
-サンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VirtualBoxと7 zipをインストールします。
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -ycurlコマンドを取得して、Vantage Expressをダウンロードします。
-Vantage Expess のダウンロード ページに移動します (登録が必要です)。
-「Vantage Express 17.20」などの最新のダウンロードリンクをクリックします。使用許諾契約のポップアップが表示されます。まだライセンスを受け入れません。
-ブラウザでネットワークビューを開きます。例えば、Chrome で kbd:[F12] を押し「 Network」タブに移動します。
-`I Agree (同意する)`ボタンをクリックしてライセンスを受け入れ、ダウンロードをキャンセルします。
-ネットワーク ビューで、 `VantageExpress`で始まる最後のリクエストを見つけます。それを右クリックして `Copy → Copy as cURL`を選択します。
-
-ssh セッションに戻り、curl コマンドを貼り付けて Vantage Express をダウンロードします。ダウンロードを ve.7z という名前のファイルに保存するには、コマンドに -o ve.7z を追加します。次のように、すべてのHTTPヘッダーを削除できます。
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'ダウンロードしたファイルを解凍します。数分かかります。
-7z x ve.7zVirtualBox で VM を起動しますコマンドはすぐに返されますが、VM の初期化プロセスには数分かかります。
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cVantage Express VM に ssh で接続します。 root をパスワードとして使用します。
ssh -p 4422 root@localhostDBがアップしていることを確認します。
-pdestate -aコマンドが`PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent`を返す場合は、Vantage Expressが起動したことを意味します。
-状態が異なる場合は、正しいステータスが得られるまで pdestate -a を繰り返します。
Vantage Expressが起動して実行されたら、bteq クライアントのコマンドラインクライアントを起動します。BTEQ (「ビーテック」と発音) は、Teradata Database に SQL クエリーを送信するために使用される、汎用のコマンド ベースのクライアント ツールです。
bteqbteqに入ったら、Vantage Expressインスタンスに接続します。パスワードを求められたら、 `dbc`を入力します。
-.logon localhost/dbc`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/貼り付けて、kbd:[Enter] を押して実行します。
-CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
VM を停止して起動する場合は、Vantage Express を自動起動に追加することをお勧めします。 VM に ssh で接続し、以下のコマンドを実行します。
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-express| - - | --このハウツーでは、Teradata Extensions を Jupyter Notebooks 環境に追加する方法を示します。Teradata Extensions および分析ツールと統合された Jupyter Notebooks のホストされたバージョンは、https://clearscape.teradata.comで無料で機能テストに利用できます。 - | -
- Native Object Storage (NOS) は、AWS S3、Google GCS、Azure Blob、またはオンプレミス実装などのオブジェクト ストレージ内のファイルに保存されているデータをクエリできるようにする Vantage の機能です。これは、Vantage にデータを取り込むためのデータ パイプラインを構築せずにデータを探索するシナリオに役立ちます。
-Teradata Vantage インスタンスにアクセスする必要があります。NOS は、バージョン 17.10 以降、Vantage Express から Developer、DYI、Vantage as a Service までのすべての Vantage エディションで有効になります。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
| - - | --現在、NOS は CSV、JSON (配列または改行区切りとして)、および Parquet データ形式をサポートしています。 - | -
データセットが CSV ファイルとして S3 バケットに保存されているとします。データセットを Vantage に取り込むかどうかを決定する前に、データセットを探索したいと考えています。このシナリオでは、 -米国地質調査所によって収集された河川流量データを含む、Teradata によって公開された公開データセットを使用します。バケットは https://td-usgs-public.s3.amazonaws.com/にあります。
-まずはCSVデータのサンプルを見てみましょう。Vantage がバケットからフェッチする最初の 10 行を取得します。
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d;私が持っているものは次のとおりです。
-GageHeight2 Flow site_no datetime Precipitation GageHeight ------------ ----- -------- ---------------- ------------- ----------- -10.9 15300 09380000 2018-06-28 00:30 671 9.80 -10.8 14500 09380000 2018-06-28 01:00 673 9.64 -10.7 14100 09380000 2018-06-28 01:15 672 9.56 -11.0 16200 09380000 2018-06-27 00:00 669 9.97 -10.9 15700 09380000 2018-06-27 00:30 668 9.88 -10.8 15400 09380000 2018-06-27 00:45 672 9.82 -10.8 15100 09380000 2018-06-27 01:00 672 9.77 -10.8 14700 09380000 2018-06-27 01:15 672 9.68 -10.9 16000 09380000 2018-06-27 00:15 668 9.93 -10.8 14900 09380000 2018-06-28 00:45 672 9.72-
たくさんの数字が出てきましたが、それは何を意味するのでしょうか？この質問に答えるために、Vantage に CSV ファイルのスキーマを検出するように依頼します。
-SELECT
- *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- RETURNTYPE='NOSREAD_SCHEMA'
-) AS d;Vantage はデータ サンプルをフェッチしてスキーマを分析し、結果を返します。
-Name Datatype FileType Location ---------------- ----------------------------------- --------- ------------------------------------------------------------------- -GageHeight2 decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Flow decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -site_no int csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -datetime TIMESTAMP(0) FORMAT'Y4-MM-DDBHH:MI' csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Precipitation decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -GageHeight decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv-
CSV ファイルには 6 つの列があることがわかります。各列について、スキーマを推測するために使用された名前、データ型、ファイル座標を取得します。
-スキーマがわかったので、データセットを通常の SQL テーブルであるかのように操作できます。その要点を証明するために、データの集計を行ってみましょう。気温を収集しているサイトについて、サイトごとの平均気温を取得してみましょう。
-SELECT
- site_no Site_no, AVG(Flow) Avg_Flow
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d
-GROUP BY
- site_no
-HAVING
- Avg_Flow IS NOT NULL;結果：
-Site_no Avg_Flow --------- --------- -09380000 11 -09423560 73 -09424900 93 -09429070 81-
アドホック探索アクティビティを永続ソースとして登録するには、それを外部テーブルとして作成します。
--- If you are running this sample as dbc user you will not have permissions
--- to create a table in dbc database. Instead, create a new database and use
--- the newly create database to create a foreign table.
-
-CREATE DATABASE Riverflow
- AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB
-
--- change current database to Riverflow
-DATABASE Riverflow;
-
-CREATE FOREIGN TABLE riverflow
- USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );
-
-SELECT top 10 * FROM riverflow;結果：
-Location GageHeight2 Flow site_no datetime Precipitation GageHeight -------------------------------------------------------------------- ----------- ---- ------- ------------------- ------------- ---------- -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:40:00 1.21 null -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:30:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:45:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 01:00:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:15:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:38:00 1.06 null-
今回の SELECT ステートメントは、データベース内のテーブルに対する通常の選択のように見えます。データのクエリー時に 1 秒未満の応答時間が必要な場合は、CSV データを Vantage に取り込んで処理を高速化する簡単な方法があります。その方法については、読み続けてください。
オブジェクト ストレージのクエリーには時間がかかります。データが興味深いと判断し、より迅速に答えが得られるソリューションを使用してさらに分析を行いたい場合はどうすればよいでしょうか? 良いニュースは、NOS で返されたデータを CREATE TABLE ステートメントのソースとして使用できることです。 CREATE TABLE 権限があると仮定すると、次を実行できます:
| - - | -
-このクエリは、前の手順でデータベース 河川流量 と 河川流量 という外部テーブルを作成したことを前提としています。
- |
-
-- This query assumes you created database `Riverflow`
--- and a foreign table called `riverflow` in the previous step.
-
-CREATE MULTISET TABLE riverflow_native (site_no, Flow, GageHeight, datetime)
-AS (
- SELECT site_no, Flow, GageHeight, datetime FROM riverflow
-) WITH DATA
-NO PRIMARY INDEX;
-
-SELECT TOP 10 * FROM riverflow_native;結果：
-site_no Flow GageHeight datetime -------- ----- ---------- ------------------- -9400815 .00 -.01 2018-07-10 00:30:00 -9400815 .00 -.01 2018-07-10 01:00:00 -9400815 .00 -.01 2018-07-10 01:15:00 -9400815 .00 -.01 2018-07-10 01:30:00 -9400815 .00 -.01 2018-07-10 02:00:00 -9400815 .00 -.01 2018-07-10 02:15:00 -9400815 .00 -.01 2018-07-10 01:45:00 -9400815 .00 -.01 2018-07-10 00:45:00 -9400815 .00 -.01 2018-07-10 00:15:00 -9400815 .00 -.01 2018-07-10 00:00:00-
今回は、 SELECT クエリーは 1 秒以内に返されました。Vantage は NOS からデータを取得する必要がありませんでした。代わりに、ノード上にすでに存在していたデータを使用して応答しました。
これまではパブリックバケットを使用してきました。プライベートバケットがある場合はどうなるでしょうか? どの認証情報を使用する必要があるかを Vantage にどのように指示しますか?
-資格情報をクエリーに直接インライン化することができます。
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- AUTHORIZATION='{"ACCESS_ID":"","ACCESS_KEY":""}'
-) AS d;これらの認証情報を常に入力するのは面倒であり、安全性も低下する可能性があります。Vantage では、資格情報のコンテナとして機能する認可オブジェクトを作成できます。
-CREATE AUTHORIZATION aws_authorization
- USER 'YOUR-ACCESS-KEY-ID'
- PASSWORD 'YOUR-SECRET-ACCESS-KEY';これにより、外部テーブルを作成するときに認可オブジェクトを参照できるようになります。
-CREATE FOREIGN TABLE riverflow
-, EXTERNAL SECURITY aws_authorization
-USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );これまで、オブジェクト ストレージからのデータの読み取りとインポートについて説明してきました。SQL を使用して Vantage からオブジェクト ストレージにデータをエクスポートする方法があれば素晴らしいと思いませんか? これはまさに WRITE_NOS 関数の目的です。 riverflow_native テーブルからオブジェクト ストレージにデータをエクスポートしたいとします。次のクエリを使用してこれを行うことができます。
SELECT * FROM WRITE_NOS (
- ON ( SELECT * FROM riverflow_native )
- PARTITION BY site_no ORDER BY site_no
- USING
- LOCATION('YOUR-OBJECT-STORE-URI')
- AUTHORIZATION(aws_authorization)
- STOREDAS('PARQUET')
- COMPRESSION('SNAPPY')
- NAMING('RANGE')
- INCLUDE_ORDERING('TRUE')
-) AS d;ここでは、Vantage に riverflow_native からデータを取得し、 parquet 形式を使用して YOUR-OBJECT-STORE-URI バケットに保存するように指示します。データは site_no 属性でファイルに分割されます。ファイルは圧縮されます。
このクイック スタートでは、Vantage のネイティブ オブジェクト ストレージ (NOS) 機能を使用してオブジェクト ストレージからデータを読み取る方法を学習しました。NOS は、CSV、JSON、および Parquet 形式で保存されたデータの読み取りとインポートをサポートしています。NOS は、Vantage からオブジェクト ストレージにデータをエクスポートすることもできます。
-kbd:[ENTER]を押して、強調表示されている LINUX ブートパーティションを選択します。
-以下の画面で、もう一度 kbd:[ENTER] を押して、デフォルトの SUSE Linux カーネルを選択します。
-
-起動シーケンスが完了すると、以下のスクリーンショットに示すような端末ログイン プロンプトが表示されます。ターミナルには何も入力しないでください。システムが GUI を開始するまで待ちます。
-
-しばらくすると、以下のプロンプトが表示されます。上記のコマンド ログイン プロンプトの後に何も入力しなかったと仮定します。下の画面で`okay`ボタンを押す。
-
-VM が起動すると、そのデスクトップ環境が表示されます。username/password の入力を求められたら、両方に root と入力します。
-データベースは VM とともに自動起動するように構成されています。データベースが開始されたことを確認するには、仮想デスクトップに移動し、Gnome Terminal を起動します。
-ターミナルで pdestate コマンドを実行すると、Vantage がすでに起動しているかどうかが通知されます。
| - - | --Gnome Terminalに貼り付けるには、kbd:[SHIFT+CTRL+V] を押します。 - | -
watch pdestate -a以下のメッセージが表示されるまで待ちます。
-PDE state is RUN/STARTED. -DBS state is 5: Logons are enabled - The system is quiescent-
pdestate返すメッセージの例を参照してください。
-PDE state is DOWN/HARDSTOP. - -PDE state is START/NETCONFIG. - -PDE state is START/GDOSYNC. - -PDE state is START/TVSASTART. - -PDE state is START/READY. -PDE state is RUN/STARTED. - -DBS state is 1/1: DBS Startup - Initializing DBS Vprocs -PDE state is RUN/STARTED. - -DBS state is 1/5: DBS Startup - Voting for Transaction Recovery -PDE state is RUN/STARTED. - -DBS state is 1/4: DBS Startup - Starting PE Partitions -PDE state is RUN/STARTED.-
データベースが起動したので、仮想デスクトップに戻って`Teradata Studio Express`を起動します。
-
-初めて開始すると、ツアーが提供されます。ツアーを終了すると、新しい接続を追加するためのウィザードウィンドウが表示さます。 `Teradata`を選択します。
-
-以下の画面で、ユーザー名とパスワードに dbc を使用してローカルホスト上のデータベースに接続します。
-Teradata Studio Expressで、クエリー開発`パースペクティブに移動すします(トップメニューに移動して、`Window → クエリー開発 を選択)。
データベース接続 → `新規Teradata`をダブルクリックして、以前に作成した接続プロファイルを使用して接続します。
`dbc`ユーザーを使用して、`HR`という新しいデータベースを作成します。このクエリーをコピー/ペーストし、Run Query () ボタンまたはkbd:[F5]キーを押します。
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBサンプルテーブルを作成し、データを挿入してクエリーを実行してみましょう。まず、従業員情報を保持するテーブルを作成する。
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );次に、レコードを挿入する。
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);最後に、データを取得できるかどうかを確認する。
-SELECT * FROM HR.Employees;以下の結果が得られるはずです。
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
| - - | --https://clearscape.teradata.com/では、Vantageのホストされたインスタンスを無料で入手できるようになりました。 - | -
| - - | --Vantage の新しいインスタンスが必要な場合は、Google Cloud、Azure、AWS のクラウドに Vantage Express と呼ばれる無料バージョンをインストールできます。また、VMware、VirtualBox、またはUTMを使用して、ローカルマシンでVantage Expressを実行することもできる。 - | -
| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
- Teradata Query Service は、Vantage 用の REST API で、これを使用すると、クライアント側のドライバを管理せずに標準的な SQL 文を実行できます。REST API を使用して Analytics データベースにクエリおよびアクセスする場合は、Query Service を使用します。
-このハウツーでは、Query Service を使い始めるのに役立つ、一般的な使用例を紹介します。
-始める前に、以下のものが揃っていることを確認してください。
-Query Service がプロビジョニングされている VantageCloud システム、または Query Service が有効な接続を備えた VantageCore へのアクセス。管理者で、Query Service をインストールする必要がある場合は、 Query Service のインストール、構成、および使用ガイド を参照してください。
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Query Service のホスト名とシステム名
-データベースに接続するための認証情報
-前提条件に問題がありますか？設定情報については、Teradataに連絡してください。
-例題を使用する際は、以下の点に注記してください。
-このドキュメントではPythonを使用していますが、これを利用してお好きな言語でサンプルを作成することができます。
-ここで提供されるサンプルは完全なものであり、すぐに使用できますが、ほとんどの場合、多少のカスタマイズが必要です。
-このドキュメントの例では、URL https://<QS_HOSTNAME>:1443/ を使用しています。
以下の変数を独自の値に置き換えます。
-<QS_HOSTNAME>: Query Service がインストールされているサーバー
<SYSTEM_NAME>: システムの事前設定されたエイリアス
| - - | -
-
-
-VantageインスタンスがClearScape Analytics Experienceを通じて提供される場合、<QS_HOSTNAME>はClearScape Analytics ExperienceのホストURLであり、<SYSTEM_NAME>は「ローカル」です。 - |
-
HTTP Basic 認証または JWT 認証を使用してターゲット Analytics データベースにアクセスするための有効な認証情報を提供します。
-データベースのユーザ名とパスワードは、文字列("username : password")に結合され、Base64を使用してエンコードされています。API 応答には、認証メソッドとエンコードされた信頼証明が含まれます。
リクエスト
-import requests
-import json
-import base64
-requests.packages.urllib3.disable_warnings()
-
-# run it from local.
-
-db_user, db_password = 'dbc','dbc'
-auth_encoded = db_user + ':' + db_password
-auth_encoded = base64.b64encode(bytes(auth_encoded, 'utf-8'))
-auth_str = 'Basic ' + auth_encoded.decode('utf-8')
-
-print(auth_str)
-
-headers = {
- 'Content-Type': 'application/json',
- 'Authorization': auth_str # base 64 encoded username:password
-}
-
-print(headers)応答
-Basic ZGJjOmRiYw==
-{
- 'Content-Type': 'application/json',
- 'Authorization': 'Basic ZGJjOmRiYw=='
-}
-前提条件:
-ユーザーはデータベースにすでに存在している必要があります。
-データベースはJWT対応である必要があります。
-リクエスト
-import requests
-import json
-requests.packages.urllib3.disable_warnings()
-
-# run it from local.
-
-auth_encoded_jwt = "<YOUR_JWT_HERE>"
-auth_str = "Bearer " + auth_encoded_jwt
-
-headers = {
- 'Content-Type': 'application/json',
- 'Authorization': auth_str
-}
-
-print(headers)応答
-{'Content-Type': 'application/json', 'Authorization': 'Bearer <YOUR_JWT_HERE>'}
-以下の例では、リクエストの内容は以下の通りです。
-SELECT * FROM DBC.DBCInfo: エイリアス `<SYSTEM_NAME>`を持つシステムへのクエリー。
'format': 'OBJECT': 応答の形式。サポートされているフォーマットは、JSONオブジェクト、JSON配列、CSVです。
| - - | --JSONオブジェクト フォーマットでは、列名がフィールド名、列値がフィールド値である行ごとに1つのJSONオブジェクトが作成されます。 - | -
'includeColumns': true: 列名や型などの列メタデータをレスポンスに含めるかどうかのリクエスト。
'rowLimit': 4: クエリーから返される行の数。
リクエスト
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': example_query, # 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'includeColumns': True,
- 'rowLimit': 4
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-num_rows = response.json().get('results')[0].get('rowCount')
-print('NUMBER of ROWS', num_rows)
-print('==========================================================')
-
-print(response.json())応答
-NUMBER of ROWS 4
-==========================================================
-{
- "queueDuration":7,
- "queryDuration":227,
- "results":[
- {
- "resultSet":True,
- "columns":[
- {
- "name":"DatabaseName",
- "type":"CHAR"
- },
- {
- "name":"USEDSPACE_IN_GB",
- "type":"FLOAT"
- },
- {
- "name":"MAXSPACE_IN_GB",
- "type":"FLOAT"
- },
- {
- "name":"Percentage_Used",
- "type":"FLOAT"
- },
- {
- "name":"REMAININGSPACE_IN_GB",
- "type":"FLOAT"
- }
- ],
- "data":[
- {
- "DatabaseName":"DBC",
- "USEDSPACE_IN_GB":317.76382541656494,
- "MAXSPACE_IN_GB":1510.521079641879,
- "Percentage_Used":21.03670247964377,
- "REMAININGSPACE_IN_GB":1192.757254225314
- },
- {
- "DatabaseName":"EM",
- "USEDSPACE_IN_GB":0.0007491111755371094,
- "MAXSPACE_IN_GB":11.546071618795395,
- "Percentage_Used":0.006488017745513208,
- "REMAININGSPACE_IN_GB":11.545322507619858
- },
- {
- "DatabaseName":"user10",
- "USEDSPACE_IN_GB":0.019153594970703125,
- "MAXSPACE_IN_GB":9.313225746154785,
- "Percentage_Used":0.20566016,
- "REMAININGSPACE_IN_GB":9.294072151184082
- },
- {
- "DatabaseName":"EMEM",
- "USEDSPACE_IN_GB":0.006140708923339844,
- "MAXSPACE_IN_GB":4.656612873077393,
- "Percentage_Used":0.13187072,
- "REMAININGSPACE_IN_GB":4.650472164154053
- },
- {
- "DatabaseName":"EMWork",
- "USEDSPACE_IN_GB":0.0,
- "MAXSPACE_IN_GB":4.656612873077393,
- "Percentage_Used":0.0,
- "REMAININGSPACE_IN_GB":4.656612873077393
- }
- ],
- "rowCount":4,
- "rowLimitExceeded":True
- }
- ]
-}
-応答パラメータについては、 「Query Service インストール、構成、および使用ガイド」を参照してください。
-APIレスポンスをCSV形式で返すには、リクエストの format フィールドに CSV という値を設定します。
CSV 形式にはクエリー結果のみが含まれ、応答メタデータは含まれません。応答には行ごとに 1 行が含まれており、各行にはカンマで区切られた行列が含まれます。以下の例では、データをカンマ区切り値として返します。
-リクエスト
-# CSV with all rows included
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': example_query, # 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'CSV',
- 'includeColumns': True
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)応答
-DatabaseName,USEDSPACE_IN_GB,MAXSPACE_IN_GB,Percentage_Used,REMAININGSPACE_IN_GB -DBC ,317.7634754180908,1510.521079641879,21.036679308932754,1192.7576042237881 -EM ,7.491111755371094E-4,11.546071618795395,0.006488017745513208,11.545322507619858 -user10 ,0.019153594970703125,9.313225746154785,0.20566016,9.294072151184082 -EMEM ,0.006140708923339844,4.656612873077393,0.13187072,4.650472164154053 -EMWork ,0.0,4.656612873077393,0.0,4.656612873077393 -EMJI ,0.0,2.3283064365386963,0.0,2.3283064365386963 -USER_NAME ,0.0,2.0,0.0,2.0 -readonly ,0.0,0.9313225746154785,0.0,0.9313225746154785 -aug12_db ,7.200241088867188E-5,0.9313225746154785,0.0077312,0.9312505722045898 -SystemFe ,1.8024444580078125E-4,0.7450580596923828,0.024192,0.744877815246582 -dbcmngr ,3.814697265625E-6,0.09313225746154785,0.004096,0.09312844276428223 -EMViews ,0.027594566345214844,0.09313225746154785,29.62944,0.06553769111633301 -tdwm ,6.732940673828125E-4,0.09313225746154785,0.722944,0.09245896339416504 -Crashdumps ,0.0,0.06984921544790268,0.0,0.06984921544790268 -SYSLIB ,0.006252288818359375,0.03725290298461914,16.78336,0.031000614166259766 -SYSBAR ,4.76837158203125E-6,0.03725290298461914,0.0128,0.03724813461303711 -SYSUDTLIB ,3.5381317138671875E-4,0.029802322387695312,1.1872,0.029448509216308594 -External_AP ,0.0,0.01862645149230957,0.0,0.01862645149230957 -SysAdmin ,0.002307891845703125,0.01862645149230957,12.3904,0.016318559646606445 -KZXaDtQp ,0.0,0.009313225746154785,0.0,0.009313225746154785 -s476QJ6O ,0.0,0.009313225746154785,0.0,0.009313225746154785 -hTzz03i7 ,0.0,0.009313225746154785,0.0,0.009313225746154785 -Y5WYUUXj ,0.0,0.009313225746154785,0.0,0.009313225746154785-
トランザクションが複数のリクエストにまたがる必要がある場合や、揮発性のテーブルを使用する場合は、明示的なセッションを使用します。これらのセッションは、クエリーリクエストでセッションを参照する場合にのみ再利用されます。リクエストがすでに使用されている明示的セッションを参照する場合、リクエストはキューに入れられます。
-セッションを作成します。
-POST リクエストを /system/<SYSTEM_NAME>/sessions エンドポイントに送信します。リクエストは新しいデータベース セッションを作成し、セッションの詳細を応答として返します。
以下の例では、リクエストに `'auto_commit':True` - 完了時にクエリーをコミットするリクエストが含まれています。-
リクエスト
-# first create a session
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/sessions'
-
-payload = {
- 'auto_commit': True
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)応答
-{
- 'sessionId': 1366010,
- 'system': 'testsystem',
- 'user': 'dbc',
- 'tdSessionNo': 1626922,
- 'createMode': 'EXPLICIT',
- 'state': 'LOGGINGON',
- 'autoCommit': true
-}
-手順1で作成したセッションを使用して、クエリーを送信します。
-/system/<SYSTEM_NAME>/queries エンドポイントに POST リクエストを送信します。
リクエストでは、対象システムに対してクエリーを送信し、対象システムのリリース番号とバージョン番号を返します。
-以下の例では、リクエストには以下のものが含まれます。
-SELECT * FROM DBC.DBCInfo: エイリアス <SYSTEM_NAME> を持つシステムへのクエリー。
'format': 'OBJECT':応答の形式。
'Session' : <Session ID>:明示的なセッションを作成するためにステップ1で返されたセッションID。
リクエスト
-# use this session to submit queries afterwards
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'session': 1366010 # <-- sessionId
-}
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)応答
-{
- "queueDuration":6,
- "queryDuration":41,
- "results":[
- {
- "resultSet":true,
- "data":[
- {
- "InfoKey":"LANGUAGE SUPPORT MODE",
- "InfoData":"Standard"
- },
- {
- "InfoKey":"RELEASE",
- "InfoData":"15.10.07.02"
- },
- {
- "InfoKey":"VERSION",
- "InfoData":"15.10.07.02"
- }
- ],
- "rowCount":3,
- "rowLimitExceeded":false
- }
- ]
-}
-非同期クエリーは、大量のデータや長時間実行するクエリーによってシステムやネットワークのパフォーマンスに影響を与える場合に使用します。
-非同期クエリーをターゲット システムに送信し、クエリー IDを取得します。
-POST リクエストを /system/<SYSTEM_NAME>/queries エンドポイントに送信します。
以下の例では、リクエストには以下のものが含まれます。
-SELECT * FROM DBC.DBCInfo: エイリアス `<SYSTEM_NAME>`を持つシステムへのクエリー。
'format': 'OBJECT':応答の形式。
'spooled_result_set': True: リクエストが非同期であることを示します。
リクエスト
-## Run async query .
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'spooled_result_set': True
-}
-
-payload_json = json.dumps(payload)
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)応答
-{"id":1366025}
-ステップ 1 で取得した ID を使用してクエリーの詳細を取得します。
-GET リクエストを /system/<SYSTEM_NAME>/queries/<queryID> エンドポイントに送信し、 <queryID> をステップ 1 で取得した ID に置き換えます。
リクエストは、 queryState、 queueOrder、 queueDuration などを含む特定のクエリーの詳細を返します。応答フィールドの完全なリストとその説明については、「Query Service のインストール、構成、および使用ガイド」を参照してください。
リクエスト
-## response for async query .
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries/1366025'
-
-payload_json = json.dumps(payload)
-response = requests.request('GET', url, headers=headers, verify=False)
-
-print(response.text)応答
-{
- "queryId":1366025,
- "query":"SELECT * FROM DBC.DBCInfo;",
- "batch":false,
- "system":"testsystem",
- "user":"dbc",
- "session":1366015,
- "queryState":"RESULT_SET_READY",
- "queueOrder":0,
- "queueDuration":6,
- "queryDuration":9,
- "statusCode":200,
- "resultSets":{
-
- },
- "counts":{
-
- },
- "exceptions":{
-
- },
- "outParams":{
-
- }
-}
-非同期クエリーの結果セットを表示します
-GET リクエストを `/system/<SYSTEM_NAME>/queries/<queryID>/results` エンドポイントに送信し、 `<queryID>` をステップ 1 で取得した ID に置き換えます。 -リクエストは、送信されたクエリーによって生成された結果セットと更新カウントの配列を返します。-
リクエスト
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries/1366025/results'
-
-payload_json = json.dumps(payload)
-response = requests.request('GET', url, headers=headers, verify=False)
-
-print(response.text)応答
-{
- "queueDuration":6,
- "queryDuration":9,
- "results":[
- {
- "resultSet":true,
- "data":[
- {
- "InfoKey":"LANGUAGE SUPPORT MODE",
- "InfoData":"Standard"
- },
- {
- "InfoKey":"RELEASE",
- "InfoData":"15.10.07.02"
- },
- {
- "InfoKey":"VERSION",
- "InfoData":"15.10.07.02"
- }
- ],
- "rowCount":3,
- "rowLimitExceeded":false
- }
- ]
-}
-/system/<SYSTEM_NAME>/queries エンドポイントにGET リクエストを送信します。リクエストはアクティブなクエリーの ID を返します。
リクエスト
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload={}
-
-response = requests.request('GET', url, headers=headers, data=payload, verify=False)
-
-print(response.json())応答
-[
- {
- "queryId": 12516087,
- "query": "SELECt * from dbcmgr.AlertRequest;",
- "batch": false,
- "system": "BasicTestSys",
- "user": "dbc",
- "session": 12516011,
- "queryState": "REST_SET_READY",
- "queueOrder": 0,
- "queueDurayion": 3,
- "queryDuration": 3,
- "statusCode": 200,
- "resultSets": {},
- "counts": {},
- "exceptions": {},
- "outparams": {}
- },
- {
- "queryId": 12516088,
- "query": "SELECt * from dbc.DBQLAmpDataTbl;",
- "batch": false,
- "system": "BasicTestSys",
- "user": "dbc",
- "session": 12516011,
- "queryState": "REST_SET_READY",
- "queueOrder": 0,
- "queueDurayion": 3,
- "queryDuration": 3,
- "statusCode": 200,
- "resultSets": {},
- "counts": {},
- "exceptions": {},
- "outparams": {}
- }
-]
-機能、例、および参考資料: クエリサービスのインストール、設定、および使用ガイド
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- Vantageに大量のデータを移動させるニーズはよくあります。Teradataはこのようなニーズにこたえるため Teradata Parallel Transporter (TPT) ユーティリティを提供しています。このハウツーでは、TPT の使用方法を説明します。このシナリオでは30万件以上のレコードをもつ40MB以上のデータを数秒でロードします。
Teradata Vantageインスタンスへのアクセス。
-| - - | --Vantage のテスト インスタンスが必要な場合は、 https://clearscape.teradata.com. -で無料でプロビジョニングできます。 - | -
Teradata Tools and Utilities (TTU) をダウンロード - サポートされているプラットフォーム: Windows、 MacOS、 Linux (登録が必要です)。
-非営利団体の米国税務申告を扱います。非営利の納税申告は公開データです。アメリカ内国歳入庁は、これらを S3 バケットで公開します。2020 年の提出書類の概要を見てみましょう。 https://storage.googleapis.com/clearscape_analytics_demo_data/TPT/index_2020.csv ブラウザ、wget、または curl を使用して、ファイルをローカルに保存できます。
Vantageでデータベースを作成しましょう。お気に入りの SQL ツールを使用して、以下のクエリーを実行します。
-CREATE DATABASE irs
-AS PERMANENT = 120e6, -- 120MB
- SPOOL = 120e6; -- 120MBこれから TPT を実行します。TPT は、Teradata Vantageでデータのロード、抽出、更新に使用できるコマンドラインツールです。これらのさまざまな機能は、いわゆる オペレータ で実装されます。 例えば、Vantage へのデータのロードは Load オペレータによって処理されます。 Load オペレータは、大量のデータを Vantage にアップロードする場合に非常に効率的です。 Load オペレータには、高速化するためにいくつかの制限があります。空のテーブルのみを設定できます。すでにデータが設定されているテーブルへの挿入はサポートされていません。セカンダリ インデックスを持つテーブルはサポートされていません。また、テーブルが MULTISET テーブルであっても、重複レコードは挿入されません。制限の完全なリストについては 、 Teradata® TPT リファレンス - ロード オペレータ - 制限と制約 を参照してください。
TPT には独自のスクリプト言語があります。この言語を使用すると、任意の SQLコマンドを使用してデータベースを準備し、入力ソースを宣言し、Vantage にデータを挿入する方法を定義できます。
-CSV データを Vantage にロードするには、ジョブを定義して実行します。ジョブはデータベースを準備します。古いログテーブルとエラーテーブルが削除され、ターゲット テーブルが作成されます。次に、ファイルを読み込み、データをデータベースに挿入するします。
-TPTにVantageデータベースへの接続方法を指示するジョブ変数ファイルを作成します。ファイル jobvars.txt を作成し、以下の内容を挿入します。host をデータベースのホスト ネームで置き換えます。例えば、ローカルの Vantage Express インスタンスを使用している場合は、 127.0.0.1 を使用します。 username はデータベース ユーザー名、 password はデータベース パスワードです。準備ステップ (DDL) とロード ステップにはそれぞれ独自の構成値があり、DDLとロード ステップの両方を構成するには構成値を2回入力する必要があることに注記してください。
TargetTdpId = 'host'
-TargetUserName = 'username'
-TargetUserPassword = 'password'
-
-FileReaderDirectoryPath = ''
-FileReaderFileName = 'index_2020.csv'
-FileReaderFormat = 'Delimited'
-FileReaderOpenMode = 'Read'
-FileReaderTextDelimiter = ','
-FileReaderSkipRows = 1
-
-DDLErrorList = '3807'
-
-LoadLogTable = 'irs.irs_returns_lg'
-LoadErrorTable1 = 'irs.irs_returns_et'
-LoadErrorTable2 = 'irs.irs_returns_uv'
-LoadTargetTable = 'irs.irs_returns'以下の内容のファイルを作成し、 load.txt として保存します。ジョブファイルの構造を理解するには、ジョブファイル内のコメントを参照してください。
DEFINE JOB file_load
-DESCRIPTION 'Load a Teradata table from a file'
-(
- /*
- Define the schema of the data in the csv file
- */
- DEFINE SCHEMA SCHEMA_IRS
- (
- in_return_id VARCHAR(19),
- in_filing_type VARCHAR(5),
- in_ein VARCHAR(19),
- in_tax_period VARCHAR(19),
- in_sub_date VARCHAR(22),
- in_taxpayer_name VARCHAR(100),
- in_return_type VARCHAR(5),
- in_dln VARCHAR(19),
- in_object_id VARCHAR(19)
- );
-
- /*
- In the first step, we are sending statements to remove old tables
- and create a new one.
- This step replies on configuration stored in `od_IRS` operator
- */
- STEP st_Setup_Tables
- (
- APPLY
- ('DROP TABLE ' || @LoadLogTable || ';'),
- ('DROP TABLE ' || @LoadErrorTable1 || ';'),
- ('DROP TABLE ' || @LoadErrorTable2 || ';'),
- ('DROP TABLE ' || @LoadTargetTable || ';'),
- ('CREATE TABLE ' || @LoadTargetTable || ' (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
- )
- PRIMARY INDEX ( return_id );')
- TO OPERATOR ($DDL);
- );
-
- /*
- Finally, in this step we read the data from the file operator
- and send it to the load operator.
- */
- STEP st_Load_File
- (
- APPLY
- ('INSERT INTO ' || @LoadTargetTable || ' (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );')
- TO OPERATOR ($LOAD)
- SELECT * FROM OPERATOR($FILE_READER(SCHEMA_IRS));
- );
-);ジョブを実行する:
-tbuild -f load.txt -v jobvars.txt -j file_load実行が成功すると、以下のようなログが返されます。
-Teradata Parallel Transporter Version 17.10.00.10 64-Bit -The global configuration file '/opt/teradata/client/17.10/tbuild/twbcfg.ini' is used. - Log Directory: /opt/teradata/client/17.10/tbuild/logs - Checkpoint Directory: /opt/teradata/client/17.10/tbuild/checkpoint - -Job log: /opt/teradata/client/17.10/tbuild/logs/file_load-4.out -Job id is file_load-4, running on osboxes -Teradata Parallel Transporter SQL DDL Operator Version 17.10.00.10 -od_IRS: private log not specified -od_IRS: connecting sessions -od_IRS: sending SQL requests -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_lg' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_et' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_uv' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: disconnecting sessions -od_IRS: Total processor time used = '0.013471 Second(s)' -od_IRS: Start : Thu Apr 7 20:56:32 2022 -od_IRS: End : Thu Apr 7 20:56:32 2022 -Job step st_Setup_Tables completed successfully -Teradata Parallel Transporter Load Operator Version 17.10.00.10 -ol_IRS: private log not specified -Teradata Parallel Transporter DataConnector Operator Version 17.10.00.10 -op_IRS[1]: Instance 1 directing private log report to 'dtacop-root-368731-1'. -op_IRS[1]: DataConnector Producer operator Instances: 1 -op_IRS[1]: ECI operator ID: 'op_IRS-368731' -op_IRS[1]: Operator instance 1 processing file 'index_2020.csv'. -ol_IRS: connecting sessions -ol_IRS: preparing target table -ol_IRS: entering Acquisition Phase -ol_IRS: entering Application Phase -ol_IRS: Statistics for Target Table: 'irs.irs_returns' -ol_IRS: Total Rows Sent To RDBMS: 333722 -ol_IRS: Total Rows Applied: 333722 -ol_IRS: Total Rows in Error Table 1: 0 -ol_IRS: Total Rows in Error Table 2: 0 -ol_IRS: Total Duplicate Rows: 0 -op_IRS[1]: Total files processed: 1. -ol_IRS: disconnecting sessions -Job step st_Load_File completed successfully -Job file_load completed successfully -ol_IRS: Performance metrics: -ol_IRS: MB/sec in Acquisition phase: 9.225 -ol_IRS: Elapsed time from start to Acquisition phase: 2 second(s) -ol_IRS: Elapsed time in Acquisition phase: 5 second(s) -ol_IRS: Elapsed time in Application phase: 3 second(s) -ol_IRS: Elapsed time from Application phase to end: < 1 second -ol_IRS: Total processor time used = '0.254337 Second(s)' -ol_IRS: Start : Thu Apr 7 20:56:32 2022 -ol_IRS: End : Thu Apr 7 20:56:42 2022 -Job start: Thu Apr 7 20:56:32 2022 -Job end: Thu Apr 7 20:56:42 2022-
TPT vs. NOSこの例では、ファイルは S3 バケット内にあります。つまり、Native Object Storage (NOS) を使用してデータを取り込むことができます。
--- create an S3-backed foreign table
-CREATE FOREIGN TABLE irs_returns_nos
- USING ( LOCATION('/s3/s3.amazonaws.com/irs-form-990/index_2020.csv') );
-
--- load the data into a native table
-CREATE MULTISET TABLE irs_returns_nos_native
- (RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME)
-AS (
- SELECT RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME FROM irs_returns_nos
-) WITH DATA
-NO PRIMARY INDEX;NOS ソリューションは追加のツールに依存しないため便利です。SQLのみで実装可能です。NOS タスクが AMP に委任され、並行して実行されるため、特に多数の AMP を備えた Vantage デプロイメント環境では良好なパフォーマンスを発揮します。また、オブジェクト ストレージ内のデータを複数のファイルに分割すると、パフォーマンスがさらに向上する可能性があります。
-| - - | --ご質問がある場合、またはさらにサポートが必要な場合は、コミュニティ フォーラムにアクセスしてサポートを受け、他のコミュニティ メンバーと交流してください。 - | -
- このクイックスタートでは、 Teradata Jupyter Notebook Demos for VantageCloud Lake をMicrosoft Azure上で実行するためのプロセスについて詳しく説明します。
-このセクションでは、以下の各手順について詳しく説明します。
-Teradata Jupyter Lab の拡張機能の Docker イメージに基づいて Microsoft Azure Web アプリを作成する
-Jupyter Lab の拡張機能の Azure Web アプリを構成する
-VantageCloud LakeのデモをJupyter Labの拡張機能であるAzure Web Appにロードする
-Jupyter Lab の拡張機能 Azure Web アプリの IP を確認する
-Microsoft Azureにログインして「APP Services」をクリックする
-
-「App Services」で「Webアプリ」をクリックするgitsi
-
-「Basics」タブで、次の操作を行います。
-ドロップダウンから適切なリソース グループを選択するか、新しいリソース グループを作成する
-ウェブアプリの名前を入力する
-「Publish」ラジオボタンオプションで「Docker Container」を選択する
-オペレーティングシステムとして「Linux」を選択する
-ドロップダウンから適切なリージョンを選択する
-適切なアプリケーションサービスプランを選択する持っていない場合は、デフォルトの構成で新しいものが作成する
-| - - | --VantageCloud Lake デモの目的では、冗長性は必要ありません - | -
このタブを完了したら、「Docker」タブをクリックして続行する
-
-「Docker」タブで、次の操作を行う
-ドロップダウンから「Single Container」を選択する
-「Image Source」ドロップダウンで「Docker Hub」を選択する
-「Access Type」ドロップダウンで「Public」を選択する
-「Image and tag」タイプにタイプする: teradata/jupyterlab-extensions:latest
| - - | --この App Service には起動コマンドは必要ありません - | -
「Review + Create」タブを選択して続行する
-
-「Review + Create」タブで、「Create」ボタンをクリックする
-
-デプロイが完了したら、「Go to Resource」ボタンをクリックしする
-
-右側のパネルで「Configuration」を選択する
-
-次のアプリケーション設定を追加する
-アプリケーションの設定 |
-値 |
-
accept_license |
-Y |
-
WEBSITES_PORT |
-8888 |
-
JUPYTER_TOKEN |
-使用するJupyter Labアクセストークンを定義します。 |
-
| - - | --「JUPYTER_TOKEN」構成を含めない場合、コンテナーは新しいトークンを生成し、コンソールに記録します。アプリケーション ログから取得する必要があります。「JUPYTER_TOKEN」構成キーを含めて値を空白のままにすると、システムはトークンを空の文字列として設定し、その結果、トークン セキュリティのない保護されていない Jupyter Lab 環境が作成されます。 - | -
保存をクリックすると、アプリが再起動される
-
-右側のパネルの「Overview」タブに戻る
-デフォルトドメインをクリックする
-
-Jupyter Labの開始ダイアログで、定義されたJupyterトークンを入力し、Log inをクリックする
-
-Jupyter Labコンソールで、gitアイコンをクリックする
-
-次のURIを対応するフィールドにコピーする
-[Clone]をクリックする
-
-Jupyter Lab コンソールで、lake-demos フォルダをクリックする
-
-JupyterLab で、Teradata Python カーネルを含むノートブックを開き、次のコマンドを実行してノートブック インスタンスの IP アドレスを見つけます。
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)次のステップでは、VantageCloud Lake 環境でこの IP をホワイトリストに登録して、接続を許可する
-これは、このガイドとノートブックのデモのためのものです。実稼働環境では、より堅牢なネットワーク設定が必要になる場合がある
-Azure App Service は、サービスが公開する可能性のあるすべての IP アドレスのリストも提供します。これは、「Overview」タブの下にある
-
-VantageCloud Lake 環境の設定で、ノートブック インスタンスの IP を追加する
-| - - | --Lake環境は複数のアドレスのホワイトリストをサポートします - | -
-vars.json は、VantageCloud Lake 環境の構成に一致するように編集する必要がある
-
-特に次の値を追加する必要がある
-| 変数 | -値 | -
|---|---|
"host" |
-VantageCloud Lake 環境からのパブリック IP 値 |
-
"UES_URI" |
-VantageCloud Lake 環境からの Open Analytics |
-
dbc" |
-VantageCloud Lake 環境のマスター パスワード |
-
サンプル vars.json では、すべてのユーザーのパスワードがデフォルトで「password」に設定されていることがわかります。これは説明を目的としたものであり、これらのパスワード フィールドをすべて強力なパスワードに変更し、必要に応じて保護し、次の手順を実行する必要があります。 その他のパスワード管理のベスト プラクティス。
-| - - | --vars.json ファイル内のすべてのパスワードを忘れずに変更してください。 - | -
0_Demo_Environment_Setup.ipynb のすべてのセルを開いて実行し、環境変数を設定する続いて 1_Demo_Setup_Base_Data.ipynb を実行して、デモに必要な基本データをロードします。
-デモノートブックの詳細については、GitHubの Teradata Lake demos ページを参照してください。
-
- インストールされた Docker Desktop
-インストールされた Git
-git repoをダウンロードする必要がある https://github.com/Teradata/lake-demos.git
-Teradata VantageCloud Lakeアカウント ログイン
-Teradata のウェルカム レターにある組織の URL とログインの詳細
-選択したIDE
-VantageCloud Lake をはじめる に従って、独自の環境を作成します。
-作成したら、[SETTINGS] タブに移動し、https://quickstarts.teradata.com/getting-started-with-vantagecloud-lake.html#_access_environment_from_public_internet[環境にアクセスする] ためのパブリック IP アドレスを指定します。
| - - | --IP アドレスは WhatIsMyIp.com のWeb サイトから確認できます。IPv4アドレスに注記してください。 - | -
-環境カードには「Public internet 」アクセスと表示されるはずです。
-
-OVERVIEW タブから、 - をコピーする。 -* Public IP および -* Open Analytics Endpoint
-これらの値は、DockerからVantageCloud Lakeにアクセスするために必要です。
-
-ローカル マシンで VantageCloud Lake デモ リポジトリのクローンを作成します。
-git clone https://github.com/Teradata/lake-demos.git
-cd lake-demosリポジトリにはさまざまなファイルとフォルダーが含まれています。重要なものは次のとおりです。
-Jupyter Notebook
-0_Demo_Environment_Setup.ipynbhttps://github.com/Teradata/lake-demos/blob/main/0_Demo_Environment_Setup.ipynb[]
-Jupyter NotebookをVantageCloud Lakeに接続するには、 vars.jsonファイル を編集して、次の情報を提供する必要があります。
-| 変数 | -値 | -
|---|---|
"host" |
-*OVERVIEW*セクションの Public IP 値(上記を参照) |
-
"UES_URI" |
-OVERVIEW セクションからのOpen Analytics Endpoint 値(上記を参照) |
-
dbc" |
-VantageCloud Lake環境のマスターパスワード |
-
| - - | --サンプル vars.json では、すべてのユーザーのパスワードはデフォルトで「password」に設定されていますが、これは説明を目的としたものです。これらのパスワード フィールドをすべて強力なパスワードに変更し、必要に応じて保護し、他のパスワード管理のベスト プラクティスに従う必要があります。 - | -
VantageCloud Lake デモを実行するには、https://hub.docker.com/r/teradata/jupyterlab-extensions[Teradata Jupyter Extensions for Docker] が必要です。 この拡張機能は、SQL ipython カーネル、Teradata への接続を管理するユーティリティ、および Teradata データベースとの対話時の生産性を高めるデータベース オブジェクト エクスプローラを提供します。
-| - - | --デモ リポジトリのクローンを作成したのと同じフォルダー内ですべてのコマンドを実行していることを確認してください。 - | -
コンテナを起動し、既存のlake-demosディレクトリにバインドします。オペレーティング システムに応じて、適切なコマンドを選択します。
-| - - | --Windowsの場合は、PowerShellでdockerコマンドを実行する。 - | -
docker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v ${PWD}:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensions
-dockerログのURLをクリックして、ブラウザでJupyter Notebookを開きます。
-
-0_Demo_Environment_Setup.ipynb 内のすべてのセルを開いて実行して環境をセットアップし、続いて 1_Demo_Setup_Base_Data.ipynb を実行してデモに必要な基本データをロードします。
-+
-
-デモ用のNotebookの詳細については、GGitHubの Teradata Lake demos ページを参照してください。
-このクイック スタートでは、Docker の Jupyter Notebook から Teradata VantageCloud Lake デモを実行する方法を学びました。
-
- このクイックスタートでは、Google Cloud の AI/ML プラットフォームである Vertex AI で Teradata Jupyter Notebook Demos for VantageCloud Lake を実行する方法について説明します。
-Teradata modules for Jupyter Linuxデスクトップ版(ダウンロードは こちら 、登録が必要です)
-Vertex AI と Notebooks API が有効になっている Google Cloud アカウント
-起動スクリプトと Teradata Jupyter 拡張パッケージを保存するための Google クラウド ストレージ
-新しいNotebookインスタンスを作成するときに、起動スクリプトを指定できます。このスクリプトはインスタンスの作成後に 1 回だけ実行され、Teradata Jupyter 拡張機能パッケージをインストールし、新しいユーザー管理のノートブック インスタンスに GitHub リポジトリのクローンを作成します。
-Teradata Jupyter拡張パッケージをダウンロードする
-Vantage Modules for Jupyterページ -にアクセスする- サインインして、Teradata Linuxバージョンのパッケージをダウンロードする。
-Google Cloud Storage Bucketを作成する
-プロジェクトに関連した名前でバケットを作成する(例: teradata_jupyter)でバケットを作成する。
-バケット名がグローバルに一意であることを確認する。たとえば、teradata_jupyter という名前がすでに使用されている場合、後続のユーザーはその名前を使用できません。
-
-解凍された Jupyter 拡張機能パッケージを Google Cloud Storage バケットにファイルとしてアップロードする。
-次の起動スクリプトを作成し、startup.sh としてローカルマシンに保存する。
以下は、Google Cloud Storage バケットから Teradata Jupyter 拡張機能パッケージを取得し、Teradata SQL カーネル、拡張機能をインストールし、lake-demos リポジトリのクローンを作成するスクリプトの例です。
-| - - | -
-
-
-gsutil cp コマンドの teradata_jupyter を忘れずに置き換えてください。 - |
-
#! /bin/bash
-
-cd /home/jupyter
-mkdir teradata
-cd teradata
-gsutil cp gs://teradata_jupyter/* .
-unzip teradatasql*.zip
-
-# Install Teradata kernel
-cp teradatakernel /usr/local/bin
-
-jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-# Install Teradata extensions
-pip install --find-links . teradata_preferences_prebuilt
-pip install --find-links . teradata_connection_manager_prebuilt
-pip install --find-links . teradata_sqlhighlighter_prebuilt
-pip install --find-links . teradata_resultset_renderer_prebuilt
-pip install --find-links . teradata_database_explorer_prebuilt
-
-# PIP install the Teradata Python library
-pip install teradataml==17.20.00.04
-
-# Install Teradata R library (optional, uncomment this line only if you use an environment that supports R)
-#Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"
-
-# Clone the Teradata lake-demos repository
-su - jupyter -c "git clone https://github.com/Teradata/lake-demos.git"このスクリプトをファイルとしてGoogle Cloudストレージバケットにアップロードする
-
-頂点AIワークベンチにアクセスする
-Google Cloud コンソールの Vertex AI Workbench に戻る。
-詳細オプションを使用するか、https://notebook.new/で直接、新しいユーザー管理ノートブックを作成する。
-Details(詳細)で、ノートブックに名前を付け、リージョンを選択して続行する。
-
-Environment(環境)で Browse(参照) を選択して、Google Cloud Bucketからstartup.shスクリプトを選択する。
-
-「Create (作成)」を選択してノートブックを開始する。Notebookの作成が完了するまで、数分かかる場合があります。完了したら、「OPEN JUPYTERLAB」をクリックします。
-
-| - - | -
-
-
-接続を許可するには、VantageCloud Lake 環境でこの IP をホワイトリストに登録する必要があります。このソリューションは試用環境に適しています。実稼働環境の場合、VPC、サブネット、セキュリティ グループの構成を構成し、ホワイトリストに登録する必要がある場合があります。 - |
-
JupyterLab で、Python カーネルを含むノートブックを開き、次のコマンドを実行してノートブック インスタンスの IP アドレスを見つけます。
-
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)VantageCloud Lake環境で、[設定]の下にノートブックインスタンスのIPアドレスを追加します。
-
-ノートブックの lake-demos ディレクトリに移動します。
-vars.jsonを右クリックして、エディタでファイルを開きます。
-
-*https://github.com/Teradata/lake-demos/blob/main/vars.json[vars.json file]*ファイルを編集して、デモを実行するために必要な認証情報を含めます。
変数 |
-値 |
-
"host" |
-VantageCloud Lakeの環境から得られるPublic IP値 |
-
"UES_URI" |
-VantageCloud Lake 環境からの Open Analytics |
-
dbc" |
-VantageCloud Lake 環境のマスター パスワード |
-
Public IPアドレスとOpen Analyticsエンドポイントを取得するには、次の 手順 に従います。
-| - - | --vars.json ファイルのパスワードを変更します。サンプル vars.json では、すべてのユーザーのパスワードがデフォルトで「password」に設定されていることがわかります。これはサンプル ファイルの問題にすぎず、これらのパスワードをすべて変更する必要があります。 フィールドを強力なパスワードに設定し、必要に応じて保護し、他のパスワード管理のベスト プラクティスに従ってください。 - | -
0_Demo_Environment_Setup.ipynb 内のすべてのセルを実行して、環境をセットアップします。続いて 1_Demo_Setup_Base_Data.ipynb を実行して、デモに必要な基本データをロードします。
-デモ ノートブックの詳細については、GitHubの Teradata Lake demos ページを参照してください。
-このクイックスタート ガイドでは、VantageCloud Lake の Teradata Jupyter Notebook Demos を実行するように Google Cloud Vertex AI Workbench Notebooks を構成しました。
-
- このクイックスタートでは、AWS の AI/ML プラットフォームである Amazon SageMaker で Teradata Jupyter Notebook Demos for VantageCloud Lake を実行するプロセスについて詳しく説明します。
-Teradata modules for Jupyter (ダウンロードは こちら 、登録が必要です)
-S3 および SageMaker にアクセスできる AWS アカウント
-このセクションでは、以下の各手順について詳しく説明します。
-Teradata modules for JupyterをS3バケットにアップロードする
-Jupyter ノートブック インスタンスの IAM ロールを作成する
-Jupyter ノートブック インスタンスのライフサイクル構成を作成する
-Jupyter ノートブック インスタンスを作成する
-Jupyter ノートブック インスタンスの IP CIDR を検索する
-AWS S3 でバケットを作成し、割り当てられた名前を記録する
-デフォルトのオプションは、このバケットに適している
-作成したバケットに Jupyter 用の Teradata モジュールをアップロードする
-
-SageMaker でロールマネージャに移動する
-
-新しいロールの作成する(まだ定義されていない場合)
-このガイドの目的上、作成されたロールにはデータ サイエンティストのペルソナに割り当てる
-
-設定に関しては、デフォルトのままにするのが適切です
-対応する画面で、Teradata Jupyter モジュールをアップロードしたバケットを定義する
-
-次の設定では、S3 バケットへのアクセスに対応するポリシーを追加する
-
-SageMaker でライフサイクル構成に移動し、作成をクリックする
-
-次のスクリプトを使用してライフサイクル構成を定義する
-Windows 環境で作業する場合は、スクリプトをライフサイクル構成エディターに 1 行ずつコピーすることをお勧めします。コピーの問題を回避するには、エディターで各行の後で直接「Enter」を押します。このアプローチは、Windows と Linux のエンコーディングの違いによって発生する可能性のあるキャリッジ リターン エラーを防ぐのに役立ちます。このようなエラーは多くの場合、「/bin/bash^M: bad interpreter」として現れ、スクリプトの実行を中断する可能性があります。
-
-スクリプトの作成時:
-#!/bin/bash
-
-set -e
-
-# This script installs a custom, persistent installation of conda on the Notebook Instance's EBS volume, and ensures
-# that these custom environments are available as kernels in Jupyter.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-# Install a separate conda installation via Miniconda
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-mkdir -p "$WORKING_DIR"
-wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
-bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda"
-rm -rf "$WORKING_DIR/miniconda.sh"
-# Create a custom conda environment
-source "$WORKING_DIR/miniconda/bin/activate"
-KERNEL_NAME="teradatasql"
-
-PYTHON="3.8"
-conda create --yes --name "$KERNEL_NAME" python="$PYTHON"
-conda activate "$KERNEL_NAME"
-pip install --quiet ipykernel
-
-EOFスクリプトの開始時 (このスクリプトではバケットの名前を置き換え、Jupyter モジュールのバージョンを確認します)
-#!/bin/bash
-
-set -e
-
-# This script installs Teradata Jupyter kernel and extensions.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-
-source "$WORKING_DIR/miniconda/bin/activate" teradatasql
-
-# Install teradatasql, teradataml, and pandas in the teradatasql environment
-pip install teradataml
-pip install pandas
-
-# fetch Teradata Jupyter extensions package from S3 and unzip it
-mkdir -p "$WORKING_DIR/teradata"
-aws s3 cp s3://resources-jp-extensions/teradatasqllinux_3.4.1-d05242023.zip "$WORKING_DIR/teradata"
-cd "$WORKING_DIR/teradata"
-unzip -o teradatasqllinux_3.4.1-d05242023
-cp teradatakernel /home/ec2-user/anaconda3/condabin
-jupyter kernelspec install --user ./teradatasql
-source /home/ec2-user/anaconda3/bin/activate JupyterSystemEnv
-
-# Install other Teradata-related packages
-pip install teradata_connection_manager_prebuilt-3.4.1.tar.gz
-pip install teradata_database_explorer_prebuilt-3.4.1.tar.gz
-pip install teradata_preferences_prebuilt-3.4.1.tar.gz
-pip install teradata_resultset_renderer_prebuilt-3.4.1.tar.gz
-pip install teradata_sqlhighlighter_prebuilt-3.4.1.tar.gz
-
-conda deactivate
-EOFSageMaker で、ノートブック、ノートブック インスタンスに移動し、ノートブック インスタンスを作成する
-ノートブックインスタンスの名前を選択し、サイズを定義する(デモの場合は、利用可能な小さいインスタンスで十分です)
-追加の構成をクリックして、最近作成したライフサイクル構成を割り当てる
-
-追加の構成をクリックして、最近作成したライフサイクル構成を割り当てる
-最近作成したIAMロールをノートブックインスタンスに割り当てる
-
-次のリンクhttps://github.com/Teradata/lake-demosを、ノートブックインスタンスのデフォルトのgithubリポジトリとしてペーストする
-
-インスタンスが実行されたら、「JupyterLab を開く」をクリックします。
-
-
-JupyterLab で、Teradata Python カーネルを含むノートブックを開き、次のコマンドを実行してノートブック インスタンスの IP アドレスを見つけます。
-接続を許可するために、VantageCloud Lake 環境でこの IP をホワイトリストに登録します。
-これは、このガイドとノートブックのデモを目的としています。実稼働環境の場合、VPC、サブネット、セキュリティ グループの構成を構成し、ホワイトリストに登録する必要がある場合があります。
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)VantageCloud Lake 環境の設定で、ノートブック インスタンスの IP を追加する
-
-vars.json は、VantageCloud Lake 環境の構成に一致するように編集する必要がある
-
-特に次の値を追加する必要があります
-| 変数 | -値 | -
|---|---|
"host" |
-VantageCloud Lake 環境からのPublic IP値 |
-
"UES_URI" |
-VantageCloud Lake 環境からの Open Analytics |
-
dbc" |
-VantageCloud Lake環境のマスターパスワード |
-
| - - | --vars.json ファイル内のすべてのパスワードを忘れずに変更してください。 - | -
サンプル vars.json では、すべてのユーザーのパスワードがデフォルトで「password」に設定されていることがわかります。これは説明を目的としたものであり、これらのパスワード フィールドをすべて強力なパスワードに変更し、必要に応じて保護し、次の手順を実行する必要があります。 その他のパスワード管理のベスト プラクティス。
-0_Demo_Environment_Setup.ipynb のすべてのセルを開いて実行し、環境変数を設定します。続いて 1_Demo_Setup_Base_Data.ipynb を実行して、デモに必要な基本データをロードします。
-デモ ノートブックの詳細については、GGitHubの Teradata Lake demos ページを参照してください。
-
- Visual Studio Code は、Windows、MacO、Linux と互換性のある人気のオープンソース コード エディタです。開発者は、アプリケーションのコーディング、デバッグ、構築、展開にこの統合開発環境 (IDE) を使用します。このクイックスタート ガイドでは、Visual Studio Code 内で VantageCloud Lake Jupyter ノートブック デモを起動します。
-
-始める前に、次の前提条件が整っていることを確認します。
-インストールされた Docker Desktop
-インストールされた Git
-git repoをダウンロードする必要がある https://github.com/Teradata/lake-demos.git
-インストールされた Visual Studio Code
-Teradata ウェルカム レターの組織 URL とログイン詳細を含む Teradata VantageCloud Lake アカウント
-ログインしたら、次の 手順 に従って VantageCloud Lake 環境を作成する
-まず、GitHub リポジトリのクローンを作成し、プロジェクト ディレクトリに移動する。
-git clone https://github.com/Teradata/lake-demos.git
-cd lake-demosVantageCloud Lake デモを起動するには、 Teradata Jupyter Extensions for Docker が必要です。 これらの拡張機能は、SQL ipython カーネル、Teradata への接続を管理するユーティリティ、および Teradata データベースとの対話時の生産性を高めるデータベース オブジェクト エクスプローラを提供します。
-次に、コンテナを起動し、既存の lake-demos ディレクトリにバインドします。オペレーティング システムに基づいて適切なコマンドを選択します。
-| - - | --Windows の場合は、PowerShell で docker コマンドを実行します。 - | -
docker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v ${PWD}:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensions結果の URL とトークンをメモします。 これらは、Visual Studio Code から接続を確立するために必要になります。
-
-Visual Studio Codeで lake-demos プロジェクトディレクトリを開く。リポジトリには次のプロジェクト ツリーが含まれている。
LAKE_DEMOS
-vars.json file ファイルを編集して、デモを実行するために必要な認証情報を含める
-+
-変数 |
-値 |
-
"host" |
-VantageCloud Lake 環境からの Public IP値 |
-
"UES_URI" |
-VantageCloud Lake 環境からの Open Analytics |
-
"dbc" |
-VantageCloud Lake 環境のマスター パスワード |
-
Public IPアドレスとOpen Analyticsエンドポイントを取得するには、次の 手順 に従います。
-| - - | --vars.json ファイルのパスワードを変更します。 - サンプル vars.json では、すべてのユーザーのパスワードがデフォルトで「password」に設定されていることがわかります。これはサンプル ファイルに関するものであり、これらのパスワード フィールドをすべて強力なパスワードに変更し、必要に応じて保護する必要があります。 他のパスワード管理のベスト プラクティスに従ってください。 - | -
ユースケースディレクトリでは、すべての.ipynbファイルは、Jupyterlabから作業するときに、パス././vars.jsonを使用してJSONファイルから変数をロードする。Visual Studio Code から直接作業するには、vars.json を指すように各 .ipynb 内のコードを更新します。
-これらの変更を行う最も簡単な方法は、左側の垂直 メニューの検索機能を使用することです。検索対象
-'../../vars.json'-
次のように置換します。
-'vars.json'-
-
-0_Demo_Environment_Setup.ipynb を開き、Visual Studio Codeの右上にあるSelect Kernelをクリックします。
-Jupyter および Python 拡張機能をインストールしていない場合は、Visual Studio Code によってそれらをインストールするように求められます。これらの拡張機能は、Visual Studio Code がカーネルを検出するために必要です。これらをインストールするには、「Install/Enable suggested extensions for Python and Jupyter」を選択します。
-
-必要な拡張機能をインストールすると、ドロップダウン メニューにオプションが表示されます。既存のJupyterカーネル を選択します。
-
-実行中の Jupyter Server の URL を入力し、Enter キーを押します。
-http://localhost:8888-
-ファイルを Docker コンテナにマウントするときにターミナルで見つかったトークンを入力し、Enter キーを押します。
-
-サーバー表示名を変更する (URL を使用するには空白のままにします)
-
-これで、すべての Teradata Vantage 拡張カーネルにアクセスできるようになりました。実行中の Jupyter サーバーから Python 3 (ipykernel) を選択します。
-
-0_Demo_Environment_Setup.ipynb 内のすべてのセルを実行して、環境をセットアップします。続いて 1_Demo_Setup_Base_Data.ipynb を実行して、デモに必要な基本データをロードします。 -デモ ノートブックの詳細については、GGitHubの Teradata Lake demos ページを参照してください。
-
-このクイックスタート ガイドでは、Jupyter ノートブックを使用して VantageCloud Lake デモにアクセスするように Visual Studio Code を構成しました。
-This how-to demonstrates how to connect to Teradata Vantage using JDBC using a sample Java application: https://github.com/Teradata/jdbc-sample-app.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
JDK
-Maven
-Add the Teradata JDBC driver as a dependency to your Maven POM XML file:
-| - - | -
-This step assumes that your Vantage database is available on localhost on port 1025. If you are running Vantage Express on your laptop, you need to expose the port from the VM to the host machine. Refer to your virtualization software documentation how to forward ports.
- |
-
The project is set up. All that is left, is to load the driver, pass connection and authentication parameters and run a query:
-This how-to demonstrated how to connect to Teradata Vantage using JDBC. It described a sample Java application with Maven as the build tool that uses the Teradata JDBC driver to send SQL queries to Teradata Vantage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Vertex AI is Google's single environment for data scientists to develop and deploy ML models, from experimentation, to deployment, to managing and monitoring models. In this tutorial, we will show how to integrate Vantage Analytics capabilites in Vertex AI ML Pipelines. We'll create two pipelines:
-Training - the first will be a three step pipeline to train and deploy a model; the first step transforms data in Vantage and then exports a file for training, the second step trains a model using scikit-learn, and the final step deploys the model to Vantage using Bring Your Own Model (BYOM) feature of Teradata Vantage.
-
Scoring - the second pipeline will use the model created by the the first pipeline to score new data stored in a table on Vantage.
-
Both pipelines are very simple, but the first pipeline could be triggered to retrain a model with new data when the production model has drifted. The second pipeline could be run on a regular schedule when new data for scoring was available.
- -import sys
-!{sys.executable} -m pip install --upgrade --force-reinstall ipython-sql
-!{sys.executable} -m pip install teradatasqlalchemy teradataml kaggle ipython-sql kfp
-Follow the Run Vantage Express on Google Cloud how-to to get Vantage setup. Make sure to follow the instructions to open the VM up to the Internet.
-You will need a GCS bucket to store artifacts managed by KubeFlow.
-Define the bucket name:
- -BUCKET_NAME = "<your-bucket-name>"
-If the bucket doesn't exist, go ahead and create it:
- -!gsutil ls -b gs://$BUCKET_NAME || gsutil mb gs://$BUCKET_NAME
-Go to IAM tab in GCS console and assign Storage Admin role to your default Compute Engine. The principal of the default Compute Engine account looks like this: <project-id>-compute@developer.gserviceaccount.com.
We'll use the Boston Housing dataset which can be obtained from Kaggle.
-Login to your Kaggle account. In the top right corner click on your user icon and select Account. Find API section and click on Create New API Token. This will produce kaggle.json file. Open kaggle.json and copy the username and key. Substitute the values in the cell and run it:
%env KAGGLE_USERNAME=<your-kaggle-username>
-%env KAGGLE_KEY=<your-kaggle-key>
-!kaggle datasets download -f housing.csv vikrishnan/boston-house-prices
-Let's setup DATABASE_URL environment variable that will point to your instance of Vantage. Make sure that you default to mldb database where BYOM package is installed, e.g.:
DATABASE_URL='teradatasql://dbc:dbc@34.121.78.209/mldb'
-%env DATABASE_URL=$DATABASE_URL
-import pandas
-import os
-
-df=pandas.read_fwf('housing.csv', names=['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV'])
-df.to_sql('housing', con=DATABASE_URL, index=False)
-For this tutiorial we need a table to store the trained model and another table with some new data that we want to score with our model. Use teradatasql to execute the following SQL on your Vantage instance.
- -%%sql
-CREATE SET TABLE demo_models (model_id VARCHAR (30), model BLOB) PRIMARY INDEX (model_id);
-CREATE SET TABLE test_housing (ID INTEGER, CRIM FLOAT, ZN FLOAT,INDUS FLOAT,CHAS INTEGER,NOX FLOAT,RM FLOAT,
- AGE FLOAT,DIS FLOAT, RAD INTEGER,TAX INTEGER,PTRATIO FLOAT,B FLOAT,LSTAT FLOAT) PRIMARY INDEX (CRIM);
-INSERT INTO test_housing (ID, CRIM, ZN, INDUS, CHAS, NOX, RM, AGE, DIS, RAD, TAX, PTRATIO, B, LSTAT)
- VALUES (1,.02,0.0,7.07,0,.46,6.4,78.9,4.9,2,242,17.8,396.9,9.14);
-Now we are ready to create the components in the pipeline. Vertex AI Pipelines can run pipelines built using the Kubeflow Pipelines SDK or TensorFlow Extended. We'll be using the Kubeflow Pipelines SDK for this simple example using scikit-learn.
-In this example we will create the following three components:
-read_data_from_vantagetrain_modeldeploy_modelFirst, import the Kubeflow Pipeline component and dsl packages.
- -import kfp.v2.dsl as dsl
-from kfp.v2.dsl import (
- component,
- Input,
- Output,
- Dataset,
- Model,
- Metrics,
-)
-The first component reads data from a Vantage warehouse (see above and make sure you have set up Vantage Express in Google Cloud including opening up a firewall to the VM so you can access Vantage from the Internet.)
- -The component connects to Vantage using the connection string passed as an input parameter, reads the rows from the table mldb.housing in Vantage and then outputs the data to an Output[Dataset]. The Output is a temporary file used to pass data between components (see more about passing data between components here).
The component uses sqlalchemy to talk to Teradata. Each component is run in a separate container on Kubernetes so all import statements need to be done within the component. We have created a base image with teradatasql already installed. When you pass base_image='python' the component will use that image to create a container. packages_to_install parameter defines what other packages the component needs.
@component(base_image='python', packages_to_install=['teradatasqlalchemy'])
-def read_data_from_vantage(
- connection_string: str,
- output_file: Output[Dataset]
-):
- import sqlalchemy
-
- file_name = output_file.path
- engine = sqlalchemy.create_engine(connection_string)
-
- with engine.connect() as con:
- rs = con.execute('SELECT * FROM housing')
- with open(output_file.path, 'w') as output_file:
- output_file.write('CRIM,ZN,INDUS,CHAS,NOX,RM,AGE,DIS,RAD,TAX,PTRATIO,B,LSTAT,MEDV\n')
- for row in rs:
- output_file.write(','.join([str(i) for i in row]) + '\n')
-Next we'll create a component to train a model with the training data.
-The input into this component is the file from the previous component. The output is the file with the trained model using joblib.dump and a file with the test data.
-The component will use scikit-learn and pandas so we need to pass packages_to_install=['pandas==1.3.5','scikit-learn'] - this will tell Kubeflow to install the packages when the container is created.
@component(base_image='teradata/python-sklearn2pmml', packages_to_install=['pandas==1.3.5','scikit-learn','sklearn-pandas==1.5.0'])
-def train_model(
- input_file : Input[Dataset],
- output_model: Output[Model],
- output_metrics: Output[Metrics]
-):
- import pandas as pd
- from sklearn.model_selection import train_test_split
- from sklearn.ensemble import RandomForestRegressor
- from sklearn.preprocessing import StandardScaler
- from sklearn import metrics
- from sklearn_pandas import DataFrameMapper
- import joblib
- from sklearn2pmml.pipeline import PMMLPipeline
- from sklearn2pmml import sklearn2pmml
-
- df = pd.read_csv(input_file.path)
-
- train, test = train_test_split(df, test_size = .33)
- train = train.apply(pd.to_numeric, errors='ignore')
- test = test.apply(pd.to_numeric, errors='ignore')
-
- target = 'MEDV'
- features = train.columns.drop(target)
-
-
- pipeline = PMMLPipeline([
- ("mapping", DataFrameMapper([
- (['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT'], StandardScaler())
- ])),
- ("rfc", RandomForestRegressor(n_estimators = 100, random_state = 0))
- ])
-
- pipeline.fit(train[features], train[target])
- y_pred = pipeline.predict(test[features])
-
- metric_accuracy = metrics.mean_squared_error(y_pred,test[target])
- output_metrics.log_metric('accuracy', metric_accuracy)
- output_model.metadata['accuracy'] = metric_accuracy
-
- joblib.dump(pipeline, output_model.path)
-
-The last component loads the model and tests it on the test data. The Output[Metrics] creates an artifact with the models performance and can be visualize in the Runtime Graph.
@component(base_image='teradata/python-sklearn2pmml')
-def deploy_model(
- connection_string: str,
- input_model : Input[Model],
-):
- import sqlalchemy
- import teradataml as tdml
- import joblib
- from sklearn2pmml.pipeline import PMMLPipeline
- from sklearn2pmml import sklearn2pmml
-
- engine = sqlalchemy.create_engine(connection_string)
- tdml.create_context(tdsqlengine = engine)
-
- pipeline = joblib.load(input_model.path)
-
- sklearn2pmml(pipeline, "test_local.pmml", with_repr = True)
-
- model_id = 'housing_rf'
- model_file = 'test_local.pmml'
- table_name = 'demo_models'
-
- tdml.configure.byom_install_location = "mldb"
-
- try:
- res = tdml.save_byom(model_id = model_id, model_file = model_file, table_name = table_name)
- except Exception as e:
- # if our model exists, delete and rewrite
- if str(e.args).find('TDML_2200') >= 1:
- res = tdml.delete_byom(model_id = model_id, table_name = table_name)
- res = tdml.save_byom(model_id = model_id, model_file = model_file, table_name = table_name)
- pass
- else:
- raise
-
-Now we'll create a function to execute each component in the pipeline.
- -@dsl.pipeline(
- name='run-vantage-pipeline',
- description='An example pipeline that connects to Vantage.',
-)
-def run_vantage_pipeline_vertex(
- connection_string: str
-):
- data_file = read_data_from_vantage(connection_string).output
- test_model_data = train_model(data_file)
- deploy_model(connection_string,test_model_data.outputs['output_model'])
-Compile the pipeline. The pipline will be saved in a json file with the name provided as the package_path.
from kfp.v2 import compiler
-compiler.Compiler().compile(pipeline_func=run_vantage_pipeline_vertex,
- package_path='train_housing_pipeline.json')
-Now use the Vertex AI client to execute the pipeline. Import the google.cloud.aiplatform package. Vertex AI needs a Cloud Storage bucket to for temporary files. Create a new job using the json file above and pass the ipaddr as the parameter. Then submit the job.
When the job starts a link will appear that will take you to the Runtime Graph.
- -import google.cloud.aiplatform as aip
-
-pipeline_root_path = 'gs://' + BUCKET_NAME
-
-job = aip.PipelineJob(
- display_name="housing_training_deploy",
- template_path="train_housing_pipeline.json",
- pipeline_root=pipeline_root_path,
- parameter_values={
- 'connection_string': DATABASE_URL
- }
-)
-
-job.submit()
-When the pipeline has completed running (each component in the graph should have a green check mark). You can click on each component to see details of the execution and the logs created. If you click on the output_metrics artifact, in the Pipeline run analysis window the Node Info will show the accuracy of the model. Yyou can learn more about other metrics you can pass and visulation using the Metrics artifict here.)
Let's test the model we have just deployed by scoring some new data. We'll use the teradataml driver to retrieve the saved model and score the rows in a table with new data.
import teradataml as tdml
-import sqlalchemy
-import os
-
-engine = sqlalchemy.create_engine(DATABASE_URL)
-eng = tdml.create_context(tdsqlengine = engine)
-
-#indicate the database that BYOM is using
-tdml.configure.byom_install_location = "mldb"
-
-tdf_test = tdml.DataFrame('test_housing')
-
-modeldata = tdml.retrieve_byom("housing_rf", table_name="demo_models")
-
-predictions = tdml.PMMLPredict(
- modeldata = modeldata,
- newdata = tdf_test,
- accumulate = ['ID']
- )
-predictions.result.to_pandas()
-This pipeline will have only one component that uses the teradatasql driver to execute a SQL query that retrieves the model from the demo_model table and scores the rows in the test_housing table.
@component(base_image='teradata/python-sklearn2pmml', packages_to_install=['pandas==1.3.5','scikit-learn'])
-def score_new_data(
- connection_string: str,
- model_name: str,
- model_table: str,
- data_table: str,
- prediction_table: str
-):
- import teradataml as tdml
- import sqlalchemy
-
- engine = sqlalchemy.create_engine(connection_string)
-
- with engine.connect() as con:
- con.execute(f'CREATE TABLE {prediction_table} AS (SELECT * FROM mldb.PMMLPredict ( ON {data_table} ON (SELECT * FROM {model_table} where model_id=\'{model_name}\') DIMENSION USING Accumulate (\'ID\')) AS td ) WITH DATA')
-
-The run_new_data_score pipeline takes the following parameters:
model_name: ID of the modelmodel_table: the name of the table storing the modeldata_table: the name of the table with new data to scoreprediction_table: the name of the table to store the scoring resultsWhen the pipeline is executed the dashboard will provide fields to enter the values you want to use.
- -@dsl.pipeline(
- name='new-data-pipeline',
- description='An example of a component that scores new data with a saved model.',
-)
-def run_new_data_score(
- connection_string: str,
- model_name: str,
- model_table: str,
- data_table: str,
- prediction_table: str
-):
- score_new_data(DATABASE_URL,model_name,model_table,data_table,prediction_table)
-To compile the pipeline run the following code. The pipeline will be saved in score_new_data_pipeline_sql.json file.
compiler.Compiler().compile(pipeline_func=run_new_data_score,
- package_path='score_new_data_pipeline_sql.json')
-We will now execute the pipeline in Vertex AI Pipelines.
- -import google.cloud.aiplatform as aip
-
-pipeline_root_path = 'gs://' + BUCKET_NAME
-
-job = aip.PipelineJob(
- display_name="new_data_housing",
- template_path="score_new_data_pipeline_sql.json",
- pipeline_root=pipeline_root_path,
- parameter_values={
- 'connection_string': DATABASE_URL,
- 'model_name': 'housing_rf',
- 'model_table': 'demo_models',
- 'data_table': 'test_housing',
- 'prediction_table': 'housing_predictions'
- }
-)
-
-job.submit()
-Once the job completes, you can view the batch predictions with:
- -%%sql
-SELECT * FROM housing_predictions;
-To stop incurring charges you need to clean up the following resources:
-Delete.| - Didn’t find a demo you were looking for? - | -- Contribute or request a demo - | -- request - contribute - | -
| - - | --This how-to shows you how to add Teradata Extensions to a Jupyter Notebooks environment. A hosted version of Jupyter Notebooks integrated with Teradata Extensions and analytics tools is available for functional testing for free at https://clearscape.teradata.com. - | -
In this how-to we will go through the steps for connecting to Teradata Vantage from a Jupyter notebook.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
There are a couple of ways to connect to Vantage from a Jupyter Notebook:
-Use python or R libraries in a regular Python/R kernel notebook - this option works well when you are in a restricted environment that doesn’t allow you to spawn your own Docker images. Also, it’s useful in traditional datascience scenarios when you have to mix SQL and Python/R in a notebook. If you are proficient with Jupyter and have your own set of preferred libraries and extensions, start with this option.
-Use the Teradata Jupyter Docker image - the Teradata Jupyter Docker image bundles the Teradata SQL kernel (more on this later), teradataml and tdplyr libraries, python and R drivers. It also contains Jupyter extensions that allow you to manage Teradata connections, explore objects in Vantage database. It’s convenient when you work a lot with SQL or would find a visual Navigator helpful. If you are new to Jupyter or if you prefer to get a currated assembly of libraries and extensions, start with this option.
This option uses a regular Jupyter Lab notebook. We will see how to load the Teradata Python driver and use it from Python code. We will also examine ipython-sql extension that adds support for SQL-only cells.
We start with a plain Jupyter Lab notebook. Here, I’m using docker but any method of starting a notebook, including Jupyter Hub, Google Cloud AI Platform Notebooks, AWS SageMaker Notebooks, Azure ML Notebooks will do.
-docker run --rm -p 8888:8888 -e JUPYTER_ENABLE_LAB=yes \
- -v "${PWD}":/home/jovyan/work jupyter/datascience-notebookDocker logs will display the url that you need to go to:
-Entered start.sh with args: jupyter lab -Executing the command: jupyter lab -.... -To access the server, open this file in a browser: - file:///home/jovyan/.local/share/jupyter/runtime/jpserver-7-open.html -Or copy and paste one of these URLs: - http://d5c2323ae5db:8888/lab?token=5fb43e674367c6895e8c2404188aa550b5c7bdf96f5b4a3a - or http://127.0.0.1:8888/lab?token=5fb43e674367c6895e8c2404188aa550b5c7bdf96f5b4a3a-
We will open a new notebook and create a cell to install the required libraries:
-| - - | --I’ve published a notebook with all the cells described below on GitHub: https://github.com/Teradata/quickstarts/blob/main/modules/ROOT/attachments/vantage-with-python-libraries.ipynb - | -
import sys
-!{sys.executable} -m pip install teradatasqlalchemyNow, we will import Pandas and define the connection string to connect to Teradata. Since I’m running my notebook in Docker on my local machine and I want to connect to a local Vantage Express VM, I’m using host.docker.internal DNS name provided by Docker to reference the IP of my machine.
import pandas as pd
-# Define the db connection string. Pandas uses SQLAlchemy connection strings.
-# For Teradata Vantage, it's teradatasql://username:password@host/database_name .
-# See https://pypi.org/project/teradatasqlalchemy/ for details.
-db_connection_string = "teradatasql://dbc:dbc@host.docker.internal/dbc"I can now call Pandas to query Vantage and move the result to a Pandas dataframe:
-pd.read_sql("SELECT * FROM dbc.dbcinfo", con = db_connection_string)The syntax above is concise but it can get tedious if all you need is to explore data in Vantage. We will use ipython-sql and its %%sql magic to create SQL-only cells. We start with importing the required libraries.
import sys
-!{sys.executable} -m pip install ipython-sql teradatasqlalchemyWe load ipython-sql and define the db connection string:
%load_ext sql
-# Define the db connection string. The sql magic uses SQLAlchemy connection strings.
-# For Teradata Vantage, it's teradatasql://username:password@host/database_name .
-# See https://pypi.org/project/teradatasqlalchemy/ for details.
-%sql teradatasql://dbc:dbc@host.docker.internal/dbcWe can now use %sql and %%sql magic. Let’s say we want to explore data in a table. We can create a cell that says:
%%sql
-SELECT * FROM dbc.dbcinfoIf we want to move the data to a Pandas frame, we can say:
-result = %sql SELECT * FROM dbc.dbcinfo
-result.DataFrame()There are many other features that ipython-sql provides, including variable substitution, plotting with matplotlib, writting results to a local csv file or back to the database. See the demo notebook for examples and ipython-sql github repo for a complete reference.
The Teradata Jupyter Docker image builds on jupyter/datascience-notebook Docker image. It adds the Teradata SQL kernel, Teradata Python and R libraries, Jupyter extensions to make you productive while interacting with Teradata Vantage. The image also contains sample notebooks that demonstrate how to use the SQL kernel and Teradata libraries.
The SQL kernel and Teradata Jupyter extensions are useful for people that spend a lot of time with the SQL interface. Think about it as a notebook experience that, in many cases, is more convenient than using Teradata Studio. The Teradata Jupyter Docker image doesn’t try to replace Teradata Studio. It doesn’t have all the features. It’s designed for people who need a lightweight, web-based interface and enjoy the notebook UI.
-The Teradata Jupyter Docker image can be used when you want to run Jupyter locally or you have a place where you can run custom Jupyter docker images. The steps below demonstrate how to use the image locally.
-Run the image:
-| - - | -
-By passing -e "accept_license=Y you accept the license agreement for Teradata Jupyter Extensions.
- |
-
docker volume create notebooks
-docker run -e "accept_license=Y" -p :8888:8888 \
- -v notebooks:/home/jovyan/JupyterLabRoot \
- teradata/jupyterlab-extensionsDocker logs will display the url that you need to go to. For example, this is what I’ve got:
-Starting JupyterLab ... -Docker Build ID = 3.2.0-ec02012022 -Using unencrypted HTTP - -Enter this URL in your browser: http://localhost:8888?token=96a3ab874a03779c400966bf492fe270c2221cdcc74b61ed - -* Or enter this token when prompted by Jupyter: 96a3ab874a03779c400966bf492fe270c2221cdcc74b61ed -* If you used a different port to run your Docker, replace 8888 with your port number-
Open up the URL and use the file explorer to open the following notebook: jupyterextensions → notebooks → sql → GettingStartedDemo.ipynb.
Go through the demo of the Teradata SQL Kernel:
-
-This quick start covered different options to connect to Teradata Vantage from a Jupyter Notebook. We learned about the Teradata Jupyter Docker image that bundles multiple Teradata Python and R libraries. It also provides an SQL kernel, database object explorer and connection management. These features are useful when you spend a lot of time with the SQL interface. For more traditional data science scenarios, we explored the standalone Teradata Python driver and integration through the ipython sql extension.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
For customers who have their own JupyterHub clusters, there are two options to integrate Teradata Jupyter extensions into the existing clusters:
-Use Teradata Jupyter Docker image.
-Customize an existing Docker image to include Teradata extensions.
-This page contains detailed instructions on the two options. Instructions are based on the assumption that the customer JupyterHub deployment is based on Zero to JupyterHub with Kubernetes.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Teradata provides a ready-to-run Docker image that builds on the jupyter/datascience-notebook image. It bundles the Teradata SQL kernel, Teradata Python and R libraries and drivers and Teradata extensions for Jupyter to make you productive while interacting with Teradata database. The image also contains sample notebooks that demonstrate how to use the SQL kernel, extensions and Teradata libraries.
-You can use this image in the following ways:
-Start a personal Jupyter Notebook server in a local Docker container
-Run JupyterLab servers for a team using JupyterHub
-For instructions to start a personal JupyterLab server in a local Docker container, please see installation guide. This section will focus on how to use the Teradata Jupyter Docker image in a customer’s existing JupyterHub environment.
-Go to Vantage Modules for Jupyter page and download the Docker image. It is a tarball with name in this format teradatajupyterlabext_VERSION.tar.gz.
Load the image:
-docker load -i teradatajupyterlabext_VERSION.tar.gzPush the image to your Docker registry:
-docker push| - - | -
-
-
-You may want to consider changing the name of the loaded image for simplicity: -
-
-
-
- |
-
To use the Teradata Jupyter Docker image directly in your JupyterHub cluster, modify the override file as described in herein the JupyterHub documentation. Replace REGISTRY_URL and VERSION with appropriate values from the step above:
singleuser:
- image:
- name: REGISTRY_URL/teradatajupyterlabext_VERSION
- tag: latestApply the changes to the cluster as described in JupyterHub documentation.
-| - - | --You can use multiple profiles to allow users to select which image they want to use when they log in to JupyterHub. For detailed instructions and examples on configuring multiple profiles, please see JupyterHub documentation. - | -
If your users need some packages or notebooks that are not bundled in the Teradata Jupyter Docker image, we recommend that you use Teradata image as a base image and build a new one on top of it.
-Here is an example Dockerfile that builds on top of Teradata image and adds additional packages and notebooks. Use the Dockerfile to build a new Docker image, push the image to a designated registry, modify override file as shown above to use the new image as singleuser image, apply the changes to the cluster as described above. Replace REGISTRY_URL and VERSION with appropriate values:
FROM REGISTRY_URL/teradatajupyterlabext_VERSION:latest
-
-# install additional packages
-RUN pip install --no-cache-dir astropy
-
-# copy notebooks
-COPY notebooks/. /tmp/JupyterLabRoot/DemoNotebooks/If you prefer, you can include the Teradata SQL kernel and extensions into into an existing image you are currently using.
-Go to Vantage Modules for Jupyter page to download the zipped Teradata Jupyter extensions package bundle. Assuming your existing -docker image is Linux based, you will want to use the Linux version of the download. Otherwise, download for the platform you are using. The .zip file contains the Teradata SQL Kernel, extensions and sample -notebooks.
-Unzip the bundle file to your working directory.
-Below is an example Dockerfile to add Teradata Jupyter extensions to your existing Docker image. Use the Dockerfile to build a new Docker image, push the image to a designated registry, modify override file as shown above to use the new image as singleuser image, apply the changes to the cluster:
-FROM REGISTRY_URL/your-existing-image:tag
-ENV NB_USER=jovyan \
- HOME=/home/jovyan \
- EXT_DIR=/opt/teradata/jupyterext/packages
-
-USER root
-
-##############################################################
-# Install kernel and copy supporting files
-##############################################################
-
-# Copy the kernel
-COPY ./teradatakernel /usr/local/bin
-RUN chmod 755 /usr/local/bin/teradatakernel
-
-# Copy directory with kernel.json file into image
-COPY ./teradatasql teradatasql/
-
-##############################################################
-# Switch to user jovyan to copy the notebooks and license files.
-##############################################################
-
-USER $NB_USER
-
-# Copy notebooks
-COPY ./notebooks/ /tmp/JupyterLabRoot/TeradataSampleNotebooks/
-
-# Copy license files
-COPY ./ThirdPartyLicenses /tmp/JupyterLabRoot/ThirdPartyLicenses/
-
-USER root
-
-# Install the kernel file to /opt/conda jupyter lab instance
-RUN jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-##############################################################
-# Install Teradata extensions
-##############################################################
-
-COPY ./teradata_*.tgz $EXT_DIR
-
-WORKDIR $EXT_DIR
-
-RUN jupyter labextension install --no-build teradata_database* && \
- jupyter labextension install --no-build teradata_resultset* && \
- jupyter labextension install --no-build teradata_sqlhighlighter* && \
- jupyter labextension install --no-build teradata_connection_manager* && \
- jupyter labextension install --no-build teradata_preferences* && \
- jupyter lab build --dev-build=False --minimize=False && \
- rm -rf *
-
-WORKDIR $HOME
-
-# Give back ownership of /opt/conda to jovyan
-RUN chown -R jovyan:users /opt/conda
-
-# Jupyter will create .local directory
-RUN rm -rf $HOME/.localYou can optionally install Teradata package for Python and Teradata package for R. See the following pages for details:
- -| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
There are situations when you want to quickly validate a machine learning model idea. You have a model type in mind. You don’t want to operationalize with an ML pipeline just yet. You just want to test out if the relationship you had in mind exists. Also, sometimes even your production deployment doesn’t require constant relearning with MLops. In such cases, you can use Database Analytic Functions for feature engineering, train different ML models, score your models, and evaluate your model on different model evaluation functions.
-You need access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Here in this example we will be using the sample data from val database. We will use the accounts, customer, and transactions tables. We will be creating some tables in the process and you might face some issues while creating tables in val database, so let’s create our own database td_analytics_functions_demo.
CREATE DATABASE td_analytics_functions_demo
-AS PERMANENT = 110e6;| - - | --You must have CREATE TABLE permissions on the Database where you want to use Database Analytics Functions. - | -
Let’s now create accounts, customer and transactions tables in our database td_analytics_functions_demo from the corresponding tables in val database.
DATABASE td_analytics_functions_demo;
-
-CREATE TABLE customer AS (
-SELECT * FROM val.customer
-) WITH DATA;
-
-CREATE TABLE accounts AS (
-SELECT * FROM val.accounts
-) WITH DATA;
-
-CREATE TABLE transactions AS (
-SELECT * FROM val.transactions
-) WITH DATA;Now, that we have our sample tables loaded into td_analytics_functions_demo, let’s explore the data. It’s a simplistic, fictitious dataset of banking customers (700-ish rows), Accounts (1400-ish rows) and Transactions (77K-ish rows). They are related to each other in the following ways:
-In later parts of this how-to we are going to explore if we can build a model that predicts average monthly balance that a banking customer has on their credit card based on all non-credit card related variables in the tables.
-We have data in three different tables that we want to join and create features. Let’s start by creating a joined table.
--- Create a consolidated joined_table from customer, accounts and transactions table
-CREATE TABLE td_analytics_functions_demo.joined_table AS (
- SELECT
- T1.cust_id AS cust_id
- ,MIN(T1.income) AS tot_income
- ,MIN(T1.age) AS tot_age
- ,MIN(T1.years_with_bank) AS tot_cust_years
- ,MIN(T1.nbr_children) AS tot_children
- ,MIN(T1.marital_status)AS marital_status
- ,MIN(T1.gender) AS gender
- ,MAX(T1.state_code) AS state_code
- ,AVG(CASE WHEN T2.acct_type = 'CK' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS ck_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'SV' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS sv_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'CC' THEN T2.starting_balance+T2.ending_balance ELSE 0 END) AS cc_avg_bal
- ,AVG(CASE WHEN T2.acct_type = 'CK' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS ck_avg_tran_amt
- ,AVG(CASE WHEN T2.acct_type = 'SV' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS sv_avg_tran_amt
- ,AVG(CASE WHEN T2.acct_type = 'CC' THEN T3.principal_amt+T3.interest_amt ELSE 0 END) AS cc_avg_tran_amt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 1 THEN T3.tran_id ELSE NULL END) AS q1_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 2 THEN T3.tran_id ELSE NULL END) AS q2_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 3 THEN T3.tran_id ELSE NULL END) AS q3_trans_cnt
- ,COUNT(CASE WHEN ((EXTRACT(MONTH FROM T3.tran_date) + 2) / 3) = 4 THEN T3.tran_id ELSE NULL END) AS q4_trans_cnt
- FROM Customer AS T1
- LEFT OUTER JOIN Accounts AS T2
- ON T1.cust_id = T2.cust_id
- LEFT OUTER JOIN Transactions AS T3
- ON T2.acct_nbr = T3.acct_nbr
-GROUP BY T1.cust_id) WITH DATA UNIQUE PRIMARY INDEX (cust_id);Let’s now see how our data looks. The dataset has both categorical and continuous features or independent variables. In our case, the dependent variable is cc_avg_bal which is customer’s average credit card balance.
-On looking at the data we see that there are several features that we can take into consideration for predicting the cc_avg_bal.
As we have some categorical features in our dataset such as gender, marital status and state code. We will leverage the Database Analytics function TD_OneHotEncodingFit to encode categories to one-hot numeric vectors.
CREATE VIEW td_analytics_functions_demo.one_hot_encoding_joined_table_input AS (
- SELECT * FROM TD_OneHotEncodingFit(
- ON td_analytics_functions_demo.joined_table AS InputTable
- USING
- IsInputDense ('true')
- TargetColumn ('gender','marital_status','state_code')
- CategoryCounts(2,4,33)
-Approach('Auto')
-) AS dt
-);If we look at the data, some columns like tot_income, tot_age, ck_avg_bal have values in different ranges. For the optimization algorithms like gradient descent it is important to normalize the values to the same scale for faster convergence, scale consistency and enhanced model performance. We will leverage TD_ScaleFit function to normalize values in different scales.
CREATE VIEW td_analytics_functions_demo.scale_fit_joined_table_input AS (
- SELECT * FROM TD_ScaleFit(
- ON td_analytics_functions_demo.joined_table AS InputTable
- USING
- TargetColumns('tot_income','q1_trans_cnt','q2_trans_cnt','q3_trans_cnt','q4_trans_cnt','ck_avg_bal','sv_avg_bal','ck_avg_tran_amt', 'sv_avg_tran_amt', 'cc_avg_tran_amt')
- ScaleMethod('RANGE')
-) AS dt
-);Teradata’s Database Analytic Functions typically operate in pairs for data transformations. The first step is dedicated to "fitting" the data. Subsequently, the second function utilizes the parameters derived from the fitting process to execute the actual transformation on the data. The TD_ColumnTransformer takes the FIT tables to the function and transforms the input table columns in single operation.
--- Using a consolidated transform function
-CREATE TABLE td_analytics_functions_demo.feature_enriched_accounts_consolidated AS (
-SELECT * FROM TD_ColumnTransformer(
-ON joined_table AS InputTable
-ON one_hot_encoding_joined_table_input AS OneHotEncodingFitTable DIMENSION
-ON scale_fit_joined_table_input AS ScaleFitTable DIMENSION
-) as dt
-) WITH DATA;Once we perform the transformation we can see our categorical columns one-hot encoded and numeric values scaled as can be seen in the image below. For ex: tot_income is in the range [0,1], gender is one-hot encoded to gender_0, gender_1, gender_other.
-
-As we have our datatset ready with features scaled and encoded, now let’s split our dataset into training (75%) and testing (25%) parts. Teradata’s Database Analytic Functions provide TD_TrainTestSplit function that we’ll leverage to split our dataset.
--- Train Test Split on Input table
-CREATE VIEW td_analytics_functions_demo.train_test_split AS (
-SELECT * FROM TD_TrainTestSplit(
-ON td_analytics_functions_demo.feature_enriched_accounts_consolidated AS InputTable
-USING
-IDColumn('cust_id')
-trainSize(0.75)
-testSize(0.25)
-Seed (42)
-) AS dt
-);As can be seen in the image below, the function adds a new column TD_IsTrainRow.
-We’ll use TD_IsTrainRow to create two tables, one for training and other for testing.
-- Creating Training Table
-CREATE TABLE td_analytics_functions_demo.training_table AS (
- SELECT * FROM td_analytics_functions_demo.train_test_split
- WHERE TD_IsTrainRow = 1
-) WITH DATA;
-
--- Creating Testing Table
-CREATE TABLE td_analytics_functions_demo.testing_table AS (
- SELECT * FROM td_analytics_functions_demo.train_test_split
- WHERE TD_IsTrainRow = 0
-) WITH DATA;We will now use TD_GLM Database Analytic Function to train on our training dataset. The TD_GLM function is a generalized linear model (GLM) that performs regression and classification analysis on data sets. Here we have used a bunch of input columns such as tot_income, ck_avg_bal,cc_avg_tran_amt, one-hot encoded values for marital status, gender and states. cc_avg_bal is our dependent or response column which is continous and hence is a regression problem. We use Family as Gaussian for regression and Binomial for classification.
The parameter Tolerance signifies minimum improvement required in prediction accuracy for model to stop the iterations and MaxIterNum signifies the maximum number of iterations allowed. The model concludes training upon whichever condition is met first. For example in the example below the model is CONVERGED after 58 iterations.
-- Training the GLM_Model with Training Dataset
-CREATE TABLE td_analytics_functions_demo.GLM_model_training AS (
-SELECT * FROM TD_GLM (
- ON td_analytics_functions_demo.training_table AS InputTable
- USING
- InputColumns('tot_income','ck_avg_bal','cc_avg_tran_amt','[19:26]')
- ResponseColumn('cc_avg_bal')
- Family ('Gaussian')
- MaxIterNum (300)
- Tolerance (0.001)
- Intercept ('true')
-) AS dt
-) WITH DATA;
-We will now use our model GLM_model_training to score our testing dataset testing_table using TD_GLMPredict Database Analytic Function.
-- Scoring the GLM_Model with Testing Dataset
-CREATE TABLE td_analytics_functions_demo.GLM_model_test_prediction AS (
-SELECT * from TD_GLMPredict (
-ON td_analytics_functions_demo.testing_table AS InputTable
-ON td_analytics_functions_demo.GLM_model_training AS ModelTable DIMENSION
-USING
-IDColumn ('cust_id')
-Accumulate('cc_avg_bal')
-) AS dt
-) WITH DATA;
-Finally, we evaluate our model on the scored results. Here we are using TD_RegressionEvaluator function. The model can be evaluated based on parameters such as R2, RMSE, F_score.
-- Evaluating the model
-SELECT * FROM TD_RegressionEvaluator(
-ON td_analytics_functions_demo.GLM_model_test_prediction AS InputTable
-USING
-ObservationColumn('cc_avg_bal')
-PredictionColumn('prediction')
-Metrics('RMSE','MAE','R2')
-) AS dt;
-| - - | --The purpose of this how-to is not to describe feature engineering but to demonstrate how we can leverage different Database Analytic Functions in Vantage. The model results might not be optimal and the process to make the best model is beyond the scope of this article. - | -
In this quick start we have learned how to create ML models using Teradata Database Analytic Functions. We built our own database td_analytics_functions_demo with customer,accounts, transactions data from val database. We performed feature engineering by transforming the columns using TD_OneHotEncodingFit, TD_ScaleFit and TD_ColumnTransformer. We then used TD_TrainTestSplit for train test split. We trained our training dataset with TD_GLM model and scored our testing dataset. Finally we evaluated our scored results using TD_RegressionEvaluator function.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| job_id | \n", - "\t\tPatientId | \n", - "\t\tHasDiabetes | \n", - "\t\tjson_report | \n", - "\t
|---|---|---|---|
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t360 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t45 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t490 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t660 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t30 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t220 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t355 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t560 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t460 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t325 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| job_id | \n", - "\t\tPatientId | \n", - "\t\tHasDiabetes | \n", - "\t\tjson_report | \n", - "\t
|---|---|---|---|
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t360 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t45 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t490 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t660 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t30 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t220 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t355 | \n", - "\t\t1 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t560 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t460 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| 2d16fcf4-78e3-4801-a052-a9c224814b85 | \n", - "\t\t325 | \n", - "\t\t0 | \n", - "\t\t\n", - "\t |
| \n", - " | job_id | \n", - "PatientId | \n", - "HasDiabetes | \n", - "json_report | \n", - "
|---|
This tutorial helps you to get started quickly using ClearScape Analytics ModelOps. We discuss key concepts briefly, so you can get right down to importing your first Bring-your-own-model (BYOM) models into ModelOps. In other tutorials in this quickstart site, you will have the opportunity to go deeper into other deployment and automation patterns with ClearSCape Analytics ModelOps.
-In this tutorial, you will learn:
-What’s the difference between BYOM functions and ModelOps BYOM
-Importing your first BYOM model in the Model Registry through the graphical user interface
-Deploying the model in Vantage with automated scheduling and monitoring capabilities
-We provide an associated notebook and sample data that you can import into your clearscape environment to access and run all of the code examples included in the quickstart. Download the ModelOps sample notebooks and data
-Access to a Teradata Vantage instance with ClearScape Analytics (includes ModelOps)
-Access to a Jupyter notebook environment or use the one available in ClearScape Analytics Experience:
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
The Vantage Bring Your Own Model (BYOM) package gives data scientists and analysts the ability to operationalize predictive models in Vantage. Predictive models trained in external tools can be used to score data stored in Vantage using the BYOM Predict functions.
-Create or convert your predictive model using a supported model interchange format (PMML, MOJO, ONNX, Dataiku, and DataRobot are currently available), import it in a Vantage table, and use the BYOM PMMLPredict, H2OPredict, ONNXPredict, DataikuPredict, or DataRobotPredict to score your data with the model.
-In ModelOps the BYOM package is enriched with additional governance, automation, and monitoring capabilities for data scientists and machine learning engineers with the possibility of applying all of this without coding. In addition to the compatible formats of BYOM package, ModelOps extends the possibility to import and score models inside Vantage to Python scripts, R scripts and SAS scoring accelerator models. -Once you have your compatible model created or converted using a supported format (PMML, MOJO, ONNX, Dataiku, DataRobot, Python script, R script and SAS scoring accelerator model) then you can either use the ModelOps graphical user interface or the ModelOps code SDK to import into the model registry.
-Create a project and connection (ModelOps)
-Environment Setup (Notebook)
-Creating datasets (ModelOps)
-Train a model and export to PMML (Notebook)
-Import the PMML into Vantage using BYOM functions (Notebook)
-Import the PMML into Vantage using ModelOps Graphical user interface (ModelOps)
-Go through Automated Lifecycle - Evaluation, Approve, Deploy (ModelOps)
-Default and Custom alerting rules for Monitoring (ModelOps)
-Custom Evaluation metrics and charts (Notebook)
-Login into ModelOps and navigate to the Projects screen.
-Click on the CREATE PROJECT button located on the top-right of the screen. We’re using an cloned demo code in ModelOps with this path: /app/built-in/demo-models as git repository. Here we recommend you clone into your git repository instance the demo models public git: https://github.com/Teradata/modelops-demo-models.git in the branch "tmo"
-
-Inside the Project creation sheet panel, include the following values:
-Name: "BYOM Quickstart"
-Description: "BYOM Quickstart"
-Group: DEMO
-Path: /app/built-in/demo-models
-Credentials: No Credentials
-Branch: tmo
-Click the TEST GIT CONNECTION button. If the test is succesful then click on save and continue.
-
-In this guide we will skip creating a service connection, so click SAVE & CONTINUE and then NEXT to create a personal connection.
-
-
-Inside the Personal Connection of the Projects creation sheet panel, include the following values:
-Name: Quickstart Personal
-Description: Quickstart Personal Connection
-Host: ClearScape-url
-Database: "demo_user"
-VAL Database Name: "VAL"
-BYOM Database Name: "MLDB"
-Login Mechanism: "TDNEGO"
-Username: demo_user
-Pasword: your-password
-Test the Vantage connection by clicking on the TEST CONNECTION button.
-Click save.
-
-This is how the Projects panel will show with the new project created:
-
-Enter into the project by clicking on it, and get inside Settings on the Left-hand menu. Use View details from your connection
-
-Then you should get the healthcheck panel, where it will show if SQLE, BYOM and VAL associated rights are enabled for this connection user. If there is any error here, contact your dba to apply the specific rights. Review the onboarding bteq script that comes in the attached files of the quickstart for the specific GRANT commands that are required.
-
-Follow the Notebook attached in this quickstart to perform the envrionnment setup and checks at the database level.
-Click on your newly created project and then click on the Datasets button located on the left-hand menu. Click on CREATE DATASET TEMPLATE.
-
-Enter the following values:
-Name: dataset
-Description: dataset
-Feature Catalog: Vantage
-Database: your-db
-Table: aoa_statistics_metadata
-
-Click next and enter the Features Query: This query will be used to identify the features table, you can also Validate statistics and preview Data:
-
-SELECT * FROM pima_patient_features
-Continue to Entity & Target and include the query: This query will be used to join with the features based on the same entity and to filter the rows of the Training, Evaluation and Scoring Datasets.
-You need to select HasDiabetes as the target variable from this query, then Validate Statistics
-SELECT * FROM pima_patient_diagnoses
-Continue to Predictions and include the details of the database, table, and the query: This query will be used as the Input of the execution of your model in Production when this model will be deployed as BATCH (Note: BYOM models can only be deployed as batch in ModelOps version 7)
-Database: your-db
-Table: pima_patient_predictions
-Query:
-SELECT * FROM pima_patient_features WHERE patientid MOD 5 = 0
-Click on create dataset, Enter the name and description and Select training and click next.
-This query we want to filter and get 80% of rows of the dataset, we use MOD 5 <> 0 to get this:
-SELECT * FROM pima_patient_diagnoses WHERE patientid MOD 5 <> 0
-
-Confirm the query and click on create.
-Click on create dataset, Enter the name and description and Select evaluation and click next.
-This query we want to filter and get 20% of rows of the dataset, we use MOD 5 = 0 to get this:
-SELECT * FROM pima_patient_diagnoses WHERE patientid MOD 5 = 0
-
-Confirm the query and click on create.
-This is how it should show both datasets for Training and Evaluation
-
-Follow the Notebook attached in this quickstart to perform the model training, conversion and download the model pmml file for following steps.
-Follow the Notebook attached in this quickstart to use and understand the BYOM package functions, this way will publish the models in Vantage, but not in the ModelOps registry and we will not have governance, automation or monitoring capabilities.
-Go to Models at the left-hand menu and click on DEFINE BYOM MODEL
-
-Fill the fields with this values as example:
-Name: byom
-Description: byom
-Format: PMML
-Click on Save Model & Import versions
-
-Fill the field for external id to track it from the training tool, and upload the model.pmml file - NOTE It has to be this exact name: model.pmml
-External id: 001
-model file: model.pmml
-
-In this screen we are going to keep marked the Enable Monitoring capabily.
-We need to select the training dataset that was used for this model pmml when training. We have already created this dataset before, so we select
-Then we press on VALIDATE.
-BYOM predict functions generate an output based on a JSON, and this is different for every BYOM model. We need to know the specific field that is the target/output of our prediction. In order to use it in our evaluation logic and generate model metrics (accuracy, precision, etc.). For this we require a CAST expression on the JSON output file.
-We have included a Generate Link to help us on validating and implementing this CAST expression. So click on the Generate button to move into the helper screen and get the expression
-
-Now select the target/output variable of our prediction. In this demo case is: predicted_HasDiabetes.
-Click on Save and let the helper copy the expression for you.
-
-This is the CAST expression, Click on Save on the dialog: -CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes') AS INT)
-
-Now you can validate the Cast Expression and click on Save:
-
-A new job for MODEL IMPORT and another job for COMPUTE STATISTICS will run for few minutes.
-
-After finishing the jobs a new model version will be available in the Model version catalog of this byom model like the following image. Click on the model version to get inside Lifecycle:
-
-The model is in IMPORT stage. we can now evaluate the model, click EVALUATE to run the automated default evaluation job
-
-Select the evaluation dataset and click on EVALUATE MODEL.
-
-This will create a new Job for the Evaluation and will show the log. These screen can be closed at the X button at the top-right.
-
-You can access at any time at the left-hand menu JOBS screen. to go again into the log you just need to click on the 3 dots of the job and VIEW DETAILS. This is how it should look:
-
-Once the job is finished, model will be in the EVALUATE stage in the lifecycle screen. Go to your model version to see it.
-You can check all the details of the evaluation step, including an evaluation REPORT, where you will see metrics and Charts that the default Evaluation logic has generated. NOTE: These metrics are default for Classification and Regression models and can be customized with a coded template that will share later in the quickstart.
-
-
-Once the model version is evaluated, it is ready to be approved or rejected. This approval can be done through model lifecycle screen, in the model report screen and it can also be done through REST API integrating an external tool like Jira/BPM case management systems.
-Let’s get into the Approval dialog and include the following description, as an example:
-Approval comment: Go for Production
-
-to deploy the model you need to use the DEPLOY button in the model lifecycle screen.
-
-For BYOM models the deployment target available is In-Vantage, as we want to leverage the BYOM predict functions in Vantage:
-
-Publish the model: Select the connection to Vantage that will be used to publish the model, the database and the table. Here we will use our created connection and the table we created for storing BYOM models: aoa_byom_models. Click Next after including these details
-Connection: personal
-Database: demo_user
-Table: aoa_byom_models
-
-Now in the Scheduling step, you are able to enable scheduling and select what is the frequency/cadence of this scoring. Keep marked the Enable Scheduling checkbox and select "Manual" in this demo, inside clearscape.teradata.com in order to save resources the scheduling options are disabled. Any scheduling option is available since we can include a CRON expression.
-In this screen we will also select the dataset template to be used when scoring the model in production. The Prediction details of the dataset will be used such as the Input query, and output prediction table that we defined in the Datasets step.
-Click on Deploy to finalize this step
-
-A new Deployment job will be running by the ModelOps Agent. once this is finished a new deployment will be available in the Deployments section of the left-hand menu.
-
-Go to the left-hand menu Deployments, and see the new deployment from the BYOM model is available, click on it to see the details and go to the Jobs tab
-
-In the Jobs tab you will see the history of executions of this model deployed. Let’s run now a new scoring using the Run now button. This button can be also scheduled externally through REST APIs
-
-After executing the scoring job, it should look like this:
-
-And we can get into the output details of this job, by clicking on the three dots at the right, and view predictions
-
-Now that we have run a job in production, the default Monitoring capabilities are enabled, you can check both feature and prediction drift to see individually per feature the histogram calculation and the Population Stability Index (PSI) KPI for drift monitoring
-
-
-In the Performance metrics tab, we see that there is only a single metric data point, this is because performance monitoring relies on Evaluation jobs. So let’s create a new dataset and run a new evaluation at this deployment to simulate we have new fresh data and want to check on the performance of my model by comparing the metrics with the previous evaluation.
-Let’s create a new evaluation dataset in Datasets left-hand menu.
-We will use the same dataset template that we created and will create a new dataset with the following details
-Name: evaluation2
-Description: evaluation2
-Scope: evaluation
-
-And let’s simulate the new evaluation with a new dataset query
-SELECT * FROM pima_patient_features WHERE patientid MOD 10 = 0And click on create to generate new dataset for evaluation
-
-Now you can go back to your deployment to evaluate the model version deployed:
-
-Use the new dataset created in the Evaluation job panel:
-Dataset template: dataset
-Dataset: evaluate2
-and click on EVALUATE model
-
-Once the Evaluation job is finished, then the performance metrics will show a new set of metrics with the new dataset used:
-
-Default Alerts in ModelOps are activated at the models screen, There is a Enable Alerts column in this table, activate it to start with default alerting
-
-Once this alerts are enabled you can check on the definition of the default alert, by getting inside the model and getting into the ALERT tab:
-
-We can create new alerts, like new rules for performance monitoring or update default alerting rules.
-Let’s do an alert edit, on the feature drift monitoring. click on the alert edit
-
-Here you can update the fields. Let’s update the value treshold from 0.2 to 0.18 and click on UPDATE
-
-After editing the rule, your alerts screen should look like this:
-
-Now that we have alert edited, we should wait 1 minute till we get a new alert into the ModelOps tool. This alert can be configured to send an email to a set of email addresses as well.
-Now we have received the alert, we can see a red circle in the alerts at the left-hand menu
-We can directly access to the model version from this screen by clicking on the modelid
-
-Once we are in the model lifecycle screen, we see a direct access to Model Drift, let’s get inside
-
-Then we can see the individual features in red in the feature drift tab of my deployed model. This alert is indicating that the latest scoring data is drifted from the training data with that value of population stability index(PSI). And teams can then make proactive actions to evaluate the drift of the model and replace the model in production if is needed
-
-Follow the Notebook attached in this quickstart to understand the methodology for creating custom Evaluation logic, metrics and charts
-In this quick start we have learned what is the difference between BYOM functions and ModelOps BYOM pattern, How to import models with ModelOps graphical user interface, and how to automate the scoring and monitoring of the model getting Data Drift and Model QUality metrics alerts
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This is a how-to for people who are new to ClearScape Analytics ModelOps. In the tutorial, you will be able to create a new project in ModelOps, upload the required data to Vantage, and track the full lifecycle of a demo model using code templates and following the methodology for GIT models in ModelOps.
-Access to a Teradata Vantage instance with ClearScape Analytics (includes ModelOps)
-Ability to run Jupyter notebooks
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Files needed
-Let’s start by downloading the needed files for this tutorial. Download these 4 attachments and upload them in your Notebook filesystem. Select the files depending on your version of ModelOps:
-ModelOps version 6 (October 2022):
-Alternatively you can git clone following repos
-git clone https://github.com/willfleury/modelops-getting-started
-git clone https://github.com/Teradata/modelops-demo-models/ModelOps version 7 (April 2023):
-git clone -b v7 https://github.com/willfleury/modelops-getting-started.git -git clone https://github.com/Teradata/modelops-demo-models/-
Setting up the database and Jupyter environment
-Follow the ModelOps_Training Jupyter Notebook to setup the database, tables and libraries needed for the demo.
-Add a new Project
-create project
-Details
-Name: Demo: your-name
-Description: ModelOps Demo
-Group: your-name
-Credentials: No Credentials
-Branch: master
-Here you can test the git connection. If is green then save and continue. Skip the service connection settings for now.
-When creating a new project, ModelOps will ask you for a new connection.
-Personal connection
-Name: Vantage personal your-name
-Description: Vantage demo env
-Host: tdprd.td.teradata.com (internal for teradata transcend only)
-Database: your-db
-VAL Database: TRNG_XSP (internal for teradata transcend only)
-BYOM Database: TRNG_BYOM (internal for teradata transcend only)
-Login Mech: TDNEGO
-Username/Password
-You can check the permissions with the new healthcheck panel in the connections panel
-
-Let’s create a new dataset template, then 1 dataset for training and 2 datasets for evaluation so we can monitor model quality metrics with 2 different datasets
-Add datasets
-create dataset template
-Catalog
-Name: PIMA
-Description: PIMA Diabetes
-Feature Catalog: Vantage
-Database: your-db
-Table: aoa_feature_metadata
-Features -Query:
-
-SELECT * FROM {your-db}.pima_patient_featuresEntity Key: PatientId -Features: NumTimesPrg, PlGlcConc, BloodP, SkinThick, TwoHourSerIns, BMI, DiPedFunc, Age
-Entity & Target -Query:
-SELECT * FROM {your-db}.pima_patient_diagnosesEntity Key: PatientId -Target: HasDiabetes
-Predictions
-Database: your-db
-Table: pima_patient_predictions
-Entity selection:
-Query:
-SELECT * FROM pima_patient_features WHERE patientid MOD 5 = 0Only for v6 (in v7 you will define this in the BYOM no code screen): BYOM Target Column: CAST(CAST(json_report AS JSON).JSONExtractValue('$.predicted_HasDiabetes') AS INT)
-Basic
-Name: Train
-Description: Training dataset
-Scope: Training
-Entity & Target
-Query:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 1Basic
-Name: Evaluate
-Description: Evaluation dataset
-Scope: Evaluation
-Entity & Target
-Query:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 2Basic
-Name: Evaluate
-Description: Evaluation dataset
-Scope: Evaluation
-Entity & Target
-Query:
-SELECT * FROM {your-db}.pima_patient_diagnoses WHERE patientid MOD 5 = 3For Git Models we need to fill the code templates available when adding a new model.
-These code scripts will be stored in the git repository under: model_definitions/your-model/model_modules/
-init.py : this an empty file required for python modules
-training.py: this script contains train function
-def train(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # your training code
-
- # save your model
- joblib.dump(model, f"{context.artifact_output_path}/model.joblib")
-
- record_training_stats(...)Review the Operationalize notebook to see how you can execute this from CLI or from notebook as an alternative to ModelOps UI.
-evaluation.py: this script contains evaluate function
-def evaluate(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # read your model
- model = joblib.load(f"{context.artifact_input_path}/model.joblib")
-
- # your evaluation logic
-
- record_evaluation_stats(...)Review the Operationalize notebook to see how you can execute this from CLI or from notebook as an alternative to ModelOps UI.
-scoring.py: this script contains score function
-def score(context: ModelContext, **kwargs):
- aoa_create_context()
-
- # read your model
- model = joblib.load(f"{context.artifact_input_path}/model.joblib")
-
- # your evaluation logic
-
- record_scoring_stats(...)Review the Operationalize notebook to see how you can execute this from CLI or from notebook as an alternative to ModelOps UI.
-requirements.txt: this file contains the library names and versions required for your code scripts. Example:
-%%writefile ../model_modules/requirements.txt
-xgboost==0.90
-scikit-learn==0.24.2
-shap==0.36.0
-matplotlib==3.3.1
-teradataml==17.0.0.4
-nyoka==4.3.0
-aoa==6.0.0config.json: this file located in the parent folder (your-model folder) contains default hyper-parameters
-%%writefile ../config.json
-{
- "hyperParameters": {
- "eta": 0.2,
- "max_depth": 6
- }
-}Go and review the code scripts for the demo model in the repository: https://github.com/Teradata/modelops-demo-models/
-Go into model_definitions→python-diabetes→model_modules
-Open Project to see models available from GIT
-Train a new model version
-see how CommitID from code repository is tracked
-Evaluate
-Review evaluation report, including dataset statistics and model metrics
-Compare with other model versions
-Approve
-Deploy in Vantage - Engine, Publish, Schedule. Scoring dataset is required -Use your connection and select a database. e.g "aoa_byom_models"
-Deploy in Docker Batch - Engine, Publish, Schedule. Scoring dataset is required -Use your connection and select a database. e.g "aoa_byom_models"
-Deploy in Restful Batch - Engine, Publish, Schedule. Scoring dataset is required -Use your connection and select a database. e.g "aoa_byom_models"
-Deployments/executions
-Evaluate again with dataset2 - to monitor model metrics behavior
-Monitor Model Drift - data and metrics
-Open BYOM notebook to execute the PMML predict from SQL code when deployed in Vantage
-Test Restful from ModelOps UI or from curl command
-Retire deployments
-In this quick start we have learned how to follow a full lifecycle of GIT models into ModelOps and how to deploy it into Vantage or into Docker containers for Edge deployments. Then how we can schedule a batch scoring or test restful or on-demand scorings and start monitoring on Data Drift and Model Quality metrics.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
The purpose of the Model Factory Solution Accelerator of ClearScape Analytics is to streamline and accelerate the end-to-end process of developing, deploying, and managing machine learning models within an organization at Horizontal Scale by operationalizing hundreds of models for a business domain at one effort. It leverages the scalability of in-database analytics and the openness of supporting partner model formats such as H2O or Dataiku. This unique combination enhances efficiency, scalability, and consistency across various stages of the machine learning lifecycle in Enterprise environments.
-By incorporating best practices, automation, and standardized workflows, the Model Factory Solution Accelerator enables teams to rapidly select the data to be used, configure the model required, ensure reproducibility, and deploy unlimited number of models seamlessly into production. Ultimately, it aims to reduce the time-to-value for machine learning initiatives and promote a more structured and efficient approach to building and deploying models at scale. Here is the diagram of an automated Workflow:
-
-Here are the steps to implement Model Factory Solution Accelerator using Airflow and ClearScape Analytics ModelOps. Apache Airflow is used for the scheduling and orchestration of data pipelines or workflows. So in this tutorial we are creating an Airflow DAG (Directed Acyclic Graph) which will be executed to automate the lifecycle of ModelOps.
-In this tutorial it is implemented on local machine using Visual Studio code IDE.
-In order to execute shell commands, you can install the VS code extension "Remote Development" using the followng link. This extension pack includes the WSL extension, in addition to the Remote - SSH, and Dev Containers extensions, enabling you to open any folder in a container, on a remote machine, or in WSL: -VS code marketplace.
-Access to a Teradata Vantage instance with ClearScape Analytics (includes ModelOps)
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Open Visual Studio code and select the option of open a remote window. Then select Connect to WSL-Ubuntu
-Select File > Open Folder. Then select the desired folder or create a new one using this command: mkdir [folder_name]
-Set the AIRFLOW_HOME environment variable. Airflow requires a home directory and uses ~/airflow by default, but you can set a different location if you prefer. The AIRFLOW_HOME environment variable is used to inform Airflow of the desired location.
-AIRFLOW_HOME=./[folder_name]Install apache-airflow stable version 2.8.2 from PyPI repository.:
- AIRFLOW_VERSION=2.8.2
-
- PYTHON_VERSION="$(python3 --version | cut -d " " -f 2 | cut -d "." -f 1-2)"
-
- CONSTRAINT_URL="https://raw.githubusercontent.com/apache/airflow/constraints-${AIRFLOW_VERSION}/constraints-${PYTHON_VERSION}.txt"
-
- pip install "apache-airflow==${AIRFLOW_VERSION}" --constraint "${CONSTRAINT_URL}" --default-timeout=100Install the Airflow Teradata provider stable version from PyPI repository.
-pip install "apache-airflow-providers-teradata" --default-timeout=100Install Docker Desktop so that you can use docker container for running airflow. Ensure that the docker desktop is running.
-Check docker version using this command:
-docker --versionCheck the version of docker compose. Docker Compose is a tool for defining and running multi-container applications
-docker-compose --versionTo deploy Airflow on Docker Compose, you need to fetch docker-compose.yaml using this curl command.
- curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.8.2/docker-compose.yaml'Create these folders to use later using following command:
-mkdir -p ./dags ./logs ./plugins ./configCreate a config file inside config folder and set the parameters to corresponding values depending on which model you want to train.
-from configparser import ConfigParser
-import os
-
-config = ConfigParser()
-
-config['MAIN'] = {
- "projectId": "23e1df4b-b630-47a1-ab80-7ad5385fcd8d",
- "bearerToken": os.environ['BEARER_TOKEN'],
- "trainDatasetId": "ba39e766-2fdf-426f-ba5c-4ca3e90955fc",
- "evaluateDatasetId": "74489d62-2af5-4402-b264-715e151a420a",
- "datasetConnectionId" : "151abf05-1914-4d38-a90d-272d850f212c",
- "datasetTemplateId": "d8a35d98-21ce-47d0-b9f2-00d355777de1"
-}
-
-config['HYPERPARAMETERS'] = {
- "eta": 0.2,
- "max_depth": 6
-}
-
-config['RESOURCES'] = {
- "memory": "500m",
- "cpu": "0.5"
-}
-
-config['MODEL'] = {
- "modelId": "f937b5d8-02c6-5150-80c7-1e4ff07fea31",
- "approvalComments": "Approving this model!",
- "cron": "@once",
- "engineType": "DOCKER_BATCH",
- "engine": "python-batch",
- "dockerImage": "artifacts.td.teradata.com/tdproduct-docker-snapshot/avmo/aoa-python-base:3.9.13-1"
-}
-
-
-with open('./config/modelOpsConfig.ini', 'w') as f:
- config.write(f)Now copy the Bearer token from the ModelOps user interface (Left Menu → Your Account → Session Details) and set it here as an environment varibale using the following command:
-export BEARER_TOKEN='your_token_here'Now you can execute the previously created config file, which will create a new ini file inside config folder containing all the required parameters which will be used in the DAG creation step.
-python3 createConfig.pyNow you can create a DAG using the following python code. Add this python code file inside dags folder. This DAG contains 5 tasks of ModelOps lifecycle (i.e., Train, Evaluate, Approve, Deploy and Retire)
-import base64
-from datetime import datetime, timedelta, date
-import json
-import os
-import time
-
-from airflow import DAG
-from airflow.operators.python import PythonOperator
-
-import requests
-
-from configparser import ConfigParser
-
-# Read from Config file
-config = ConfigParser()
-config.read('config/modelOpsConfig.ini')
-
-config_main = config["MAIN"]
-config_hyper_params = config["HYPERPARAMETERS"]
-config_resources = config["RESOURCES"]
-config_model = config["MODEL"]
-
-# Default args for DAG
-default_args = {
- 'owner': 'Tayyaba',
- 'retries': 5,
- 'retry_delay': timedelta(minutes=2)
-}
-
-def get_job_status(job_id):
-
- # Use the fetched Job ID to check Job Status
- headers_for_status = {
- 'AOA-PROJECT-ID': config_main['projectid'],
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- }
-
- status_response = requests.get('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/jobs/' + job_id + '?projection=expandJob', headers=headers_for_status)
- status_json = status_response.json()
- job_status = status_json.get('status')
- return job_status
-
-
-def train_model(ti):
-
- headers = {
- 'AOA-Project-ID': config_main['projectid'],
- 'Accept': 'application/json, text/plain, */*',
- 'Accept-Language': 'en-US,en;q=0.9',
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- 'Content-Type': 'application/json',
- }
-
- json_data = {
- 'datasetId': config_main['trainDatasetId'],
- 'datasetConnectionId': config_main['datasetConnectionId'],
- 'modelConfigurationOverrides': {
- 'hyperParameters': {
- 'eta': config_hyper_params['eta'],
- 'max_depth': config_hyper_params['max_depth'],
- },
- },
- 'automationOverrides': {
- 'resources': {
- 'memory': config_resources['memory'],
- 'cpu': config_resources['cpu'],
- },
- 'dockerImage': config_model['dockerImage'],
- },
- }
-
-
- response = requests.post('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/models/' + config_model['modelid'] + '/train', headers=headers, json=json_data)
-
- json_data = response.json()
-
- # Get the Training Job ID
- job_id = json_data.get('id')
- ti.xcom_push(key='train_job_id', value=job_id)
-
- job_status = get_job_status(job_id)
- print("Started - Training Job - Status: ", job_status)
-
- while job_status != "COMPLETED":
- if job_status=="ERROR":
- print("The training job is terminated due to an Error")
- ti.xcom_push(key='trained_model_id', value='NONE') # Setting the Trained Model Id to None here and check in next step (Evaluate)
- break
- elif job_status=="CANCELLED":
- ti.xcom_push(key='trained_model_id', value='NONE')
- print("The training job is Cancelled !!")
- break
- print("Job is not completed yet. Current status", job_status)
- time.sleep(5) #wait 5s
- job_status = get_job_status(job_id)
-
- # Checking Job status at the end to push the correct trained_model_id
- if(job_status == "COMPLETED"):
- train_model_id = json_data['metadata']['trainedModel']['id']
- ti.xcom_push(key='trained_model_id', value=train_model_id)
- print('Model Trained Successfully! Job ID is : ', job_id, 'Trained Model Id : ', train_model_id, ' Status : ', job_status)
- else:
- ti.xcom_push(key='trained_model_id', value='NONE')
- print("Training Job is terminated !!")
-
-
-def evaluate_model(ti):
-
- trained_model_id = ti.xcom_pull(task_ids = 'task_train_model', key = 'trained_model_id')
-
- headers = {
- 'AOA-Project-ID': config_main['projectid'],
- 'Accept': 'application/json, text/plain, */*',
- 'Accept-Language': 'en-US,en;q=0.9',
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- 'Content-Type': 'application/json',
- }
-
- json_data = {
- 'datasetId': config_main['evaluatedatasetid'],
- 'datasetConnectionId': config_main['datasetConnectionId'],
- 'modelConfigurationOverrides': {
- 'hyperParameters': {
- 'eta': config_hyper_params['eta'],
- 'max_depth': config_hyper_params['max_depth'],
- },
- },
- 'automationOverrides': {
- 'resources': {
- 'memory': config_resources['memory'],
- 'cpu': config_resources['cpu'],
- },
- 'dockerImage': config_model['dockerImage'],
- },
- }
-
- if trained_model_id == 'NONE':
- ti.xcom_push(key='evaluated_model_status', value='FALIED')
- print("Evaluation cannot be done as the Training Job was terminated !!")
- else:
- response = requests.post('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/trainedModels/' + trained_model_id + '/evaluate', headers=headers, json=json_data)
- json_data = response.json()
-
- # Get the Evaluation Job ID
- eval_job_id = json_data.get('id')
- ti.xcom_push(key='evaluate_job_id', value=eval_job_id)
-
- job_status = get_job_status(eval_job_id)
- print("Started - Job - Status: ", job_status)
-
- while job_status != "COMPLETED":
- if job_status=="ERROR":
- print("The evaluation job is terminated due to an Error")
- # Set the Trained Model Id to None here and check in next step (Evaluate)
- break
- elif job_status=="CANCELLED":
- print("The evaluation job is Cancelled !!")
- break
- print("Job is not completed yet. Current status", job_status)
- time.sleep(5) # wait 5s
- job_status = get_job_status(eval_job_id)
-
- # Checking Job status at the end to push the correct evaluate_job_id
- if(job_status == "COMPLETED"):
- ti.xcom_push(key='evaluated_model_status', value='EVALUATED')
- print('Model Evaluated Successfully! Job ID is : ', eval_job_id, ' Status : ', job_status)
- else:
- ti.xcom_push(key='evaluated_model_status', value='FAILED')
- print("Evaluation Job is terminated !!")
-
-
-def approve_model(ti):
-
- evaluated_model_status = ti.xcom_pull(task_ids = 'task_evaluate_model', key = 'evaluated_model_status')
-
- if evaluated_model_status == 'FAILED':
- ti.xcom_push(key='approve_model_status', value='FALIED')
- print("Approval cannot be done as the Evaluation was failed !!")
- else:
- trained_model_id = ti.xcom_pull(task_ids = 'task_train_model', key = 'trained_model_id')
-
- headers = {
- 'AOA-Project-ID': config_main['projectid'],
- 'Accept': 'application/json, text/plain, */*',
- 'Accept-Language': 'en-US,en;q=0.9',
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- 'Content-Type': 'application/json',
- }
-
- json_data = {
- "comments": (base64.b64encode(config_model['approvalComments'].encode()).decode())
- }
-
- response = requests.post('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/trainedModels/' + trained_model_id + '/approve' , headers=headers, json=json_data)
- response_json = response.json()
- approval_status = response_json['status']
- if(approval_status == 'APPROVED'):
- ti.xcom_push(key='approve_model_status', value='EVALUATED')
- print('Model Approved Successfully! Status: ', approval_status)
- else:
- ti.xcom_push(key='approve_model_status', value='FAILED')
- print('Model not approved! Status: ', approval_status)
-
-
-def deploy_model(ti):
-
- approve_model_status = ti.xcom_pull(task_ids = 'task_approve_model', key = 'approve_model_status')
-
- headers = {
- 'AOA-Project-ID': config_main['projectid'],
- 'Accept': 'application/json, text/plain, */*',
- 'Accept-Language': 'en-US,en;q=0.9',
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- 'Content-Type': 'application/json',
- }
-
-
- json_data = {
- 'engineType': config_model['engineType'],
- 'engineTypeConfig': {
- 'dockerImage': config_model['dockerImage'],
- 'engine': "python-batch",
- 'resources': {
- 'memory': config_resources['memory'],
- 'cpu': config_resources['cpu'],
- }
- },
- 'language':"python",
- 'datasetConnectionId': config_main['datasetConnectionId'],
- 'datasetTemplateId': config_main['datasetTemplateId'],
- 'cron': config_model['cron'],
- 'publishOnly': "false",
- 'args':{}
- }
-
- if approve_model_status == 'FAILED':
- ti.xcom_push(key='deploy_model_status', value='FALIED')
- print("Deployment cannot be done as the model is not approved !!")
- else:
- trained_model_id = ti.xcom_pull(task_ids = 'task_train_model', key = 'trained_model_id')
-
- response = requests.post('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/trainedModels/' + trained_model_id + '/deploy', headers=headers, json=json_data)
- json_data = response.json()
-
- # Get the Deployment Job ID
- deploy_job_id = json_data.get('id')
- ti.xcom_push(key='deploy_job_id', value=deploy_job_id)
-
- # deployed_model_id = json_data['metadata']['deployedModel']['id']
-
- job_status = get_job_status(deploy_job_id)
- print("Started - Deployment Job - Status: ", job_status)
-
- while job_status != "COMPLETED":
- if job_status=="ERROR":
- ti.xcom_push(key='deploy_model_status', value='FAILED')
- print("The deployment job is terminated due to an Error")
- break
- elif job_status=="CANCELLED":
- ti.xcom_push(key='deploy_model_status', value='FAILED')
- print("The deployment job is Cancelled !!")
- break
- print("Job is not completed yet. Current status", job_status)
- time.sleep(5) # wait 5s
- job_status = get_job_status(deploy_job_id)
-
- # Checking Job status at the end to push the correct deploy_model_status
- if(job_status == "COMPLETED"):
- ti.xcom_push(key='deploy_model_status', value='DEPLOYED')
- print('Model Deployed Successfully! Job ID is : ', deploy_job_id, ' Status : ', job_status)
- else:
- ti.xcom_push(key='deploy_model_status', value='FAILED')
- print("Deployment Job is terminated !!")
-
-
-
-def retire_model(ti):
-
- deployed_model_status = ti.xcom_pull(task_ids = 'task_deploy_model', key = 'deploy_model_status')
-
- if deployed_model_status == 'FAILED':
- ti.xcom_push(key='retire_model_status', value='FALIED')
- print("Retirement cannot be done as the model is not deployed !!")
- else:
- trained_model_id = ti.xcom_pull(task_ids = 'task_train_model', key = 'trained_model_id')
-
- headers = {
- 'AOA-Project-ID': config_main['projectid'],
- 'Accept': 'application/json, text/plain, */*',
- 'Accept-Language': 'en-US,en;q=0.9',
- 'Authorization': 'Bearer ' + config_main['bearertoken'],
- 'Content-Type': 'application/json',
- }
-
- # Identifying the deployment ID
- get_deployment_id_response = requests.get('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/deployments/search/findByStatusAndTrainedModelId?projection=expandDeployment&status=DEPLOYED&trainedModelId=' + trained_model_id , headers=headers)
-
- get_deployment_id_json = get_deployment_id_response.json()
- deployment_id = get_deployment_id_json['_embedded']['deployments'][0]['id']
-
- json_data = {
- "deploymentId": deployment_id
- }
-
- # Retire the specific deployment
- retire_model_response = requests.post('https://airflow-u9usja4twtauvt3s.env.clearscape.teradata.com:8443/modelops/core/api/trainedModels/' + trained_model_id + '/retire', headers=headers, json=json_data)
- retire_model_response_json = retire_model_response.json()
-
- # Get the Evaluation Job ID
- retire_job_id = retire_model_response_json.get('id')
- ti.xcom_push(key='retire_job_id', value=retire_job_id)
-
- job_status = get_job_status(retire_job_id)
- print("Started - Job - Status: ", job_status)
-
- while job_status != "COMPLETED":
- if job_status=="ERROR":
- print("The Retire job is terminated due to an Error")
- # Set the Trained Model Id to None here and check in next step (Evaluate)
- break
- elif job_status=="CANCELLED":
- print("The Retire job is Cancelled !!")
- break
- print("Job is not completed yet. Current status", job_status)
- time.sleep(5) # wait 5s
- job_status = get_job_status(retire_job_id)
-
- # Checking Job status at the end to push the correct evaluate_job_id
- if(job_status == "COMPLETED"):
- ti.xcom_push(key='retire_model_status', value='RETIRED')
- print('Model Retired Successfully! Job ID is : ', retire_job_id, ' Status : ', job_status)
- else:
- ti.xcom_push(key='retire_model_status', value='FAILED')
- print("Retire Job is terminated !!")
-
-
-
-with DAG(
- dag_id = 'ModelOps_Accelerator_v1',
- default_args=default_args,
- description = 'ModelOps lifecycle accelerator for Python Diabetes Prediction model',
- start_date=datetime.now(), # Set the start_date as per requirement
- schedule_interval='@daily'
-) as dag:
- task1 = PythonOperator(
- task_id='task_train_model',
- python_callable=train_model
- )
- task2 = PythonOperator(
- task_id='task_evaluate_model',
- python_callable=evaluate_model
- )
- task3 = PythonOperator(
- task_id='task_approve_model',
- python_callable=approve_model
- )
- task4 = PythonOperator(
- task_id='task_deploy_model',
- python_callable=deploy_model
- )
- task5 = PythonOperator(
- task_id='task_retire_model',
- python_callable=retire_model
- )
-
-
-task1.set_downstream(task2)
-task2.set_downstream(task3)
-task3.set_downstream(task4)
-task4.set_downstream(task5)While initializing Airflow services like the internal Airflow database, for operating systems other than Linux, you may get a warning that AIRFLOW_UID is not set, but you can safely ignore it. by setting its environment variable using the following command.
-echo -e "AIRFLOW_UID=5000" > .envTo run internal database migrations and create the first user account, initialize the database using this command:
-docker compose up airflow-initAfter initialization is complete, you should see a message like this:
- airflow-init_1 | Upgrades done
- airflow-init_1 | Admin user airflow created
- airflow-init_1 | 2.8.2
- start_airflow-init_1 exited with code 0You can clean up the environment which will remove the preloaded example DAGs using this command:
-docker-compose down -vThen update this parameter in docker-compose.yaml file as given below:
-AIRFLOW__CORE__LOAD_EXAMPLES: 'false'Launch Airflow using this command:
-docker-compose up -dNow you can access Airflow UI uisng the following link: http://localhost:8080/
-
-Login with Usename: airflow and Password: airflow. In the DAGs menu you will be able to see your created DAGs.
-
-Select your latest created DAG and the graph will look like this:
-
-Now you can trigger the DAG using the play icon on the top right side.
-You can check the logs by selecting any task and then click on the logs menu:
-On the ClearScape Analytics ModelOps - Jobs section you can see that the jobs have started running:
-
-Now you can see that all the tasks are successfully executed.
-
-This tutorial aimed at providing a hands on exercise on how to install an Airflow environment on a Linux server and how to use Airflow to interact with ClearScape Analytics ModelOps and Teradata Vantage database. An additional example is provided on how to integrate Airflow and the data modelling and maintenance tool dbt to create and load a Teradata Vantage database.
-Feast’s connector for Teradata is a complete implementation with support for all features and uses Teradata Vantage as an online and offline store.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
This how-to assumes you know Feast terminology. If you need a refresher check out the official FEAST documentation
-This document demonstrates how developers can integrate Teradata’s offline and online store with Feast. Teradata’s offline stores allow users to use any underlying data store as their offline feature store. Features can be retrieved from the offline store for model training and can be materialized into the online feature store for use during model inference.
On the other hand, online stores are used to serve features at low latency. The materialize command can be used to load feature values from the data sources (or offline stores) into the online store
The feast-teradata library adds support for Teradata as
OfflineStore
OnlineStore
Additionally, using Teradata as the registry (catalog) is already supported via the registry_type: sql and included in our examples. This means that everything is located in Teradata. However, depending on the requirements, installation, etc, this can be mixed and matched with other systems as appropriate.
To get started, install the feast-teradata library
pip install feast-teradataLet’s create a simple feast setup with Teradata using the standard drivers' dataset. Note that you cannot use feast init as this command only works for templates that are part of the core feast library. We intend on getting this library merged into feast core eventually but for now, you will need to use the following cli command for this specific task. All other feast cli commands work as expected.
feast-td init-repoThis will then prompt you for the required information for the Teradata system and upload the example dataset. Let’s assume you used the repo name demo when running the above command. You can find the repository files along with a file called test_workflow.py. Running this test_workflow.py will execute a complete workflow for the feast with Teradata as the Registry, OfflineStore, and OnlineStore.
demo/
- feature_repo/
- driver_repo.py
- feature_store.yml
- test_workflow.pyFrom within the demo/feature_repo directory, execute the following feast command to apply (import/update) the repo definition into the registry. You will be able to see the registry metadata tables in the teradata database after running this command.
feast applyTo see the registry information in the feast UI, run the following command. Note the --registry_ttl_sec is important as by default it polls every 5 seconds.
-feast ui --registry_ttl_sec=120project: <name of project>
-registry: <registry>
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <db host>
- database: <db name>
- user: <username>
- password: <password>
- log_mech: <connection mechanism>Below is an example of definition.py which elaborates how -to set the entity, source connector, and feature view.
-Now to explain the different components:
-TeradataSource: Data Source for features stored in Teradata (Enterprise or Lake) or accessible via a Foreign Table from Teradata (NOS, QueryGrid)
Entity: A collection of semantically related features
Feature View: A feature view is a group of feature data from a specific data source. Feature views allow you to consistently define features and their data sources, enabling the reuse of feature groups across a project
driver = Entity(name="driver", join_keys=["driver_id"])
-project_name = yaml.safe_load(open("feature_store.yaml"))["project"]
-
-driver_stats_source = TeradataSource(
- database=yaml.safe_load(open("feature_store.yaml"))["offline_store"]["database"],
- table=f"{project_name}_feast_driver_hourly_stats",
- timestamp_field="event_timestamp",
- created_timestamp_column="created",
-)
-
-driver_stats_fv = FeatureView(
- name="driver_hourly_stats",
- entities=[driver],
- ttl=timedelta(weeks=52 * 10),
- schema=[
- Field(name="driver_id", dtype=Int64),
- Field(name="conv_rate", dtype=Float32),
- Field(name="acc_rate", dtype=Float32),
- Field(name="avg_daily_trips", dtype=Int64),
- ],
- source=driver_stats_source,
- tags={"team": "driver_performance"},
-)There are two different ways to test your offline store as explained below. But first, there are a few mandatory steps to follow:
-Now, let’s batch-read some features for training, using only entities (population) for which we have seen an event in the last 60 days. The predicates (filter) used can be on anything relevant for the entity (population) selection for the given training dataset. The event_timestamp is only for example purposes.
from feast import FeatureStore
-store = FeatureStore(repo_path="feature_repo")
-training_df = store.get_historical_features(
- entity_df=f"""
- SELECT
- driver_id,
- event_timestamp
- FROM demo_feast_driver_hourly_stats
- WHERE event_timestamp BETWEEN (CURRENT_TIMESTAMP - INTERVAL '60' DAY) AND CURRENT_TIMESTAMP
- """,
- features=[
- "driver_hourly_stats:conv_rate",
- "driver_hourly_stats:acc_rate",
- "driver_hourly_stats:avg_daily_trips"
- ],
-).to_df()
-print(training_df.head())The feast-teradata library allows you to use the complete set of feast APIs and functionality. Please refer to the official feast quickstart for more details on the various things you can do.
Feast materializes data to online stores for low-latency lookup at model inference time. Typically, key-value stores are used for online stores, however, relational databases can be used for this purpose as well.
-Users can develop their own online stores by creating a class that implements the contract in the OnlineStore class.
-project: <name of project>
-registry: <registry>
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <db host>
- database: <db name>
- user: <username>
- password: <password>
- log_mech: <connection mechanism>There are a few mandatory steps to follow before we can test the online store:
-The command materialize_incremental is used to incrementally materialize features in the online store. If there are no new features to be added, this command will essentially not be doing anything. With feast materialize_incremental, the start time is either now — ttl (the ttl that we defined in our feature views) or the time of the most recent materialization. If you’ve materialized features at least once, then subsequent materializations will only fetch features that weren’t present in the store at the time of the previous materializations.
CURRENT_TIME=$(date +'%Y-%m-%dT%H:%M:%S')
-feast materialize-incremental $CURRENT_TIMENext, while fetching the online features, we have two parameters features and entity_rows. The features parameter is a list and can take any number of features that are present in the df_feature_view. The example above shows all 4 features present but these can be less than 4 as well. Secondly, the entity_rows parameter is also a list and takes a dictionary of the form {feature_identifier_column: value_to_be_fetched}. In our case, the column driver_id is used to uniquely identify the different rows of the entity driver. We are currently fetching values of the features where driver_id is equal to 5. We can also fetch multiple such rows using the format: [{driver_id: val_1}, {driver_id: val_2}, .., {driver_id: val_n}] [{driver_id: val_1}, {driver_id: val_2}, .., {driver_id: val_n}]
entity_rows = [
- {
- "driver_id": 1001,
- },
- {
- "driver_id": 1002,
- },
- ]
-features_to_fetch = [
- "driver_hourly_stats:acc_rate",
- "driver_hourly_stats:conv_rate",
- "driver_hourly_stats:avg_daily_trips"
- ]
-returned_features = store.get_online_features(
- features=features_to_fetch,
- entity_rows=entity_rows,
-).to_dict()
-for key, value in sorted(returned_features.items()):
- print(key, " : ", value)Another important thing is the SQL Registry. We first make a path variable that uses the username, password, database name, etc. to make a connection string which it then uses to establish a connection to Teradata’s Database.
-path = 'teradatasql://'+ teradata_user +':' + teradata_password + '@'+host + '/?database=' + teradata_database + '&LOGMECH=' + teradata_log_mechIt will create the following table in your database:
-Entities (entity_name,project_id,last_updated_timestamp,entity_proto)
-Data_sources (data_source_name,project_id,last_updated_timestamp,data_source_proto)
-Feature_views (feature_view_name,project_id,last_updated_timestamp,materialized_intervals,feature_view_proto,user_metadata)
-Request_feature_views (feature_view_name,project_id,last_updated_timestamp,feature_view_proto,user_metadata)
-Stream_feature_views (feature_view_name,project_id,last_updated_timestamp,feature_view_proto,user_metadata)
-managed_infra (infra_name, project_id, last_updated_timestamp, infra_proto)
-validation_references (validation_reference_name, project_id, last_updated_timestamp, validation_reference_proto)
-saved_datasets (saved_dataset_name, project_id, last_updated_timestamp, saved_dataset_proto)
-feature_services (feature_service_name, project_id, last_updated_timestamp, feature_service_proto)
-on_demand_feature_views (feature_view_name, project_id, last_updated_timestamp, feature_view_proto, user_metadata)
-Additionally, if you want to see a complete (but not real-world), end-to-end example workflow example, see the demo/test_workflow.py script. This is used for testing the complete feast functionality.
An Enterprise Feature Store accelerates the value-gaining process in crucial stages of data analysis. It enhances productivity and reduces the time taken to introduce products in the market. By integrating Teradata with Feast, it enables the use of Teradata’s highly efficient parallel processing within a Feature Store, thereby enhancing performance.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Anypoint Studio (Studio) editors help you design and update your Mule applications, properties, and configuration files.
-To add and configure a connector in Studio:
-When you run the connector, you can view the app log to check for problems, as described in View the App Log.
-If you are new to configuring connectors in Studio, see Using Anypoint Studio to Configure a Connector. If, after reading this topic, you need additional information about the connector fields, see the Teradata Connector Reference.
-In Studio, create a new Mule project in which to add and configure the connector:
-In Studio, select File > New > Mule Project.
-Enter a name for your Mule project and click Finish.
-Add Teradata Connector to your Mule project to automatically populate the XML code with the connector’s namespace and schema location and to add the required dependencies to the project’s pom.xml file:
In the Mule Palette view, click (X) Search in Exchange.
-In the Add Dependencies to Project window, type teradata in the search field.
Click Teradata Connector in Available modules.
-Click Add.
-Click Finish.
-Adding a connector to a Mule project in Studio does not make that connector available to other projects in your Studio workspace.
-A source initiates a flow when a specified condition is met. -You can configure one of these input sources to use with Teradata Connector:
-Teradata > On Table Row
-Initiates a flow by selecting from a table at a regular interval and generates one message per obtained row
HTTP > Listener
-Initiates a flow each time it receives a request on the configured host and port
Scheduler
-Initiates a flow when a time-based condition is met
For example, to configure an On Table Row source, follow these steps:
-In the Mule Palette view, select Teradata > On Table Row.
-Drag On Table Row to the Studio canvas.
-In the On Table Row configuration screen, optionally change the value of the Display Name field.
-Click the plus sign (+) next to the Connector configuration field to configure a global element that can be used by all instances of the source in the app.
-In the Teradata Config window, on the General tab, specify the database connection information for the connector.
-On the Transactions tab, optionally specify the transaction isolation, or XA transactions, when connecting to the database.
-On the Advanced tab, optionally specify connection pooling and reconnection information, including a reconnection strategy.
-Click Test Connection to confirm that Mule can connect with the specified database.
-Click OK to close the window.
-In the On Table Row configuration screen, in Table, specify the name of the table to select from.
-When you add a connector operation to your flow, you immediately define a specific operation for that connector to perform.
-To add an operation for Teradata Connector, follow these steps:
-In the Mule Palette view, select Teradata Connector and then select the desired operation.
-Drag the operation onto the Studio canvas and to the right of the input source.
-The following screenshot shows the Teradata Connector operations in the Mule Palette view of Anypoint Studio:
-
-When you configure a connector, it’s best to configure a global element that all instances of that connector in the app can use.
-To configure the global element for Teradata Connector, follow these steps:
-Select the operation in the Studio canvas.
-In the configuration screen for the operation, click the plus sign (+) next to the Connector configuration field to access the global element configuration fields.
-In the Teradata Config window, on the General tab, specify the database connection information for the connector.
-On the Transactions tab, optionally specify the transaction isolation, or XA transactions, when connecting to the database.
-On the Advanced tab, optionally specify connection pooling and reconnection information, including a reconnection strategy.
-Click Test Connection to confirm that Mule can connect with the specified database.
-Click OK.
-The following screenshot shows the Teradata Connector Global Element Configuration window in Anypoint Studio:
-
-To check for problems, you can view the app log as follows:
-If you’re running the app from Anypoint Platform, the output is visible in the Anypoint Studio console window.
-If you’re running the app using Mule from the command line, the app log is visible in your OS console.
-Unless the log file path is customized in the app’s log file (log4j2.xml), you can also view the app log in the default location MULE_HOME/logs/<app-name>.log.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Anypoint Connector for Teradata (Teradata Connector) establishes communication between your Mule app and a Teradata Vantage database, enabling you to connect with your Teradata Vantage instance to load data and run SQL queries in Teradata Vantage tables.
-Reference: Teradata Connector Reference
-Release Notes: Teradata Connector Release Notes
-To use this connector, you must be familiar with:
-Teradata Vantage SQL
-Anypoint Connectors
-Mule runtime engine (Mule)
-Elements and global elements in a Mule flow
-Anypoint Studio (Studio)
-Before creating an app, you must have:
-Anypoint Studio version 7.5 or later
-Credentials to access the Teradata Vantage target resource
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Teradata Connector enables you to:
-Perform predefined queries, dynamically constructed queries, and template queries that are self-sufficient and customizable.
-Use a source listener operation to read from a database in the data source section of a flow.
-Execute other operations to read and write to a database anywhere in the process section.
-Run a single bulk update to perform multiple SQL requests.
-Make Data Definition Language (DDL) requests.
-Execute stored procedures and SQL scripts.
-The Teradata Connector supports:
-Connection pooling
-Auto reconnects after timeouts
-After you complete the prerequisites, you can try the examples and configure the connector using Anypoint Studio.
-Anypoint Connector for Teradata (Teradata Connector) establishes communication between your Mule app and a Teradata Vantage database, enabling you to connect with your Teradata Vantage instance to load data and run SQL queries in Teradata Vantage tables.
-Release Notes: Teradata Connector Release Notes
-Use these parameters to configure the default configuration.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Name |
-
- String - |
-
- The name for this configuration. Connectors reference the configuration with this name. - |
-- |
- x - |
-
Connection |
-
-
|
-
- The connection types to provide to this configuration. - |
-- |
- x - |
-
Expiration Policy |
-- |
- Configures the minimum amount of time that a dynamic configuration instance can remain idle before Mule considers it eligible for expiration. This does not mean that the platform expires the instance at the exact moment that it becomes eligible. Mule purges the instances as appropriate. - |
-- | - |
Configure the connection provider implementation that creates database connections from a referenced data source.
When you use a provider’s custom type in a Data Source Reference Connection, define the type inside the Column Types form of the Advanced section in the Database config.
| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Pooling Profile |
-- |
- Provides a way to configure database connection pooling - |
-- | - |
Column Types |
-
- Array of Column Type - |
-
- Specifies non-standard column types - |
-- | - |
Reconnection |
-
-
- |
-
- When the application is deployed, a connectivity test is performed on all connectors. If set to |
-- | - |
| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Pooling Profile |
-- |
- Provides a way to configure database connection pooling - |
-- | - |
Column Types |
-
- Array of Column Type - |
-
- Specifies non-standard column types - |
-- | - |
Transaction Isolation |
-
-
-Enumeration, one of: -
-
|
-
- The transaction isolation level to set on the driver when connecting the database - |
-
-
|
-- |
Use XA Transactions |
-
- Boolean - |
-
- Indicates whether or not the created datasource must support XA transactions - |
-
-
|
-- |
URL |
-
- String - |
-
- JDBC URL to use to connect to the database - |
-- |
- x - |
-
User |
-
- String - |
-
- Database username - |
-- | - |
Password |
-
- String - |
-
- Database password - |
-- | - |
Reconnection |
-
-
- |
-
- When the application is deployed, a connectivity test is performed on all connectors. If set to |
-- | - |
| - - | -
-To specify an SQL function in an SQL query in an operation, specify the SQL function in the {fn function()} format. For example, the SQL function CURRENT_TIMESTAMP is specified as {fn CURRENT_TIMESTAMP()}.
- |
-
<db:bulk-delete>
This operation allows delete operations to execute at various times using different parameter bindings and a single database statement. This improves performance compared to executing a single delete operation at various times.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Input Parameters |
-
- Array of Object - |
-
- Specifies a list of maps, which contain the parameter names as keys and the value the parameter is bound to, and in which every list item represents a row to insert. - |
-
-
|
-- |
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions - |
-
-
|
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. This property is required when streaming is true, in which case a default value of |
-- | - |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- This parameter allows you to optionally specify the type of one or more of the parameters in the query. If a value is provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:bulk-insert>
This operation allows inserts to execute at various times using different parameter bindings and a single database statement. This improves performance compared to executing a single insert operation at various times.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Input Parameters |
-
- Array of Object - |
-
- A list of maps in which every list item represents a row to be inserted, and the map contains the parameter names as keys and the value the parameter is bound to. - |
-
-
|
-- |
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions. - |
-
- JOIN_IF_POSSIBLE - |
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. No timeout is used by default. - |
-
- 0 - |
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A TimeUnit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a resultSet. This property is required when streaming is true; in that case a default value (10) is used. - |
-- | - |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters, but you cannot reference a parameter not present in the input values - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output. - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors. - |
-- | - |
<db:bulk-update>
This operation allows updates to execute at various times using different parameter bindings and a single database statement. This improves performance compared to executing one single update operation at various times.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Input Parameters |
-
- Array of Object - |
-
- Specifies a list of maps, which contain the parameter names as keys and the value the parameter is bound to, and in which every list item represents a row to insert. - |
-
-
|
-- |
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions. - |
-
- JOIN_IF_POSSIBLE - |
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:delete>
This operation deletes data in a database.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions - |
-
-
|
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If a value is provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example, |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:execute-ddl>
This operation allows execution of DDL queries against a database.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions - |
-
-
|
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:execute-script>
This operation executes an SQL script in a single database statement. The script is executed as provided by the user, without any parameter binding.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take for transactions. - |
-
-
|
-- |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- | - |
Script Path |
-
- String - |
-
- Specifies the location of a file to load. The file can point to a resource on the classpath, or on a disk. - |
-- | - |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:insert>
This operation inserts data into a database.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions - |
-
-
|
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to be set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (E.g: where id = :myParamName)). The map’s values contain the actual assignation for each parameter. - |
-- | - |
Auto Generate Keys |
-
- Boolean - |
-
- Indicates when to make auto-generated keys available for retrieval. - |
-
-
|
-- |
Auto Generated Keys Column Indexes |
-
- Array of Number - |
-
- List of column indexes that indicates which auto-generated keys to make available for retrieval - |
-- | - |
Auto Generated Keys Column Names |
-
- Array of String - |
-
- List of column names that indicates which auto-generated keys to make available for retrieval - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:select>
This operation queries data from a database. To prevent loading all the results at once, which can lead to performance and memory issues, results are automatically streamed. This means that pages of fetchSize rows are loaded when needed. If this operation is performed inside a transaction (that is, within a Try scope component) and that transaction is closed before consuming the data, accessing the results that haven’t been loaded will fail.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions - |
-
-
|
-- |
Streaming Strategy |
-
-
|
-
- Configure to use repeatable streams - |
-- | - |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to be set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example: where id = :myParamName)). The map’s values will contain the actual assignation for each parameter. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output. - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors. - |
-- | - |
When working with pooling profiles and the Select operation, the connection remains open until one of the following occurs:
-The flow execution ends
-The content of the streams are consumed completely
-The connection is the transaction key.
-| - - | --Because LOBs are treated as streams, the connection remains open until the flow execution ends, or until the content is consumed before the flow completes, in which case the best approach is taken to close the related connection. - | -
This behavior occurs because the result set the operation generates can have a stream or be part of an ongoing transaction.
-<db:query-single>
This operation selects a single data record from a database. If you provide an SQL query that returns more than one row, then only the first record is processed and returned. This operation does not use streaming, which means that immediately after performing the Query Single operation, the complete content of the selected record is loaded into memory.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of join action that operations can take regarding transactions - |
-
-
|
-- |
Streaming Strategy |
-
-
|
-
- Configure to use repeatable streams - |
-- | - |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- The maximum number of rows that any ResultSet object generated by this message processor can contain. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Enables you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to be set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example: where id = :myParamName)). The map’s values will contain the actual assignation for each parameter. - |
-- | - |
Target Variable |
-
- String - |
-
- Name of the variable in which to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- Expression that evaluates the operation’s output. The expression outcome is stored in the target variable. - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors. - |
-- | - |
When working with pooling profiles and the Query Single operation, the connection returns to the pool immediately after the operation is performed.
-<db:stored-procedure>
Invokes a stored procedure on the database. When the stored procedure returns one or more ResultSet instances, results are not read all at once. Instead, results are automatically streamed to prevent performance and memory issues. This behavior means that pages of fetchSize rows are loaded lazily when needed. If the Stored procedure operation is performed inside a transaction (for example, in a Try scope component), and that transaction is closed before consuming the data, accessing the results that haven’t been loaded will fail.
| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use. - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take regarding transactions. - |
-
- JOIN_IF_POSSIBLE - |
-- |
Streaming Strategy |
-
-
|
-
- Configure to use repeatable streams - |
-- | - |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. No timeout is used by default. - |
-
- 0 - |
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a resultSet. This property is required when streaming is true; in that case a default value (10) is used. - |
-- | - |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows to optionally specify the type of one or more of the parameters in the query. If provided, you’re not even required to reference all of the parameters, but you cannot reference a parameter not present in the input values - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to be set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example: where id = :myParamName)). The map’s values will contain the actual assignation for each parameter. - |
-- | - |
Input - Output Parameters |
-
- Object - |
-
- A map in which keys are the name of a parameter to be set on the JDBC prepared statement which is both input and output. Each parameter should be referenced in the SQL text using a colon prefix (for example: where id = :myParamName)). The map’s values will contain the actual assignation for each parameter. - |
-- | - |
Output Parameters |
-
- Array of Output Parameter - |
-
- A list of output parameters to be set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example: call multiply(:value, :result)) - |
-- | - |
Auto Generate Keys |
-
- Boolean - |
-
- Indicates when to make auto-generated keys available for retrieval. - |
-
-
|
-- |
Auto Generated Keys Column Indexes |
-
- Array of Number - |
-
- List of column indexes that indicates which auto-generated keys to make available for retrieval. - |
-- | - |
Auto Generated Keys Column Names |
-
- Array of String - |
-
- List of column names that indicates which auto-generated keys should be made available for retrieval. - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output. - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
When working with pooling profiles and the Stored procedure operation, the connection remains open until the flow execution ends or the content of the streams are consumed completely, or if the connection is the transaction key. This behavior occurs because the resultset the operation generates can have a stream or be part of an ongoing transaction.
-Starting with Database Connector 1.8.3, the connections on the Stored procedure operation are released if they are not part of a stream or transaction.
-<db:update>
Updates data in a database.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of joining action that operations can take for transactions - |
-
-
|
-- |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
SQL Query Text |
-
- String - |
-
- The text of the SQL query to execute - |
-- |
- x - |
-
Parameter Types |
-
- Array of Parameter Type - |
-
- Allows you to optionally specify the type of one or more of the parameters in the query. If provided, you’re not required to reference all of the parameters; but you cannot reference a parameter that is not present in the input values. - |
-- | - |
Input Parameters |
-
- Object - |
-
- A map in which keys are the name of an input parameter to set on the JDBC prepared statement. Each parameter should be referenced in the SQL text using a colon prefix (for example: where id = :myParamName)). The map’s values contain the actual assignation for each parameter. - |
-- | - |
Auto Generate Keys |
-
- Boolean - |
-
- Indicates when to make auto-generated keys available for retrieval - |
-
-
|
-- |
Auto Generated Keys Column Indexes |
-
- Array of Number - |
-
- List of column indexes that indicates which auto-generated keys to make available for retrieval - |
-- | - |
Auto Generated Keys Column Names |
-
- Array of String - |
-
- List of column names that indicates which auto-generated keys should be made available for retrieval - |
-- | - |
Target Variable |
-
- String - |
-
- The name of a variable to store the operation’s output - |
-- | - |
Target Value |
-
- String - |
-
- An expression to evaluate against the operation’s output and store the expression outcome in the target variable - |
-
-
|
-- |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors - |
-- | - |
<db:listener>
This operation selects from a table at a regular interval and generates one message per obtained row. Optionally, you can provide watermark and ID columns. If a watermark column is provided, the values taken from that column are used to filter the contents of the next poll, so that only rows with a greater watermark value are returned. If an ID column is provided, this component automatically verifies that the same row is not picked twice by concurrent polls.
-This operation does not support streaming, meaning that there is no need to perform additional transformations to the payload in order to access the operation results. This behavior is identical to the Query Single operation released in version 1.9.
-| Name | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Configuration |
-
- String - |
-
- The name of the configuration to use - |
-- |
- x - |
-
Table |
-
- String - |
-
- The name of the table to select from - |
-- |
- x - |
-
Watermark Column |
-
- String - |
-
- The name of the column to use for a watermark. Values taken from this column are used to filter the contents of the next poll, so that only rows with a greater watermark value are processed. - |
-- | - |
Id Column |
-
- String - |
-
- The name of the column to consider as the row ID. If provided, this component makes sure that the same row is not processed twice by concurrent polls. - |
-- | - |
Transactional Action |
-
-
-Enumeration, one of: -
-
|
-
- The type of beginning action that sources can take regarding transactions - |
-
-
|
-- |
Transaction Type |
-
-
-Enumeration, one of: -
-
|
-
- The type of transaction to create. Availability depends on the runtime version. - |
-
-
|
-- |
Primary Node Only |
-
- Boolean - |
-
- Whether this source should be executed only on the primary node when running in a cluster - |
-- | - |
Scheduling Strategy |
-
- scheduling-strategy - |
-
- Configures the scheduler that triggers the polling - |
-- |
- x - |
-
Redelivery Policy |
-- |
- Defines a policy for processing the redelivery of the same message - |
-- | - |
Query Timeout |
-
- Number - |
-
- Indicates the minimum amount of time before the JDBC driver attempts to cancel a running statement. By default, no timeout is used. - |
-
-
|
-- |
Query Timeout Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-
-
|
-- |
Fetch Size |
-
- Number - |
-
- Indicates how many rows to fetch from the database when rows are read from a ResultSet. - |
-
- 10 - |
-- |
Max Rows |
-
- Number - |
-
- Sets the limit for the maximum number of rows that any ResultSet object generated by this message processor can contain for the given number. If the limit is exceeded, the excess rows are silently dropped. - |
-- | - |
Reconnection Strategy |
-
-
|
-
- A retry strategy in case of connectivity errors. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Max Pool Size |
-
- Number - |
-
- Maximum number of connections a pool maintains at any given time - |
-
-
|
-- |
Min Pool Size |
-
- Number - |
-
- Minimum number of connections a pool maintains at any given time - |
-
-
|
-- |
Acquire Increment |
-
- Number - |
-
- Determines how many connections at a time to try to acquire when the pool is exhausted - |
-
-
|
-- |
Prepared Statement Cache Size |
-
- Number - |
-
- Determines how many statements are cached per pooled connection. Setting this to zero disables statement caching. - |
-
-
|
-- |
Max Wait |
-
- Number - |
-
- The amount of time a client trying to obtain a connection waits for it to be acquired when the pool is exhausted. Setting this value to zero (default) means wait indefinitely. This is equivalent to |
-
-
|
-- |
Max Wait Unit |
-
-
-Enumeration, one of: -
-
|
-
- A #maxWait. - |
-
- SECONDS - |
-- |
Max Idle Time |
-
- Number - |
-
- Determines how many seconds a connection can remain pooled but unused before being discarded. Setting this value to zero (default) means idle connections never expire. - |
-
-
|
-- |
Additional Properties |
-
- Object - |
-
- A map in which keys are the name of a pooling profile configuration property. Does not support the use of expressions. These properties cannot be used to override any of the previously specified properties (like Max Pool Size or Min Pool Size), the main property prevails if an attempt is made to override it. The map’s values contain the actual assignation for each parameter. - |
-- | - |
Max Statement |
-
- Number - |
-
- Defines the total number PreparedStatements a DataSource will cache. The pool destroys the least-recently-used PreparedStatement when it reaches the specified limit. When set to |
-- | - |
Test connection on checkout |
-
- Boolean - |
-
- Disables connection testing on checkout to improve performance. If set to |
-
-
|
-- |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Id |
-
- Number - |
-
- Type identifier used by the JDBC driver - |
-- |
- x - |
-
Type Name |
-
- String - |
-
- Name of the data type used by the JDBC driver - |
-- |
- x - |
-
Class Name |
-
- String - |
-
- Indicates which Java class must be used to map the database type - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Fails Deployment |
-
- Boolean - |
-
- When the application is deployed, a connectivity test is performed on all connectors. If set to |
-- | - |
Reconnection Strategy |
-
-
|
-
- The reconnection strategy to use - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Frequency |
-
- Number - |
-
- How often to reconnect (in milliseconds) - |
-- | - |
Count |
-
- Number - |
-
- The number of reconnection attempts to make - |
-- | - |
blocking |
-
- Boolean - |
-
- If set to |
-
-
|
-- |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Frequency |
-
- Number - |
-
- How often in milliseconds to reconnect - |
-- | - |
blocking |
-
- Boolean - |
-
- If set to |
-
-
|
-- |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Enabled Protocols |
-
- String - |
-
- A comma-separated list of protocols enabled for this context. - |
-- | - |
Enabled Cipher Suites |
-
- String - |
-
- A comma-separated list of cipher suites enabled for this context. - |
-- | - |
Trust Store |
-
-
- |
-- | - | - |
Key Store |
-
-
- |
-- | - | - |
Revocation Check |
-
-
|
-- | - | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Path |
-
- String - |
-
- The location (which will be resolved relative to the current classpath and file system, if possible) of the trust store. - |
-- | - |
Password |
-
- String - |
-
- The password used to protect the trust store. - |
-- | - |
Type |
-
- String - |
-
- The type of store used. - |
-- | - |
Algorithm |
-
- String - |
-
- The algorithm used by the trust store. - |
-- | - |
Insecure |
-
- Boolean - |
-
- If true, no certificate validations will be performed, rendering connections vulnerable to attacks. Use at your own risk. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Path |
-
- String - |
-
- The location (which will be resolved relative to the current classpath and file system, if possible) of the key store. - |
-- | - |
Type |
-
- String - |
-
- The type of store used. - |
-- | - |
Alias |
-
- String - |
-
- When the key store contains many private keys, this attribute indicates the alias of the key that should be used. If not defined, the first key in the file will be used by default. - |
-- | - |
Key Password |
-
- String - |
-
- The password used to protect the private key. - |
-- | - |
Password |
-
- String - |
-
- The password used to protect the key store. - |
-- | - |
Algorithm |
-
- String - |
-
- The algorithm used by the key store. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Only End Entities |
-
- Boolean - |
-
- Only verify the last element of the certificate chain. - |
-- | - |
Prefer Crls |
-
- Boolean - |
-
- Try CRL instead of OCSP first. - |
-- | - |
No Fallback |
-
- Boolean - |
-
- Do not use the secondary checking method (the one not selected before). - |
-- | - |
Soft Fail |
-
- Boolean - |
-
- Avoid verification failure when the revocation server can not be reached or is busy. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Url |
-
- String - |
-
- The URL of the OCSP responder. - |
-- | - |
Cert Alias |
-
- String - |
-
- Alias of the signing certificate for the OCSP response (must be in the trust store), if present. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Path |
-
- String - |
-
- The path to the CRL file. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Max Idle Time |
-
- Number - |
-
- A scalar time value for the maximum amount of time a dynamic configuration instance should be allowed to be idle before it’s considered eligible for expiration - |
-- | - |
Time Unit |
-
-
-Enumeration, one of: -
-
|
-
- A time unit that qualifies the |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Max Redelivery Count |
-
- Number - |
-
- The maximum number of times a message can be redelivered and processed unsuccessfully before triggering a process-failed-message - |
-- | - |
Use Secure Hash |
-
- Boolean - |
-
- Whether to use a secure hash algorithm to identify a redelivered message. - |
-- | - |
Message Digest Algorithm |
-
- String - |
-
- The secure hashing algorithm to use. If this is not set, the default is SHA-256. - |
-
-
|
-- |
Id Expression |
-
- String - |
-
- Defines one or more expressions to use to determine when a message has been redelivered. This property can be set only if Use secure hash is set to |
-- | - |
Object Store |
-
- Object Store - |
-
- The object store where the redelivery counter for each message is stored - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Key |
-
- String - |
-
- The name of the input parameter - |
-- |
- x - |
-
Type Classifier |
-- | - | - |
- x - |
-
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Type |
-
-
-Enumeration, one of: -
-
|
-- | - | - |
Custom Type |
-
- String - |
-- | - | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Affected Rows |
-
- Number - |
-- | - | - |
Generated Keys |
-
- Object - |
-- | - | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Initial Buffer Size |
-
- Number - |
-
- The number of instances that are initially allowed to be kept in memory to consume the stream and provide random access to it. If the stream contains more data than can fit into this buffer, then the buffer expands according to the Buffer size increment attribute, with an upper limit of Max in memory size. The default value is 100 instances. - |
-
-
|
-- |
Buffer Size Increment |
-
- Number - |
-
- Specifies by how much the buffer size expands if it exceeds its initial size. Setting a value of zero or lower means that the buffer should not expand, in which case a |
-
-
|
-- |
Max Buffer Size |
-
- Number - |
-
- The maximum amount of memory to use. If more than the specified maximum amount of memory is used, then a `STREAM_MAXIMUM_SIZE_EXCEEDE`D error is raised. A value lower than, or equal to, zero means no limit. - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
In Memory Objects |
-
- Number - |
-
- The maximum number of instances to keep in memory. If more than the specified maximum is required, then content starts to buffer on disk. - |
-- | - |
Buffer Unit |
-
-
-Enumeration, one of: -
-
|
-
- The unit in which maxInMemorySize is expressed - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
Initial Buffer Size |
-
- Number - |
-
- The number of instances that are initially allowed to be kept in memory to consume the stream and provide random access to it. If the stream contains more data than can fit into this buffer, then the buffer expands according to the Buffer size increment attribute, with an upper limit of Max in memory size - |
-- | - |
Buffer Size Increment |
-
- Number - |
-
- Specifies by how much the buffer size expands if it exceeds its initial size. Setting a value of zero or lower means that the buffer should not expand, in which case a |
-- | - |
Max Buffer Size |
-
- Number - |
-
- The maximum amount of memory to use. If more than the specified maximum amount of memory is used, then a |
-- | - |
Buffer Unit |
-
- Enumeration, one of: - BYTE - KB - MB - GB - |
-
- The unit in which all these attributes are expressed - |
-- | - |
| Field | -Type | -Description | -Default Value | -Required | -
|---|---|---|---|---|
In Memory Size |
-
- Number - |
-
- Defines the maximum memory that the stream should use to keep data in memory. If more than that is consumed content on the disk is buffered. - |
-- | - |
Buffer Unit |
-
-
-Enumeration, one of: -
-
|
-
- The unit in which Max in memory size is expressed - |
-- | - |
Anypoint Connector for Teradata (Teradata Connector) establishes communication between your Mule app and a Teradata Vantage database, enabling you to connect with your Teradata Vantage instance to load data and run SQL queries in Teradata Vantage tables.
-Date: February 8, 2023
-The initial version is based and extended on MuleSoft’s Database Connector - Mule 4. This version supports the list of features:
-Perform predefined queries, dynamically constructed queries, and template queries that are self-sufficient and customizable.
-Use a source listener operation to read from a database in the data source section of a flow.
-Execute other operations to read and write to a database anywhere in the process section.
-Run a single bulk update to perform multiple SQL requests.
-Make Data Definition Language (DDL) requests.
-Execute stored procedures and SQL scripts.
-Support pooling profile configuration for database connection
-Support auto reconnect to database
-This example is a clone of the Mulesoft MySQL sample project. -It demonstrates how to query a Teradata database and expose results over REST API.
-Mulesoft Anypoint Studio. You can download a 30-day trial from https://www.mulesoft.com/platform/studio.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
This example Mule service takes an HTTP request, queries the Teradata Vantage database and returns results in JSON format.
-
-The Mule HTTP connector listens for HTTP GET requests with the form: http://<host>:8081/?lastname=<parameter>;.
-The HTTP connector passes the value of <parameter> as one of the message properties to a database connector.
-The database connector is configured to extract this value and use it in this SQL query:
SELECT * FROM hr.employees WHERE LastName = :lastNameAs you can see, we are using parameterized query with reference to the value of the parameter passed to the HTTP connector. -So if the HTTP connector receives http://localhost:8081/?lastname=Smith, the SQL query will be:
-SELECT * FROM employees WHERE last_name = SmithThe database connector instructs the database server to run the SQL query, retrieves the result of the query, and passes it to the Transform message processor which converts the result to JSON. -Since the HTTP connector is configured as request-response, the result is returned to the originating HTTP client.
-Clone Teradata/mule-jdbc-example repository:
git clone https://github.com/Teradata/mule-jdbc-exampleEdit src/main/mule/querying-a-teradata-database.xml, find the Teradata connection string jdbc:teradata://<HOST>/user=<username>,password=<password> and replace Teradata connection parameters to match your environment.
| - - | -
-
-
-Should your Vantage instance be accessible via ClearScape Analytics Experience, you must replace <HOST> with the host URL of your ClearScape Analytics Experience environment. Additionally, the 'user' and 'password' should be updated to reflect your ClearScape Analytics Environment’s username and password. - |
-
Create a sample database in your Vantage instance. -Populate it with sample data.
- -- create database
- CREATE DATABASE HR
- AS PERMANENT = 60e6, SPOOL = 120e6;
-
- -- create table
- CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
- )
- UNIQUE PRIMARY INDEX ( GlobalID );
-
- -- insert a record
- INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
- ) VALUES (
- 101,
- 'Test',
- 'Testowsky',
- '1980-01-05',
- '2004-08-01',
- 01
- );Open the project in Anypoint Studio.
-Once in Anypoint Studio, click on Import projects..:
Select Anypoint Studio project from File System:
Use the directory where you cloned the git repository as the Project Root. Leave all other settings at their default values.
Run the example application in Anypoint Studio using the Run menu.
-The project will now build and run. It will take a minute.
Go to your web browser and send the following request: http://localhost:8081/?lastname=Testowsky.
-You should get the following JSON response:
-[
- {
- "JoinedDate": "2004-08-01T00:00:00",
- "DateOfBirth": "1980-01-05T00:00:00",
- "FirstName": "Test",
- "GlobalID": 101,
- "DepartmentCode": 1,
- "LastName": "Testowsky"
- }
-]View this document for more information on how to configure a database connector on your machine.
-Access plain Reference material for the Database Connector.
-Learn more about DataSense.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Native Object Storage (NOS) is a Vantage feature that allows you to query data stored in files in object storage such as AWS S3, Google GCS, Azure Blob or on-prem implementations. It’s useful in scenarios where you want to explore data without building a data pipeline to bring it into Vantage.
-You need access to a Teradata Vantage instance. NOS is enabled in all Vantage editions from Vantage Express through Developer, DYI to Vantage as a Service starting from version 17.10.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
| - - | --Currently, NOS supports CSV, JSON (as array or new-line delimited), and Parquet data formats. - | -
Let’s say you have a dataset stored as CSV files in an S3 bucket. You want to explore the dataset before you decide if you want to bring it into Vantage. For this scenario, we are going to use a public dataset published by Teradata that contains river flow data collected by the -U.S. Geological Survey. The bucket is at https://td-usgs-public.s3.amazonaws.com/.
-Let’s first have a look at sample CSV data. We take the first 10 rows that Vantage will fetch from the bucket:
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d;Here is what I’ve got:
-GageHeight2 Flow site_no datetime Precipitation GageHeight ------------ ----- -------- ---------------- ------------- ----------- -10.9 15300 09380000 2018-06-28 00:30 671 9.80 -10.8 14500 09380000 2018-06-28 01:00 673 9.64 -10.7 14100 09380000 2018-06-28 01:15 672 9.56 -11.0 16200 09380000 2018-06-27 00:00 669 9.97 -10.9 15700 09380000 2018-06-27 00:30 668 9.88 -10.8 15400 09380000 2018-06-27 00:45 672 9.82 -10.8 15100 09380000 2018-06-27 01:00 672 9.77 -10.8 14700 09380000 2018-06-27 01:15 672 9.68 -10.9 16000 09380000 2018-06-27 00:15 668 9.93 -10.8 14900 09380000 2018-06-28 00:45 672 9.72-
We have got plenty of numbers, but what do they mean? To answer this question, we will ask Vantage to detect the schema of the CSV files:
-SELECT
- *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- RETURNTYPE='NOSREAD_SCHEMA'
-) AS d;Vantage will now fetch a data sample to analyze the schema and return results:
-Name Datatype FileType Location ---------------- ----------------------------------- --------- ------------------------------------------------------------------- -GageHeight2 decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Flow decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -site_no int csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -datetime TIMESTAMP(0) FORMAT'Y4-MM-DDBHH:MI' csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -Precipitation decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv -GageHeight decimal(3,2) csv /S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09513780/2018/06/27.csv-
We see that the CSV files have 6 columns. For each column, we get the name, the datatype and the file coordinates that were used to infer the schema.
-Now that we know the schema, we can work with the dataset as if it was a regular SQL table. To prove the point, let’s try to do some data aggregation. Let’s get an average temperature per site for sites that collect temperatures.
-SELECT
- site_no Site_no, AVG(Flow) Avg_Flow
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
-) AS d
-GROUP BY
- site_no
-HAVING
- Avg_Flow IS NOT NULL;Result:
-Site_no Avg_Flow --------- --------- -09380000 11 -09423560 73 -09424900 93 -09429070 81-
To register your ad hoc exploratory activity as a permanent source, create it as a foreign table:
--- If you are running this sample as dbc user you will not have permissions
--- to create a table in dbc database. Instead, create a new database and use
--- the newly create database to create a foreign table.
-
-CREATE DATABASE Riverflow
- AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB
-
--- change current database to Riverflow
-DATABASE Riverflow;
-
-CREATE FOREIGN TABLE riverflow
- USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );
-
-SELECT top 10 * FROM riverflow;Result:
-Location GageHeight2 Flow site_no datetime Precipitation GageHeight -------------------------------------------------------------------- ----------- ---- ------- ------------------- ------------- ---------- -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:40:00 1.21 null -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:30:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:45:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 01:00:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09400815/2018/07/10.csv null 0.00 9400815 2018-07-10 00:15:00 0.00 -0.01 -/S3/s3.amazonaws.com/td-usgs-public/CSVDATA/09429070/2018/07/02.csv null null 9429070 2018-07-02 14:38:00 1.06 null-
This time, the SELECT statement looks like a regular select against an in-database table. If you require subsecond response time when querying the data, there is an easy way to bring the CSV data into Vantage to speed things up. Read on to find out how.
Querying object storage takes time. What if you decided that the data looks interesting and you want to do some more analysis with a solution that will you quicker answers? The good news is that data returned with NOS can be used as a source for CREATE TABLE statements. Assuming you have CREATE TABLE privilege, you will be able to run:
| - - | -
-This query assumes you created database Riverflow and a foreign table called riverflow in the previous step.
- |
-
-- This query assumes you created database `Riverflow`
--- and a foreign table called `riverflow` in the previous step.
-
-CREATE MULTISET TABLE riverflow_native (site_no, Flow, GageHeight, datetime)
-AS (
- SELECT site_no, Flow, GageHeight, datetime FROM riverflow
-) WITH DATA
-NO PRIMARY INDEX;
-
-SELECT TOP 10 * FROM riverflow_native;Result:
-site_no Flow GageHeight datetime -------- ----- ---------- ------------------- -9400815 .00 -.01 2018-07-10 00:30:00 -9400815 .00 -.01 2018-07-10 01:00:00 -9400815 .00 -.01 2018-07-10 01:15:00 -9400815 .00 -.01 2018-07-10 01:30:00 -9400815 .00 -.01 2018-07-10 02:00:00 -9400815 .00 -.01 2018-07-10 02:15:00 -9400815 .00 -.01 2018-07-10 01:45:00 -9400815 .00 -.01 2018-07-10 00:45:00 -9400815 .00 -.01 2018-07-10 00:15:00 -9400815 .00 -.01 2018-07-10 00:00:00-
This time, the SELECT query returned in less than a second. Vantage didn’t have to fetch the data from NOS. Instead, it answered using data that was already on its nodes.
So far, we have used a public bucket. What if you have a private bucket? How do you tell Vantage what credentials it should use?
-It is possible to inline your credentials directly into your query:
-SELECT
- TOP 10 *
-FROM (
- LOCATION='/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/'
- AUTHORIZATION='{"ACCESS_ID":"","ACCESS_KEY":""}'
-) AS d;Entering these credentials all the time can be tedious and less secure. In Vantage, you can create an authorization object that will serve as a container for your credentials:
-CREATE AUTHORIZATION aws_authorization
- USER 'YOUR-ACCESS-KEY-ID'
- PASSWORD 'YOUR-SECRET-ACCESS-KEY';You can then reference your authorization object when you create a foreign table:
-CREATE FOREIGN TABLE riverflow
-, EXTERNAL SECURITY aws_authorization
-USING ( LOCATION('/s3/td-usgs-public.s3.amazonaws.com/CSVDATA/') );So far, we have talked about reading and importing data from object storage. Wouldn’t it be nice if we had a way to use SQL to export data from Vantage to object storage? This is exactly what WRITE_NOS function is for. Let’s say we want to export data from riverflow_native table to object storage. You can do so with the following query:
SELECT * FROM WRITE_NOS (
- ON ( SELECT * FROM riverflow_native )
- PARTITION BY site_no ORDER BY site_no
- USING
- LOCATION('YOUR-OBJECT-STORE-URI')
- AUTHORIZATION(aws_authorization)
- STOREDAS('PARQUET')
- COMPRESSION('SNAPPY')
- NAMING('RANGE')
- INCLUDE_ORDERING('TRUE')
-) AS d;Here, we instruct Vantage to take data from riverflow_native and save it in YOUR-OBJECT-STORE-URI bucket using parquet format. The data will be split into files by site_no attribute. The files will be compressed.
In this quick start we have learned how to read data from object storage using Native Object Storage (NOS) functionality in Vantage. NOS supports reading and importing data stored in CSV, JSON and Parquet formats. NOS can also export data from Vantage to object storage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This how-to demonstrates how to use the ODBC driver with Teradata Vantage on Ubuntu.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Root access to a Ubuntu machine.
-Install dependencies:
-apt update && DEBIAN_FRONTEND=noninteractive apt install -y wget unixodbc unixodbc-dev iodbc python3-pipInstall Teradata ODBC driver for Ubuntu:
-wget https://downloads.teradata.com/download/cdn/connectivity/odbc/17.10.x.x/tdodbc1710__ubuntu_x8664.17.10.00.14-1.tar.gz \
- && tar -xzf tdodbc1710__ubuntu_x8664.17.10.00.14-1.tar.gz \
- && dpkg -i tdodbc1710/tdodbc1710-17.10.00.14-1.x86_64.debConfigure ODBC, by creating file /etc/odbcinst.ini with the following content:
[ODBC Drivers]
-Teradata Database ODBC Driver 17.10=Installed
-
-[Teradata Database ODBC Driver 17.10]
-Description=Teradata Database ODBC Driver 17.10
-Driver=/opt/teradata/client/17.10/odbc_64/lib/tdataodbc_sb64.soWe will validate the installation with a sample Python application. Create test.py file with the following content.
-Replace DBCName=192.168.86.33;UID=dbc;PWD=dbc with the IP address of your Teradata Vantage instance, username and password:
import pyodbc
-
-print(pyodbc.drivers())
-
-cnxn = pyodbc.connect('DRIVER={Teradata Database ODBC Driver 17.10};DBCName=192.168.86.33;UID=dbc;PWD=dbc;')
-cursor = cnxn.cursor()
-
-cursor.execute("SELECT CURRENT_DATE")
-for row in cursor.fetchall():
- print(row)
-EOFRun the test application:
-python3 test.pyYou should get output similar to:
-['ODBC Drivers', 'Teradata Database ODBC Driver 17.10'] -(datetime.date(2022, 1, 5), )-
This how-to demonstrated how to use ODBC with Teradata Vantage on Ubuntu. The how-to shows how to install the ODBC Teradata driver and the dependencies. It then shows how to configure ODBC and validate connectivity with a simple Python application.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This how-to demonstrates how to create a connection to Teradata Vantage with DataHub, and ingest metadata about tables and views, along with usage and lineage information.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
DataHub installed. See DataHub Quickstart Guide
-Install the Teradata plugin for DataHub in the environment where you have DataHub installed
-pip install 'acryl-datahub[teradata]'Setup a Teradata user and set privileges to allow that user to read the dictionary tables
-CREATE USER datahub FROM <database> AS PASSWORD = <password> PERM = 20000000;
-
-GRANT SELECT ON dbc.columns TO datahub;
-GRANT SELECT ON dbc.databases TO datahub;
-GRANT SELECT ON dbc.tables TO datahub;
-GRANT SELECT ON DBC.All_RI_ChildrenV TO datahub;
-GRANT SELECT ON DBC.ColumnsV TO datahub;
-GRANT SELECT ON DBC.IndicesV TO datahub;
-GRANT SELECT ON dbc.TableTextV TO datahub;
-GRANT SELECT ON dbc.TablesV TO datahub;
-GRANT SELECT ON dbc.dbqlogtbl TO datahub; -- if lineage or usage extraction is enabledIf you want to run profiling, you need to grant select permission on all the tables you want to profile.
-If you want to extract lineage or usage metadata, query logging must be enabled and it is set to size which will fit for your queries (the default query text size Teradata captures is max 200 chars) An example how you can set it for all users:
--- set up query logging on all
-
-REPLACE QUERY LOGGING LIMIT SQLTEXT=2000 ON ALL;With DataHub running, open the DataHub GUI and login. In this example this is running at localhost:9002
-Start the new connection wizard by clicking on the ingestion plug icon
-
-and then selecting "Create new source"
-
-Scroll the list of available sources and select Other
-
-A recipe is needed to configure the connection to Teradata and define the options required such as whether to capture table and column lineage, profile the data or retrieve usage statistics. Below is a simple recipe to get you started. The host, username and password should be changed to match your environment.
-pipeline_name: my-teradata-ingestion-pipeline
-source:
- type: teradata
- config:
- host_port: "myteradatainstance.teradata.com:1025"
- username: myuser
- password: mypassword
- #database_pattern:
- # allow:
- # - "my_database"
- # ignoreCase: true
- include_table_lineage: true
- include_usage_statistics: true
- stateful_ingestion:
- enabled: truePasting the recipe into the window should look like this:
-
-Click Next and then setup the required schedule.
-
-Click Next to Finish Up and give the connection a name. Click Advanced so that the correct CLI version can be set. DataHub support for Teradata became available in CLI 0.12.x. Suggest selecting the most current version to ensure the best compatibility.
-
-Once the new source has been saved, it can be executed manually by clicking Run.
-
-Clicking on "Succeeded" after a sucessful execution will bring up a dialogue similar to this one where you can see the Databases, Tables and Views that have been ingested into DataHub.
-
-The metadata can now be explored in the GUI by browsing:
-DataSets provides a list of the datasets (tables and views) loaded
-
-Entities captured from the database
-
-Schema of an entity showing column/field names, data types and usage if it has been captured
-
-Lineage providing a visual representation of how data is linked between tables and views
-
-This how-to demonstrated how to create a connection to Teradata Vantage with DataHub in order to capture metadata of tables, views along with lineage and usage statistics.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This how-to demonstrates how to create a connection to Teradata Vantage with DBeaver.
-Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
DBeaver installed. See DBeaver Community or DBeaver PRO for installation options.
-Start the new connection wizard by clicking on the plug icon (
) in the upper left corner of the application window or go to Database → New Database Connection.
On Select your database screen, start typing teradata and select the Teradata icon.
-On the main tab, you need to set all primary connection settings. The required ones include Host, Port, Database, Username, and Password.
| - - | -
-In Teradata Vantage, when a user is created a corresponding database with the same is created as well. DBeaver requires that you enter the database. If you don’t know what database you want to connect to, use your username in the database field.
- |
-
| - - | -
-With DBeaver PRO, you can not only use the standard ordering of tables but also hierarchically link tables to a specific database or user. Expanding and collapsing the databases or users will help you navigate from one area to another without swamping the Database Navigator window. Check the Show databases and users hierarchically box to enable this setting.
- |
-
| - - | -
-In many environments Teradata Vantage can only be accessed using the TLS protocol. When in DBeaver PRO, check Use TLS protocol option to enable TLS.
- |
-
-Click on Finish.
The default logon mechanism when creating a DBeaver connection is TD2. To add other logon mechanisms, follow the steps below:
-Navigate to the database menu and click on Driver Manager.
-From the list of driver names, select Teradata and click "Copy".
-
-In the "URL Template" field, define your selected logon mechanism.
-jdbc:teradata://{host}/LOGMECH=LDAP,DATABASE={database},DBS_PORT={port}
-Click "OK".
-The new driver is now available to create connections with the selected logon mechanism.
-
-The process for setting up a new connection with the alternative mechanism is the same as described above for adding a new connection.
-
-If your database cannot be accessed directly, you can use an SSH tunnel. All settings are available on the SSH tab. DBeaver supports the following authentication methods: user/password, public key, SSH agent authentication.
-This how-to demonstrated how to create a connection to Teradata Vantage with DBeaver.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This tutorial demonstrates how to install Airflow on an AWS EC2 VM, configure the workflow to use dbt, and run it against a Teradata Vantage database. Airflow is a task scheduling tool that is typically used to build data pipelines to process and load data. In this example, we go through the Airflow installation process, which creates a Docker-based Airflow environment. Once Airflow is installed, we run several Airflow DAG (Direct Acyclic Graph, or simply workflow) examples that load data into a Teradata Vantage database.
-Access to AWS (Amazon Web Services) with permissions to create a VM.
-| - - | --This tutorial can be adjusted to other compute platforms or even on a bare metal machine as long as it has a computing and storage capacity comparable to the machine mentioned in this document (t2.2xlarge EC2 on AWS with approximately 100GB of storage) and is connected to the internet. If you decide to use a different compute platform, some steps in the tutorial will have to be altered. - | -
An SSH client.
- -Access to a Teradata Vantage database. If you don’t have access to Teradata Vantage, explore Vantage Express - a free edition for developers.
-Go to the AWS EC2 console and click on Launch instance.
Select Red Hat for OS image.
Select t2.2xlarge for instance type.
Create a new key pair or use an existing one.
-Apply network settings that will allow you ssh to the server and the server will have outbound connectivity to the Internet. Usually, applying the default settings will do.
-Assign 100GB of storage.
-ssh to the machine using ec2-user user.
Check if python is installed (should be Python 3.7 or higher). Type python or python3 on the command line.
If python is not installed (you are getting command not found message) run the commands below to install it. The commands may require you to confirm the installation by typing y and enter.
sudo yum install python3
-# create a virtual environment for the project
-sudo yum install python3-pip
-sudo pip3 install virtualenvCreate the Airflow directory structure (from the ec2-user home directory /home/ec2-user)
-mkdir airflow
-cd airflow
-mkdir -p ./dags ./logs ./plugins ./data ./config ./data
-echo -e "AIRFLOW_UID=$(id -u)" > .envUse your preferred file transfer tool (scp, PuTTY, MobaXterm, or similar) to upload airflow.cfg file to airflow/config directory.
Docker is a containerization tool that allows us to install Airflow in a containerized environment.
-| - - | -
-The steps must be executed in airflow directory.
- |
-
Uninstall podman (RHEL containerization tool)
-sudo yum remove docker \
-docker-client \
-docker-client-latest \
-docker-common \
-docker-latest \
-docker-latest-logrotate \
-docker-logrotate \
-docker-engine \
-podman \
-runcInstall yum utilities
-sudo yum install -y yum-utilsAdd docker to yum repository.
-sudo yum-config-manager \
---add-repo \
-https://download.docker.com/linux/centos/docker-ce.repoInstall docker.
-sudo yum install docker-ce docker-ce-cli containerd.ioStart docker as a service. The first command runs the docker service automatically when the system starts up next time. The second command starts Docker now.
-sudo systemctl enable docker
-sudo systemctl start dockerCheck if Docker is installed correctly. This command should return an empty list of containers (since we have not started any container yet):
-sudo docker psdocker-compose and docker environment configuration filesUpload docker-compose.yaml and Dockerfile files to the VM and save them in airflow directory.
| - - | -
- What
-docker-compose.yaml and Dockerfile do
-
-
-
-If you would like to learn more what |
-
Install docker-compose (necessary to run the yaml file).
-| - - | --The instructions are based on version 1.29.2. Check out https://github.com/docker/compose/releases site for the latest release and update the command below as needed. - | -
sudo curl -L https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
-sudo chmod +x /usr/local/bin/docker-compose
-sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-composeTest your docker-compose installation. The command should return the docker-compose version, for example docker-compose version 1.29.2, build 5becea4c:
docker-compose --version| - - | -
-These steps set up a sample dbt project. dbt tool itself will be installed on the containers later by docker-compose.
- |
-
Install git:
-sudo yum install gitGet the sample jaffle shop dbt project:
-| - - | -
-The dbt directories will be created under the home directory (not under airflow). The home directory in our example is /home/ec2-user.
- |
-
# move to home dir
-cd
-mkdir dbt
-cd dbt
-git clone https://github.com/Teradata/jaffle_shop-dev.git jaffle_shop
-cd jaffle_shop
-mkdir target
-chmod 777 target
-echo '' > target/index.html
-chmod o+w target/index.htmlCreate the airflowtest and jaffle_shop users/databases on your Teradata database by using your preferred database tool (Teradata Studio Express, bteq or similar). Log into the database as dbc, then execute the commands (change the passwords if needed):
CREATE USER "airflowtest" FROM "dbc" AS PERM=5000000000 PASSWORD="abcd";
-CREATE USER "jaffle_shop" FROM "dbc" AS PERM=5000000000 PASSWORD="abcd";Create the dbt configuration directory:
-cd
-mkdir .dbtCopy profiles.yml into the .dbt directory.
Edit the file so it corresponds to your Teradata database setup. At a minium, you will need to change the host, user and password. Use jaffle_shop user credentials you set up in step 3.
Run the docker environment creation script in the airflow directory where Dockerfile and docker-compose.yaml:
cd ~/airflow
-sudo docker-compose up --buildThis can take 5-10 minutes, when the installation is complete you should see on the screen a message similar to this:
-airflow-webserver_1 | 127.0.0.1 - - [13/Sep/2022:00:20:48 +0000] "GET /health HTTP/1.1" 200 187 "-" "curl/7.74.0"This means the Airflow webserver is ready to accept calls.
-Now Airflow should be up. The terminal session that we were using during the installation will be used to display log messages, so it is recommended -to open another terminal session for subsequent steps. To check the Airflow installation type:
-sudo docker psThe result should be something like:
-CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
-60d50d9f43f5 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-scheduler_1
-e2b46ec98274 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_3_1
-7b44004c7277 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_1_1
-4017b8ce9235 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp airflow_airflow-webserver_1
-3cc407e2d565 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:5555->5555/tcp, :::5555->5555/tcp, 8080/tcp airflow_flower_1
-340a83b202e3 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-triggerer_1
-82198f0d8b84 apache/airflow:2.2.4 "/usr/bin/dumb-init …" 18 minutes ago Up 18 minutes (healthy) 8080/tcp airflow_airflow-worker_2_1
-382c3077c1e5 redis:latest "docker-entrypoint.s…" 18 minutes ago Up 18 minutes (healthy) 6379/tcp airflow_redis_1
-8a3be8d8a7f4 nginx "/docker-entrypoint.…" 18 minutes ago Up 18 minutes (healthy) 0.0.0.0:4000->80/tcp, :::4000->80/tcp airflow_nginx_1
-9ca888e9e8df postgres:13 "docker-entrypoint.s…" 18 minutes ago Up 18 minutes (healthy) 5432/tcp airflow_postgres_1OPTIONAL: If you want to delete the docker installation (for example to update the docker-compose.yaml and the Dockerfile files and recreate a different environment), the command is (from the airflow directory where these files are located):
-sudo docker-compose down --volumes --rmi allOnce the stack is down, update the configuration files and restart by running the command in step 1.
-To test if the Airflow web UI works, type the following urls on your browser. Replace <VM_IP_ADDRESS> with the external IP address of the VM:
DAG UI: http://<YOUR_IP_ADDRESS>:8080/home - username: airflow / password: airflow
Flower Airflow UI (worker control): http://<YOUR_IP_ADDRESS>:5555/
Copy airflow_dbt_integration.py, db_test_example_dag.py, discover_dag.txt, variables.json files to /home/ec2-user/airflow/dags.
Examine the files:
-airflow_dbt_integration.py - a simple Teradata sql example that creates a few tables and runs queries.
db_test_example_dag.py - runs a dbt example (i.e. integration of dbt and airflow with a Teradata database). In this example a fictitious jaffle_shop data model is created, loaded and the documentation for this project is produced (you can view it by pointing your browser to http://<VM_IP_ADDRESS>:4000/)
| - - | -
- Adjust
-db_test_example_dag.py
-
-
|
-
discover_dag.py - an example on how to load various types of data files (CSV, Parquet, JSON). The source code file contains comments that explain what the program does and how to use it. This example relies on variables.json file. The file needs to be imported into Airflow. It will happen in subsequent steps.
Wait for a few minutes until these dag files are picked up by the airflow tool. Once they are picked up they will appear on the list of dags on the Airflow home page.
-Import variables.json file as a variable file into Airflow:
Click on Admin → Variables menu item to go to the Variables page
-Click on Choose File, then select variable.json in your file explorer and click on Import Variables
-Edit the variables to match your environment
-Run the dags from the UI and check the logs.
-This tutorial aimed at providing a hands on exercise on how to install an Airflow environment on a Linux server and how to use Airflow to interact with a Teradata Vantage database. An additional example is provided on how to integrate Airflow and the data modelling and maintenance tool dbt to create and load a Teradata Vantage database.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This tutorial shows an approach to creating a dbt pipeline that takes raw data and turns it into FEAST features. The pipeline leverages 'ClearScape Analytics functions' for data transformations. The output of the transformations is loaded into FEAST to materialize features that can be used in ML models.
-dbt (Data Build Tool) is a data transformation tool that is the cornerstone of the Modern Data Stack. It takes care of the T in ELT (Extract Load Transform). The assumption is that some other process brings raw data into your data warehouse or lake. This data then needs to be transformed.
-Feast (Feature Store) is a flexible data system that utilizes existing technology to manage and provide machine learning features to real-time models. It allows for customization to meet specific needs. It also allows us to make features consistently available for training and serving, avoid data leakage and decouple ML from data infrastructure.
-Access to a Teradata Vantage database instance. -NOTE: If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com.
-Feast-Teradata installed locally. See Feast-Teradata installation instructions
-dbt installed locally. See dbt installation instructions
-The goal is to create a data pipeline with Teradata Vantage as a source, and perform data transformation on some variables in dbt. The principle transformation of data we do in dbt is the one-hot encoding of several columns like gender, marital status, state code, etc. On top of that, the account type column data will be transformed by performing aggregation operations on a couple of columns. All of this together generates the desired dataset with transformed data. The transformed dataset is used as an input into FEAST to store features. Features are then used to generate a training dataset for models.
-Create a new python environment to manage dbt, feast, and their dependencies. Activate the environment:
-python3 -m venv env
-source env/bin/activateClone the tutorial repository and change the directory to the project directory:
-git clone https://github.com/Teradata/tdata-pipeline.gitThe directory structure of the project cloned looks like this:
-tdata-pipeline/ - feature_repo/ - feature_views.py - feature_store.yml - dbt_transformation/ - ... - macros - models - ... - generate_training_data.py - CreateDB.sql - dbt_project.yml-
teddy_bank is a fictitious dataset of banking customers, consisting of mainly 3 tables customers, accounts, and -transactions, with the following entity-relationship diagram:
-
-dbt takes this raw data and builds the following model, which is more suitable for ML modeling and analytics tools:
-
-Create file $HOME/.dbt/profiles.yml with the following content. Adjust <host>, <user>, <password> to match your Teradata instance.
| - - | -
- Database setup
-
-
-The following dbt profile points to a database called |
-
dbt_transformation:
- target: dev
- outputs:
- dev:
- type: teradata
- host: <host>
- user: <user>
- password: <password>
- schema: teddy_bank
- tmode: ANSIValidate the setup:
-dbt debugIf the debug command returned errors, you likely have an issue with the content of profiles.yml.
Feast configuration addresses connection to your Vantage database. The yaml file created while initializing the feast
-project, $HOME/.feast/feature_repo/feature_store.yml can hold the details of offline storage, online storage, provider
-and registry. Adjust <host>, <user>, <password> to match your Teradata instance.
| - - | -
- Database setup
-
-
-The following dbt profile points to a database called |
-
project: td_pipeline
-registry:
- registry_type: sql
- path: teradatasql://<user>:<password>@<hostIP>/?database=teddy_bank&LOGMECH=TDNEGO
-provider: local
-offline_store:
- type: feast_teradata.offline.teradata.TeradataOfflineStore
- host: <host>
- database: teddy_bank
- user: <user>
- password: <password>
- log_mech: TDNEGO
-entity_key_serialization_version: 2TeradataSource: Data Source for features stored in Teradata (Enterprise or Lake) or accessible via a Foreign Table from Teradata (NOS, QueryGrid)
Entity: A collection of semantically related features
Feature View: A feature view is a group of feature data from a specific data source. Feature views allow you to consistently define features and their data sources, enabling the reuse of feature groups across a project
DBT_source = TeradataSource( database=dbload, table=f"Analytic_Dataset", timestamp_field="event_timestamp")
-
-customer = Entity(name = "customer", join_keys = ['cust_id'])
-
-ads_fv = FeatureView(name="ads_fv",entities=[customer],source=DBT_source, schema=[
- Field(name="age", dtype=Float32),
- Field(name="income", dtype=Float32),
- Field(name="q1_trans_cnt", dtype=Int64),
- Field(name="q2_trans_cnt", dtype=Int64),
- Field(name="q3_trans_cnt", dtype=Int64),
- Field(name="q4_trans_cnt", dtype=Int64),
- ],)The approach to generating training data can vary. Depending upon the requirements, 'entitydf' may be joined with the source data tables using the feature views mapping. Here is a sample function that generates a training dataset.
-def get_Training_Data():
- # Initialize a FeatureStore with our current repository's configurations
- store = FeatureStore(repo_path="feature_repo")
- con = create_context(host = os.environ["latest_vm"], username = os.environ["dbc_pwd"],
- password = os.environ["dbc_pwd"], database = "EFS")
- entitydf = DataFrame('Analytic_Dataset').to_pandas()
- entitydf.reset_index(inplace=True)
- print(entitydf)
- entitydf = entitydf[['cust_id','event_timestamp']]
- training_data = store.get_historical_features(
- entity_df=entitydf,
- features=[
- "ads_fv:age"
- ,"ads_fv:income"
- ,"ads_fv:q1_trans_cnt"
- ,"ads_fv:q2_trans_cnt"
- ,"ads_fv:q3_trans_cnt"
- ,"ads_fv:q4_trans_cnt"
- ],
- full_feature_names=True
- ).to_df()
-
- return training_dataThis tutorial demonstrated how to use dbt and FEAST with Teradata Vantage. The sample project takes raw data from Teradata Vantage and produces features with dbt. Metadata of features that form the base to generate a training dataset for a model was then created with FEAST; all its corresponding tables that create the feature store, are also generated at runtime within the same database.
-Enabling highly scalable feature store with Teradata Vantage and FEAST
-Git repository for this project.
-Access to a Teradata Vantage instance, version 17.10 or higher.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
KNIME installed locally. See KNIME installation instructions for details.
-Go to https://downloads.teradata.com/download/connectivity/jdbc-driver (first time users will need to register) and download the latest version of the JDBC driver.
-Unzip the downloaded file. You will find terajdbc4.jar file.
In KNIME, click on File → Preference. Under Databases, click Add:
-Register a new database driver. Provide values for ID, Name and Description like below. Click on Add file and point to the .jar file you downloaded earlier. Click on the Find driver classes and the Driver class: should populate with the jdbc.TeraDriver:
-Click Apply and Close:
-To test the connection, create a new KNIME workflow and add a Database Reader (legacy) node by dragging it to the workspace to the right:
-
-Right-click on the Database Reader (legacy) to configure settings. Select com.teradata.jdbc.Teradriver from the drop-down:
-Enter the name of the Vantage server and login mechanism, e.g.:
-
-To test connection, enter SQL statement in box in lower right. For example, enter SELECT * FROM DBC.DBCInfoV and click Apply to close the dialog:
-Execute the node to test the connection:
-
-The node will show a green light when run successfully. Right-click and select Data from Database to view the results:
-
-This how-to demonstrats how to connect from KNIME Analytics Platform to Teradata Vantage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Time series is series of data points indexed in time order. It is data continuously produced and collected by a wide range of applications and devices including but not limited to Internet of Things. Teradata Vantage offers various functionalities to simplify time series data analysis.
-You need access to a Teradata Vantage instance. Times series functionalities and NOS are enabled in all Vantage editions from Vantage Express through Developer, DYI to Vantage as a Service starting from version 17.10.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Our sample data sets are available on S3 bucket and can be accessed from Vantage directly using Vantage NOS. Data is in CSV format and let’s ingest them into Vantage for our time series analysis.
-Let’s have a look at the data first. Below query will fetch 10 rows from S3 bucket.
-SELECT TOP 10 * FROM (
- LOCATION='/s3/nos-demo-apj.s3.amazonaws.com/taxi/2014/11/data_2014-11-25.csv'
-) AS d;Here is what we’ve got:
-Location vendor_id pickup_datetime dropoff_datetime passenger_count trip_distance pickup_longitude pickup_latitude rate_code store_and_fwd_flag dropoff_longitude dropoff_latitude payment_type fare_amount surcharge mta_tax tip_amount tolls_amount total_amount ------------------------------------------------------------------- --------- ----------------- ----------------- ---------------- -------------- ----------------- ---------------- ---------- ------------------- ------------------ ----------------- ------------- ------------ ---------- -------- ---------- ------------ ------------ -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:18 25/11/2013 15:33 1 1 -73.992423 40.749517 1 N -73.98816 40.746557 CRD 10 0 0.5 2.22 0 12.72 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 5:34 25/11/2013 5:48 1 3.6 -73.971555 40.794548 1 N -73.975399 40.755404 CRD 14.5 0.5 0.5 1 0 16.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 8:31 25/11/2013 8:55 1 5.9 -73.94764 40.830465 1 N -73.972323 40.76332 CRD 21 0 0.5 3 0 24.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 7:00 25/11/2013 7:04 1 1.2 -73.983357 40.767193 1 N -73.978394 40.75558 CRD 5.5 0 0.5 1 0 7 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:24 25/11/2013 15:30 1 0.5 -73.982313 40.764827 1 N -73.982129 40.758889 CRD 5.5 0 0.5 3 0 9 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 15:53 25/11/2013 16:00 1 0.6 -73.978104 40.752966 1 N -73.985756 40.762685 CRD 6 1 0.5 1 0 8.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 6:49 25/11/2013 7:04 1 3.8 -73.976005 40.744481 1 N -74.016063 40.717298 CRD 14 0 0.5 2.9 0 17.4 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 21:20 25/11/2013 21:26 1 1.1 -73.946371 40.775369 1 N -73.95309 40.785103 CRD 6.5 0.5 0.5 1.5 0 9 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 10:02 25/11/2013 10:17 1 2.2 -73.952625 40.780962 1 N -73.98163 40.777978 CRD 12 0 0.5 2 0 14.5 -/S3/s3.amazonaws.com/nyc-tlc/csv_backup/yellow_tripdata_2013-11.csv CMT 25/11/2013 9:43 25/11/2013 10:02 1 3.3 -73.982013 40.762507 1 N -74.006854 40.719582 CRD 15 0 0.5 2 0 17.5-
Let’s extract the complete data and bring it into Vantage for further analysis.
-CREATE TABLE trip
-(
- vendor_id varchar(10) character set latin NOT casespecific,
- rate_code integer,
- pickup_datetime timestamp(6),
- dropoff_datetime timestamp(6),
- passenger_count smallint,
- trip_distance float,
- pickup_longitude float,
- pickup_latitude float,
- dropoff_longitude float,
- dropoff_latitude float
-)
-NO PRIMARY INDEX ;
-
-
-
-INSERT INTO trip
-SELECT TOP 200000 vendor_id ,
- rate_code,
- pickup_datetime,
- dropoff_datetime ,
- passenger_count,
- trip_distance ,
- pickup_longitude,
- pickup_latitude ,
- dropoff_longitude ,
- dropoff_latitude FROM (
- LOCATION='/s3/nos-demo-apj.s3.amazonaws.com/taxi/2014/11/data_2014-11-25.csv'
-) AS d;Result:
-200000 rows affected.-
Vantage will now fetch the data from S3 and insert into trip table we just created.
-Now that we are familiar with the data set, we can use Vantage capabilities to quickly analyse the data set. First, let’s identify how many passengers are being picked up by hour in the month of November.
-SELECT TOP 10
- $TD_TIMECODE_RANGE
- ,begin($TD_TIMECODE_RANGE) time_bucket_start
- ,sum(passenger_count) passenger_count
-FROM trip
-WHERE extract(month from pickup_datetime)=11
-GROUP BY TIME(HOURS(1))
-USING TIMECODE(pickup_datetime)
-ORDER BY 1;For further reading on GROUP BY TIME.
-Result:
-TIMECODE_RANGE time_bucket_start passenger_count ---------------------------------------------------------- --------------------------------- ---------------- -(2013-11-04 11:00:00.000000, 2013-11-04 12:00:00.000000) 2013-11-04 11:00:00.000000-05:00 4 -(2013-11-04 12:00:00.000000, 2013-11-04 13:00:00.000000) 2013-11-04 12:00:00.000000-05:00 2 -(2013-11-04 14:00:00.000000, 2013-11-04 15:00:00.000000) 2013-11-04 14:00:00.000000-05:00 5 -(2013-11-04 15:00:00.000000, 2013-11-04 16:00:00.000000) 2013-11-04 15:00:00.000000-05:00 2 -(2013-11-04 16:00:00.000000, 2013-11-04 17:00:00.000000) 2013-11-04 16:00:00.000000-05:00 9 -(2013-11-04 17:00:00.000000, 2013-11-04 18:00:00.000000) 2013-11-04 17:00:00.000000-05:00 11 -(2013-11-04 18:00:00.000000, 2013-11-04 19:00:00.000000) 2013-11-04 18:00:00.000000-05:00 41 -(2013-11-04 19:00:00.000000, 2013-11-04 20:00:00.000000) 2013-11-04 19:00:00.000000-05:00 2791 -(2013-11-04 20:00:00.000000, 2013-11-04 21:00:00.000000) 2013-11-04 20:00:00.000000-05:00 15185 -(2013-11-04 21:00:00.000000, 2013-11-04 22:00:00.000000) 2013-11-04 21:00:00.000000-05:00 27500-
Yes, this can also be achieved by extracting the hour from time and then aggregating - it’s additional code/work, but can be done without timeseries specific functionality.
-But, now let’s go a step further to identify how many passengers are being picked up and what is the average trip duration by vendor every 15 minutes in November.
-SELECT TOP 10
- $TD_TIMECODE_RANGE,
- vendor_id,
- SUM(passenger_count),
- AVG((dropoff_datetime - pickup_datetime ) MINUTE (4)) AS avg_trip_time_in_mins
-FROM trip
-GROUP BY TIME (MINUTES(15) AND vendor_id)
-USING TIMECODE(pickup_datetime)
-WHERE EXTRACT(MONTH FROM pickup_datetime)=11
-ORDER BY 1,2;Result:
-TIMECODE_RANGE vendor_id passenger_count avg_trip_time_in_mins --------------------------------------------------------- ---------- ---------------- ---------------------- -(2013-11-04 11:00:00.000000, 2013-11-04 11:15:00.000000) VTS 1 16 -(2013-11-04 11:15:00.000000, 2013-11-04 11:30:00.000000) VTS 1 10 -(2013-11-04 11:45:00.000000, 2013-11-04 12:00:00.000000) VTS 2 6 -(2013-11-04 12:00:00.000000, 2013-11-04 12:15:00.000000) VTS 1 11 -(2013-11-04 12:15:00.000000, 2013-11-04 12:30:00.000000) VTS 1 57 -(2013-11-04 14:15:00.000000, 2013-11-04 14:30:00.000000) VTS 1 3 -(2013-11-04 14:30:00.000000, 2013-11-04 14:45:00.000000) VTS 2 19 -(2013-11-04 14:45:00.000000, 2013-11-04 15:00:00.000000) VTS 2 9 -(2013-11-04 15:15:00.000000, 2013-11-04 15:30:00.000000) VTS 1 11 -(2013-11-04 15:30:00.000000, 2013-11-04 15:45:00.000000) VTS 1 31-
This is the power of Vantage time series functionality. Without needing complicated, cumbersome logic we are able to find average trip duration by vendor every 15 minutes just by modifying the group by time clause. Let’s now look at how simple it is to build moving averages based on this. First, let’s start by creating a view as below.
-REPLACE VIEW NYC_taxi_trip_ts as
-SELECT
- $TD_TIMECODE_RANGE time_bucket_per
- ,vendor_id
- ,sum(passenger_count) passenger_cnt
- ,avg(CAST((dropoff_datetime - pickup_datetime MINUTE(4) ) AS INTEGER)) avg_trip_time_in_mins
-FROM trip
-GROUP BY TIME (MINUTES(15) and vendor_id)
-USING TIMECODE(pickup_datetime)
-WHERE extract(month from pickup_datetime)=11Let’s calculate a 2 hours moving average on our 15-minutes time series. 2 hour is 8 * 15 minutes periods.
-SELECT * FROM MovingAverage (
- ON NYC_taxi_trip_ts PARTITION BY vendor_id ORDER BY time_bucket_per
- USING
- MAvgType ('S')
- WindowSize (8)
- TargetColumns ('passenger_cnt')
-) AS dt
-WHERE begin(time_bucket_per)(date) = '2014-11-25'
-ORDER BY vendor_id, time_bucket_per;Result:
-time_bucket_per vendor_id passenger_cnt avg_trip_time_in_mins passenger_cnt_smavg ---------------------------------------------------------- -------------- ---------------------- -------------------- -------------------- -(2013-11-04 14:45:00.000000, 2013-11-04 15:00:00.000000) VTS 2 9 1.375 -(2013-11-04 15:15:00.000000, 2013-11-04 15:30:00.000000) VTS 1 11 1.375 -(2013-11-04 15:30:00.000000, 2013-11-04 15:45:00.000000) VTS 1 31 1.375 -(2013-11-04 16:15:00.000000, 2013-11-04 16:30:00.000000) VTS 2 16 1.375 -(2013-11-04 16:30:00.000000, 2013-11-04 16:45:00.000000) VTS 1 3 1.375 -(2013-11-04 16:45:00.000000, 2013-11-04 17:00:00.000000) VTS 6 38 2 -(2013-11-04 17:15:00.000000, 2013-11-04 17:30:00.000000) VTS 2 29.5 2.125 -(2013-11-04 17:45:00.000000, 2013-11-04 18:00:00.000000) VTS 9 20.33333333 3 -(2013-11-04 18:00:00.000000, 2013-11-04 18:15:00.000000) VTS 6 23.4 3.5 -(2013-11-04 18:15:00.000000, 2013-11-04 18:30:00.000000) VTS 4 15.66666667 3.875 -(2013-11-04 18:30:00.000000, 2013-11-04 18:45:00.000000) VTS 8 24.5 4.75 -(2013-11-04 18:45:00.000000, 2013-11-04 19:00:00.000000) VTS 23 38.33333333 7.375 -(2013-11-04 19:00:00.000000, 2013-11-04 19:15:00.000000) VTS 195 26.61538462 31.625 -(2013-11-04 19:15:00.000000, 2013-11-04 19:30:00.000000) VTS 774 13.70083102 127.625 -(2013-11-04 19:30:00.000000, 2013-11-04 19:45:00.000000) VTS 586 12.38095238 200.625 -(2013-11-04 19:45:00.000000, 2013-11-04 20:00:00.000000) VTS 1236 15.54742097 354 -(2013-11-04 20:00:00.000000, 2013-11-04 20:15:00.000000) VTS 3339 11.78947368 770.625 -(2013-11-04 20:15:00.000000, 2013-11-04 20:30:00.000000) VTS 3474 10.5603396 1204.375 -(2013-11-04 20:30:00.000000, 2013-11-04 20:45:00.000000) VTS 3260 12.26484323 1610.875 -(2013-11-04 20:45:00.000000, 2013-11-04 21:00:00.000000) VTS 5112 12.05590062 2247-
| - - | --In addition to above time series operations, Vantage also provides a special time series tables with Primary Time Index (PTI). These are regular Vantage tables with PTI defined rather than a Primary Index (PI). Though tables with PTI are not mandatory for time series functionality/operations, PTI optimizes how the time series data is stored physically and hence improves performance considerably compared to regular tables. - | -
In this quick start we have learnt how easy it is to analyse time series datasets using Vantage’s time series capabilities.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
Teradata Query Service is a REST API for Vantage that you can use to run standard SQL statements without managing client-side drivers. Use Query Service if you are looking to query and access the Analytics Database through a REST API.
-This how-to provides examples of common use cases to help you get started with Query Service API.
-Before starting, make sure you have:
-Access to a VantageCloud system where Query Service is provisioned, or a VantageCore with Query Service enabled connectivity. If you are an admin and need to install Query Service, see Query Service Installation, Configuration, and Usage Guide.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Query Service hostname and system name
-Authorization credentials to connect to the database
-Having trouble with the prerequisites? Contact Teradata for setup information.
-When using the examples, please keep in mind that:
-The examples in this document use Python, and you can use these to create examples in your language of choice.
-The examples provided here are complete and ready for you to use, although most require a little customization.
-The examples in this document use the URL https://<QS_HOSTNAME>:1443/.
Replace the following variables with your own value:
-<QS_HOSTNAME>: Server where Query Service is installed
<SYSTEM_NAME>: Preconfigured alias of the system
| - - | -
-
-
-If your Vantage instance is provided through ClearScape Analytics Experience,<QS_HOSTNAME>, is the host URL of your ClearScape Analytics Experience environment, <SYSTEM_NAME> is 'local'. - |
-
Provide valid credentials to access the target Analytics Database using HTTP Basic or JWT authentication.
-The database username and password are combined into a string ("username : password") which is then encoded using Base64. The API response contains the authorization method and encoded credentials.
Request
-import requests
-import json
-import base64
-requests.packages.urllib3.disable_warnings()
-
-# run it from local.
-
-db_user, db_password = 'dbc','dbc'
-auth_encoded = db_user + ':' + db_password
-auth_encoded = base64.b64encode(bytes(auth_encoded, 'utf-8'))
-auth_str = 'Basic ' + auth_encoded.decode('utf-8')
-
-print(auth_str)
-
-headers = {
- 'Content-Type': 'application/json',
- 'Authorization': auth_str # base 64 encoded username:password
-}
-
-print(headers)Response
-Basic ZGJjOmRiYw==
-{
- 'Content-Type': 'application/json',
- 'Authorization': 'Basic ZGJjOmRiYw=='
-}
-Prerequisites:
-The user must already exist in the database.
-The database must be JWT enabled.
-Request
-import requests
-import json
-requests.packages.urllib3.disable_warnings()
-
-# run it from local.
-
-auth_encoded_jwt = "<YOUR_JWT_HERE>"
-auth_str = "Bearer " + auth_encoded_jwt
-
-headers = {
- 'Content-Type': 'application/json',
- 'Authorization': auth_str
-}
-
-print(headers)Response
-{'Content-Type': 'application/json', 'Authorization': 'Bearer <YOUR_JWT_HERE>'}
-In the following example, the request includes:
-SELECT * FROM DBC.DBCInfo: The query to the system with the alias <SYSTEM_NAME>.
'format': 'OBJECT': The format for response. The formats supported are: JSON object, JSON array, and CSV.
| - - | --The JSON object format creates one JSON object per row where the column name is the field name, and the column value is the field value. - | -
'includeColumns': true: The request to include column metadata, such as column names and types, in the response.
'rowLimit': 4: The number of rows to be returned from a query.
Request
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': example_query, # 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'includeColumns': True,
- 'rowLimit': 4
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-num_rows = response.json().get('results')[0].get('rowCount')
-print('NUMBER of ROWS', num_rows)
-print('==========================================================')
-
-print(response.json())Response
-NUMBER of ROWS 4
-==========================================================
-{
- "queueDuration":7,
- "queryDuration":227,
- "results":[
- {
- "resultSet":True,
- "columns":[
- {
- "name":"DatabaseName",
- "type":"CHAR"
- },
- {
- "name":"USEDSPACE_IN_GB",
- "type":"FLOAT"
- },
- {
- "name":"MAXSPACE_IN_GB",
- "type":"FLOAT"
- },
- {
- "name":"Percentage_Used",
- "type":"FLOAT"
- },
- {
- "name":"REMAININGSPACE_IN_GB",
- "type":"FLOAT"
- }
- ],
- "data":[
- {
- "DatabaseName":"DBC",
- "USEDSPACE_IN_GB":317.76382541656494,
- "MAXSPACE_IN_GB":1510.521079641879,
- "Percentage_Used":21.03670247964377,
- "REMAININGSPACE_IN_GB":1192.757254225314
- },
- {
- "DatabaseName":"EM",
- "USEDSPACE_IN_GB":0.0007491111755371094,
- "MAXSPACE_IN_GB":11.546071618795395,
- "Percentage_Used":0.006488017745513208,
- "REMAININGSPACE_IN_GB":11.545322507619858
- },
- {
- "DatabaseName":"user10",
- "USEDSPACE_IN_GB":0.019153594970703125,
- "MAXSPACE_IN_GB":9.313225746154785,
- "Percentage_Used":0.20566016,
- "REMAININGSPACE_IN_GB":9.294072151184082
- },
- {
- "DatabaseName":"EMEM",
- "USEDSPACE_IN_GB":0.006140708923339844,
- "MAXSPACE_IN_GB":4.656612873077393,
- "Percentage_Used":0.13187072,
- "REMAININGSPACE_IN_GB":4.650472164154053
- },
- {
- "DatabaseName":"EMWork",
- "USEDSPACE_IN_GB":0.0,
- "MAXSPACE_IN_GB":4.656612873077393,
- "Percentage_Used":0.0,
- "REMAININGSPACE_IN_GB":4.656612873077393
- }
- ],
- "rowCount":4,
- "rowLimitExceeded":True
- }
- ]
-}
-For response parameters, see Query Service Installation, Configuration, and Usage Guide.
-To return an API response in CSV format, set the format field in the request with the value CSV.
The CSV format contains only the query results and not response metadata. The response contains a line for each row, where each line contains the row columns separated by a comma. The following example returns the data as comma-separated values.
-Request
-# CSV with all rows included
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': example_query, # 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'CSV',
- 'includeColumns': True
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)Response
-DatabaseName,USEDSPACE_IN_GB,MAXSPACE_IN_GB,Percentage_Used,REMAININGSPACE_IN_GB -DBC ,317.7634754180908,1510.521079641879,21.036679308932754,1192.7576042237881 -EM ,7.491111755371094E-4,11.546071618795395,0.006488017745513208,11.545322507619858 -user10 ,0.019153594970703125,9.313225746154785,0.20566016,9.294072151184082 -EMEM ,0.006140708923339844,4.656612873077393,0.13187072,4.650472164154053 -EMWork ,0.0,4.656612873077393,0.0,4.656612873077393 -EMJI ,0.0,2.3283064365386963,0.0,2.3283064365386963 -USER_NAME ,0.0,2.0,0.0,2.0 -readonly ,0.0,0.9313225746154785,0.0,0.9313225746154785 -aug12_db ,7.200241088867188E-5,0.9313225746154785,0.0077312,0.9312505722045898 -SystemFe ,1.8024444580078125E-4,0.7450580596923828,0.024192,0.744877815246582 -dbcmngr ,3.814697265625E-6,0.09313225746154785,0.004096,0.09312844276428223 -EMViews ,0.027594566345214844,0.09313225746154785,29.62944,0.06553769111633301 -tdwm ,6.732940673828125E-4,0.09313225746154785,0.722944,0.09245896339416504 -Crashdumps ,0.0,0.06984921544790268,0.0,0.06984921544790268 -SYSLIB ,0.006252288818359375,0.03725290298461914,16.78336,0.031000614166259766 -SYSBAR ,4.76837158203125E-6,0.03725290298461914,0.0128,0.03724813461303711 -SYSUDTLIB ,3.5381317138671875E-4,0.029802322387695312,1.1872,0.029448509216308594 -External_AP ,0.0,0.01862645149230957,0.0,0.01862645149230957 -SysAdmin ,0.002307891845703125,0.01862645149230957,12.3904,0.016318559646606445 -KZXaDtQp ,0.0,0.009313225746154785,0.0,0.009313225746154785 -s476QJ6O ,0.0,0.009313225746154785,0.0,0.009313225746154785 -hTzz03i7 ,0.0,0.009313225746154785,0.0,0.009313225746154785 -Y5WYUUXj ,0.0,0.009313225746154785,0.0,0.009313225746154785-
Use explicit sessions when a transaction needs to span multiple requests or when using volatile tables. These sessions are only reused if you reference the sessions in a query request. The request is queued if a request references an explicit session already in use.
-Create a session
-Send a POST request to the /system/<SYSTEM_NAME>/sessions endpoint. The request creates a new database session and returns the session details as the response.
In the following example, the request includes 'auto_commit': True - the request to commit the query upon completion.
Request
-# first create a session
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/sessions'
-
-payload = {
- 'auto_commit': True
-}
-
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)Response
-{
- 'sessionId': 1366010,
- 'system': 'testsystem',
- 'user': 'dbc',
- 'tdSessionNo': 1626922,
- 'createMode': 'EXPLICIT',
- 'state': 'LOGGINGON',
- 'autoCommit': true
-}
-Use the session created in Step 1 to submit queries
-Send a POST request to the /system/<SYSTEM_NAME>/queries endpoint.
The request submits queries to the target system and returns the release and version number of the target system.
-In the following example, the request includes:
-SELECT * FROM DBC.DBCInfo: The query to the system with the alias <SYSTEM_NAME>.
'format': 'OBJECT': The format for response.
'Session' : <Session ID>: The session ID returned in Step 1 to create an explicit session.
Request
-# use this session to submit queries afterwards
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'session': 1366010 # <-- sessionId
-}
-payload_json = json.dumps(payload)
-
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)Response
-{
- "queueDuration":6,
- "queryDuration":41,
- "results":[
- {
- "resultSet":true,
- "data":[
- {
- "InfoKey":"LANGUAGE SUPPORT MODE",
- "InfoData":"Standard"
- },
- {
- "InfoKey":"RELEASE",
- "InfoData":"15.10.07.02"
- },
- {
- "InfoKey":"VERSION",
- "InfoData":"15.10.07.02"
- }
- ],
- "rowCount":3,
- "rowLimitExceeded":false
- }
- ]
-}
-Use asynchronous queries when a system or network performance is affected by querying a large group of data or long running queries.
-Submit asynchronous queries to the target system and retrieve a Query ID
-Send a POST request to the /system/<SYSTEM_NAME>/queries endpoint.
In the following example, the request includes:
-SELECT * FROM DBC.DBCInfo: The query to the system with the alias <SYSTEM_NAME>.
'format': 'OBJECT': The format for response.
'spooled_result_set': True: The indication that the request is asynchronous.
Request
-## Run async query .
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload = {
- 'query': 'SELECT * FROM DBC.DBCInfo;',
- 'format': 'OBJECT',
- 'spooled_result_set': True
-}
-
-payload_json = json.dumps(payload)
-response = requests.request('POST', url, headers=headers, data=payload_json, verify=False)
-
-print(response.text)Response
-{"id":1366025}
-Get query details using the ID retrieved from Step 1
-Send a GET request to the /system/<SYSTEM_NAME>/queries/<queryID> endpoint, replacing <queryID> with the ID retrieved from Step 1.
The request returns the details of the specific query, including queryState, queueOrder, queueDuration, and so on. For a complete list of the response fields and their descriptions, see Query Service Installation, Configuration, and Usage Guide.
Request
-## response for async query .
-
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries/1366025'
-
-payload_json = json.dumps(payload)
-response = requests.request('GET', url, headers=headers, verify=False)
-
-print(response.text)Response
-{
- "queryId":1366025,
- "query":"SELECT * FROM DBC.DBCInfo;",
- "batch":false,
- "system":"testsystem",
- "user":"dbc",
- "session":1366015,
- "queryState":"RESULT_SET_READY",
- "queueOrder":0,
- "queueDuration":6,
- "queryDuration":9,
- "statusCode":200,
- "resultSets":{
-
- },
- "counts":{
-
- },
- "exceptions":{
-
- },
- "outParams":{
-
- }
-}
-View resultset for asynchronous query
-Send a GET request to the /system/<SYSTEM_NAME>/queries/<queryID>/results endpoint, replacing <queryID> with the ID retrieved from Step 1.
-The request returns an array of the result sets and update counts produced by the submitted query.
Request
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries/1366025/results'
-
-payload_json = json.dumps(payload)
-response = requests.request('GET', url, headers=headers, verify=False)
-
-print(response.text)Response
-{
- "queueDuration":6,
- "queryDuration":9,
- "results":[
- {
- "resultSet":true,
- "data":[
- {
- "InfoKey":"LANGUAGE SUPPORT MODE",
- "InfoData":"Standard"
- },
- {
- "InfoKey":"RELEASE",
- "InfoData":"15.10.07.02"
- },
- {
- "InfoKey":"VERSION",
- "InfoData":"15.10.07.02"
- }
- ],
- "rowCount":3,
- "rowLimitExceeded":false
- }
- ]
-}
-Send a GET request to the /system/<SYSTEM_NAME>/queries endpoint. The request returns the IDs of active queries.
Request
-url = 'https://<QS_HOSTNAME>:1443/systems/<SYSTEM_NAME>/queries'
-
-payload={}
-
-response = requests.request('GET', url, headers=headers, data=payload, verify=False)
-
-print(response.json())Response
-[
- {
- "queryId": 12516087,
- "query": "SELECt * from dbcmgr.AlertRequest;",
- "batch": false,
- "system": "BasicTestSys",
- "user": "dbc",
- "session": 12516011,
- "queryState": "REST_SET_READY",
- "queueOrder": 0,
- "queueDurayion": 3,
- "queryDuration": 3,
- "statusCode": 200,
- "resultSets": {},
- "counts": {},
- "exceptions": {},
- "outparams": {}
- },
- {
- "queryId": 12516088,
- "query": "SELECt * from dbc.DBQLAmpDataTbl;",
- "batch": false,
- "system": "BasicTestSys",
- "user": "dbc",
- "session": 12516011,
- "queryState": "REST_SET_READY",
- "queueOrder": 0,
- "queueDurayion": 3,
- "queryDuration": 3,
- "statusCode": 200,
- "resultSets": {},
- "counts": {},
- "exceptions": {},
- "outparams": {}
- }
-]
-Features, examples, and references: Query Service Installation, Configuration, and Usage Guide
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to demonstrates how to run Vantage Express on AWS. Vantage Express is a small footprint configuration that contains a fully functional Teradata SQL Engine.
-| - - | -
- Cloud charges
-
-
-Vantage Express is distributed as a virtual machine image. This how-to uses the EC2
-
-If you want a cheaper option, try Google Cloud and Azure which support nested virtualization and can run Vantage Express on cheap VM’s. -
-
-If you do not wish to pay for cloud usage, you can get a free hosted instance of Vantage at https://clearscape.teradata.com/. Alternatively, you install Vantage Express locally using VMware, VirtualBox, or UTM. - |
-
An AWS account. If you need to create a new account follow the official AWS instructions.
-awscli command line utility installed and configured on your machine. You can find installation instructions here: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html.
You will need a VPC with an Internet-facing subnet. If you don’t have one available, here is how you can create it:
-# Copied from https://cloudaffaire.com/how-to-create-a-custom-vpc-using-aws-cli/
-
-# Create VPC
-AWS_VPC_ID=$(aws ec2 create-vpc \
- --cidr-block 10.0.0.0/16 \
- --query 'Vpc.{VpcId:VpcId}' \
- --output text)
-
-# Enable DNS hostname for your VPC
-aws ec2 modify-vpc-attribute \
- --vpc-id $AWS_VPC_ID \
- --enable-dns-hostnames "{\"Value\":true}"
-
-# Create a public subnet
-AWS_SUBNET_PUBLIC_ID=$(aws ec2 create-subnet \
- --vpc-id $AWS_VPC_ID --cidr-block 10.0.1.0/24 \
- --query 'Subnet.{SubnetId:SubnetId}' \
- --output text)
-
-# Enable Auto-assign Public IP on Public Subnet
-aws ec2 modify-subnet-attribute \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --map-public-ip-on-launch
-
-# Create an Internet Gateway
-AWS_INTERNET_GATEWAY_ID=$(aws ec2 create-internet-gateway \
- --query 'InternetGateway.{InternetGatewayId:InternetGatewayId}' \
- --output text)
-
-# Attach Internet gateway to your VPC
-aws ec2 attach-internet-gateway \
- --vpc-id $AWS_VPC_ID \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID
-
-# Create a route table
-AWS_CUSTOM_ROUTE_TABLE_ID=$(aws ec2 create-route-table \
- --vpc-id $AWS_VPC_ID \
- --query 'RouteTable.{RouteTableId:RouteTableId}' \
- --output text )
-
-# Create route to Internet Gateway
-aws ec2 create-route \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID \
- --destination-cidr-block 0.0.0.0/0 \
- --gateway-id $AWS_INTERNET_GATEWAY_ID \
- --output text
-
-# Associate the public subnet with route table
-AWS_ROUTE_TABLE_ASSOID=$(aws ec2 associate-route-table \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID \
- --output text | head -1)
-
-# Create a security group
-aws ec2 create-security-group \
- --vpc-id $AWS_VPC_ID \
- --group-name myvpc-security-group \
- --description 'My VPC non default security group' \
- --output text
-
-# Get security group ID's
-AWS_DEFAULT_SECURITY_GROUP_ID=$(aws ec2 describe-security-groups \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'SecurityGroups[?GroupName == `default`].GroupId' \
- --output text) &&
- AWS_CUSTOM_SECURITY_GROUP_ID=$(aws ec2 describe-security-groups \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'SecurityGroups[?GroupName == `myvpc-security-group`].GroupId' \
- --output text)
-
-# Create security group ingress rules
-aws ec2 authorize-security-group-ingress \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID \
- --ip-permissions '[{"IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "Allow SSH"}]}]' \
- --output text
-
-# Add a tag to the VPC
-aws ec2 create-tags \
- --resources $AWS_VPC_ID \
- --tags "Key=Name,Value=vantage-express-vpc"
-
-# Add a tag to public subnet
-aws ec2 create-tags \
- --resources $AWS_SUBNET_PUBLIC_ID \
- --tags "Key=Name,Value=vantage-express-vpc-public-subnet"
-
-# Add a tag to the Internet-Gateway
-aws ec2 create-tags \
- --resources $AWS_INTERNET_GATEWAY_ID \
- --tags "Key=Name,Value=vantage-express-vpc-internet-gateway"
-
-# Add a tag to the default route table
-AWS_DEFAULT_ROUTE_TABLE_ID=$(aws ec2 describe-route-tables \
- --filters "Name=vpc-id,Values=$AWS_VPC_ID" \
- --query 'RouteTables[?Associations[0].Main != `false`].RouteTableId' \
- --output text) &&
- aws ec2 create-tags \
- --resources $AWS_DEFAULT_ROUTE_TABLE_ID \
- --tags "Key=Name,Value=vantage-express-vpc-default-route-table"
-
-# Add a tag to the public route table
-aws ec2 create-tags \
- --resources $AWS_CUSTOM_ROUTE_TABLE_ID \
- --tags "Key=Name,Value=vantage-express-vpc-public-route-table"
-
-# Add a tags to security groups
-aws ec2 create-tags \
- --resources $AWS_CUSTOM_SECURITY_GROUP_ID \
- --tags "Key=Name,Value=vantage-express-vpc-security-group" &&
- aws ec2 create-tags \
- --resources $AWS_DEFAULT_SECURITY_GROUP_ID \
- --tags "Key=Name,Value=vantage-express-vpc-default-security-group"To create a VM you will need an ssh key pair. If you don’t have it already, create one:
-aws ec2 create-key-pair --key-name vantage-key --query 'KeyMaterial' --output text > vantage-key.pemRestrict access to the private key. Replace <path_to_private_key_file> with the private key path returned by the previous command:
chmod 600 vantage-key.pemGet the AMI id of the latest Ubuntu image in your region:
-AWS_AMI_ID=$(aws ec2 describe-images \
- --filters 'Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-*amd64*' \
- --query 'Images[*].[Name,ImageId,CreationDate]' --output text \
- | sort -k3 -r | head -n1 | cut -f 2)Create a Ubuntu VM with 4 CPU’s and 8GB of RAM, and a 70GB disk.
-AWS_INSTANCE_ID=$(aws ec2 run-instances \
- --image-id $AWS_AMI_ID \
- --count 1 \
- --instance-type c5n.metal \
- --block-device-mapping DeviceName=/dev/sda1,Ebs={VolumeSize=70} \
- --key-name vantage-key \
- --security-group-ids $AWS_CUSTOM_SECURITY_GROUP_ID \
- --subnet-id $AWS_SUBNET_PUBLIC_ID \
- --query 'Instances[0].InstanceId' \
- --output text)ssh to your VM:
-AWS_INSTANCE_PUBLIC_IP=$(aws ec2 describe-instances \
- --query "Reservations[*].Instances[*].PublicIpAddress" \
- --output=text --instance-ids $AWS_INSTANCE_ID)
-ssh -i vantage-key.pem ubuntu@$AWS_INSTANCE_PUBLIC_IPOnce in the VM, switch to root user:
sudo -iPrepare the download directory for Vantage Express:
-mkdir /opt/downloads
-cd /opt/downloadsInstall VirtualBox and 7zip:
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -yRetrieve the curl command to download Vantage Express.
-Go to Vantage Expess download page (registration required).
-Click on the latest download link, e.g. "Vantage Express 17.20". You will see a license agreement popup. Don’t accept the license yet.
-Open the network view in your browser. For example, in Chrome press F12 and navigate to Network tab:
-Accept the license by clicking on I Agree button and cancel the download.
In the network view, find the last request that starts with VantageExpress. Right click on it and select Copy → Copy as cURL:
-Head back to the ssh session and download Vantage Express by pasting the curl command. Add -o ve.7z to the command to save the download to file named ve.7z. You can remove all the HTTP headers, e.g.:
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'Unzip the downloaded file. It will take several minutes:
-7z x ve.7zStart the VM in VirtualBox. The command will return immediately but the VM init process will take several minutes:
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cssh to Vantage Express VM. Use root as password:
ssh -p 4422 root@localhostValidate that the DB is up:
-pdestate -aIf the command returns PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent, it means that Vantage Express has started.
-If the status is different, repeat pdestate -a till you get the correct status.
Once Vantage Express is up and running, start bteq client command line client. BTEQ (pronounced “bee-teek”) is a general-purpose, command-based client tool used to submit SQL queries to a Teradata Database.
bteqOnce in bteq, connect to your Vantage Express instance. When asked for the password, enter dbc:
.logon localhost/dbcUsing dbc user, we will create a new database called HR. Copy/paste this query and run press Enter:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
If you intend to stop and start the VM, you may want to add Vantage Express to autostart. ssh to your VM and run the following commands:
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressIf you would like to connect to Vantage Express from the Internet, you will need to open up firewall holes to your VM. You should also change the default password to dbc user:
To change the password for dbc user go to your VM and start bteq:
bteqLogin to your database using dbc as username and password:
.logon localhost/dbcChange the password for dbc user:
MODIFY USER dbc AS PASSWORD = new_password;You can now open up port 1025 to the internet:
-aws ec2 authorize-security-group-ingress \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID \
- --ip-permissions '[{"IpProtocol": "tcp", "FromPort": 1025, "ToPort": 1025, "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "Allow Teradata port"}]}]'To stop incurring charges, delete all the resources:
-# Delete the VM
-aws ec2 terminate-instances --instance-ids $AWS_INSTANCE_ID --output text
-
-# Wait for the VM to terminate
-
-# Delete custom security group
-aws ec2 delete-security-group \
- --group-id $AWS_CUSTOM_SECURITY_GROUP_ID
-
-# Delete internet gateway
-aws ec2 detach-internet-gateway \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID \
- --vpc-id $AWS_VPC_ID &&
- aws ec2 delete-internet-gateway \
- --internet-gateway-id $AWS_INTERNET_GATEWAY_ID
-
-# Delete the custom route table
-aws ec2 disassociate-route-table \
- --association-id $AWS_ROUTE_TABLE_ASSOID &&
- aws ec2 delete-route-table \
- --route-table-id $AWS_CUSTOM_ROUTE_TABLE_ID
-
-# Delete the public subnet
-aws ec2 delete-subnet \
- --subnet-id $AWS_SUBNET_PUBLIC_ID
-
-# Delete the vpc
-aws ec2 delete-vpc \
- --vpc-id $AWS_VPC_ID| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to demonstrates how to run Vantage Express in Microsoft Azure. Vantage Express contains a fully functional Teradata SQL Engine.
-An Azure account. You can create one here: https://azure.microsoft.com/en-us/free/
-az command line utility installed on your machine. You can find installation instructions here: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli.
Setup the default region to the closest region to you (to list locations run az account list-locations -o table):
az config set defaults.location=<location>Create a new resource group called tdve-resource-group and add it to defaults:
az group create -n tdve-resource-group
-az config set defaults.group=tdve-resource-groupTo create a VM you will need an ssh key pair. If you don’t have it already, create one:
-az sshkey create --name vantage-ssh-keyRestrict access to the private key. Replace <path_to_private_key_file> with the private key path returned by the previous command:
chmod 600 <path_to_private_key_file>Create a Ubuntu VM with 4 CPU’s and 8GB of RAM, a 30GB os disk and a 60GB data disk.
-az disk create -n teradata-vantage-express --size-gb 60
-az vm create `
- --name teradata-vantage-express `
- --image UbuntuLTS `
- --admin-username azureuser `
- --ssh-key-name vantage-ssh-key `
- --size Standard_F4s_v2 `
- --public-ip-sku Standard
-
-$diskId = (az disk show -n teradata-vantage-express --query 'id' -o tsv) | Out-String
-az vm disk attach --vm-name teradata-vantage-express --name $diskIdaz disk create -n teradata-vantage-express --size-gb 60
-az vm create \
- --name teradata-vantage-express \
- --image UbuntuLTS \
- --admin-username azureuser \
- --ssh-key-name vantage-ssh-key \
- --size Standard_F4s_v2 \
- --public-ip-sku Standard
-
-DISK_ID=$(az disk show -n teradata-vantage-express --query 'id' -o tsv)
-az vm disk attach --vm-name teradata-vantage-express --name $DISK_IDaz disk create -n teradata-vantage-express --size-gb 60
-az vm create \
- --name teradata-vantage-express \
- --image UbuntuLTS \
- --admin-username azureuser \
- --ssh-key-name vantage-ssh-key \
- --size Standard_F4s_v2 \
- --public-ip-sku Standard
-
-DISK_ID=$(az disk show -n teradata-vantage-express --query 'id' -o tsv)
-az vm disk attach --vm-name teradata-vantage-express --name $DISK_IDssh to your VM. Replace <path_to_private_key_file> and <vm_ip> with values that match your environment:
ssh -i <path_to_private_key_file> azureuser@<vm_ip>Once in the VM, switch to root user:
sudo -iPrepare the download directory for Vantage Express:
-mkdir /opt/downloads
-cd /opt/downloadsMount the data disk:
-parted /dev/sdc --script mklabel gpt mkpart xfspart xfs 0% 100%
-mkfs.xfs /dev/sdc1
-partprobe /dev/sdc1
-export DISK_UUID=$(blkid | grep sdc1 | cut -d"\"" -f2)
-echo "UUID=$DISK_UUID /opt/downloads xfs defaults,nofail 1 2" >> /etc/fstabInstall VirtualBox and 7zip:
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -yRetrieve the curl command to download Vantage Express.
-Go to Vantage Expess download page (registration required).
-Click on the latest download link, e.g. "Vantage Express 17.20". You will see a license agreement popup. Don’t accept the license yet.
-Open the network view in your browser. For example, in Chrome press F12 and navigate to Network tab:
-Accept the license by clicking on I Agree button and cancel the download.
In the network view, find the last request that starts with VantageExpress. Right click on it and select Copy → Copy as cURL:
-Head back to the ssh session and download Vantage Express by pasting the curl command. Add -o ve.7z to the command to save the download to file named ve.7z. You can remove all the HTTP headers, e.g.:
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'Unzip the downloaded file. It will take several minutes:
-7z x ve.7zStart the VM in VirtualBox. The command will return immediately but the VM init process will take several minutes:
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cssh to Vantage Express VM. Use root as password:
ssh -p 4422 root@localhostValidate that the DB is up:
-pdestate -aIf the command returns PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent, it means that Vantage Express has started.
-If the status is different, repeat pdestate -a till you get the correct status.
Once Vantage Express is up and running, start bteq client command line client. BTEQ (pronounced “bee-teek”) is a general-purpose, command-based client tool used to submit SQL queries to a Teradata Database.
bteqOnce in bteq, connect to your Vantage Express instance. When asked for the password, enter dbc:
.logon localhost/dbcUsing dbc user, we will create a new database called HR. Copy/paste this query and run press Enter:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
If you intend to stop and start the VM, you may want to add Vantage Express to autostart. ssh to your VM and run the following commands:
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressIf you would like to connect to Vantage Express from the Internet, you will need to open up firewall holes to your VM. You should also change the default password to dbc user:
To change the password for dbc user go to your VM and start bteq:
bteqLogin to your database using dbc as username and password:
.logon localhost/dbcChange the password for dbc user:
MODIFY USER dbc AS PASSWORD = new_password;You can now open up port 1025 to the internet using gcloud command:
-az vm open-port --name teradata-vantage-express --port 1025To stop incurring charges, delete all the resources associated with the resource group:
-az group delete --no-wait -n tdve-resource-group| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This solution listens to events from Twilio Segment and writes data to a Teradata Vantage instance. The example uses Google Cloud but it can be translated into any cloud platform.
-In this solution, Twilio Segment writes raw event data to Google Cloud Pub/Sub. Pub/Sub forwards events to a Cloud Run application. The Cloud Run app writes data to a Teradata Vantage database. It’s a serverless solution that doesn’t require allocation or management of any VM’s.
-
-A Google Cloud account. If you don’t have an account, you can create one at https://console.cloud.google.com/.
-gcloud installed. See https://cloud.google.com/sdk/docs/install.
A Teradata Vantage instance that Google Cloud Run can talk to.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Clone the sample repository:
-git clone git@github.com:Teradata/segment-integration-tutorial.gitThe repo contains segment.sql file that sets up the database. the script on your Vantage db using your favorite SQL IDE, [Teradata Studio](https://downloads.teradata.com/download/tools/teradata-studio) or command line tool called bteq (download for Windows, Linux, macOS).
-The SQL script will create a new database called Segment and a set of tables to store Segment events.
Set the default project and region:
-gcloud config set project <PROJECT_ID>
-gcloud config set compute/region <REGION>Retrieve the project id and the number. We will need it in subsequent steps:
-export PROJECT_ID=$(gcloud config get-value project)
-
-export PROJECT_NUMBER=$(gcloud projects list \
- --filter="$(gcloud config get-value project)" \
- --format="value(PROJECT_NUMBER)")Enable required Google Cloud services:
-gcloud services enable cloudbuild.googleapis.com containerregistry.googleapis.com run.googleapis.com secretmanager.googleapis.com pubsub.googleapis.comBuild the application:
-gcloud builds submit --tag gcr.io/$PROJECT_ID/segment-listenerDefine an API key that you will share with Segment. Store the API key in Google Cloud Secret Manager:
-gcloud secrets create VANTAGE_USER_SECRET
-echo -n 'dbc' > /tmp/vantage_user.txt
-gcloud secrets versions add VANTAGE_USER_SECRET --data-file=/tmp/vantage_user.txt
-
-gcloud secrets create VANTAGE_PASSWORD_SECRET
-echo -n 'dbc' > /tmp/vantage_password.txt
-gcloud secrets versions add VANTAGE_PASSWORD_SECRET --data-file=/tmp/vantage_password.txtThe application that write Segment data to Vantage will use Cloud Run. We first need to allow Cloud Run to access secrets:
-gcloud projects add-iam-policy-binding $PROJECT_ID \
- --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
- --role=roles/secretmanager.secretAccessorDeploy the app to Cloud Run (replace <VANTAGE_HOST> with the hostname or IP of your Teradata Vantage database). The second export statement saves the service url as we need it for subsequent commands:
gcloud run deploy --image gcr.io/$PROJECT_ID/segment-listener segment-listener \
- --region $(gcloud config get-value compute/region) \
- --update-env-vars VANTAGE_HOST=35.239.251.1 \
- --update-secrets 'VANTAGE_USER=VANTAGE_USER_SECRET:1, VANTAGE_PASSWORD=VANTAGE_PASSWORD_SECRET:1' \
- --no-allow-unauthenticated
-
-export SERVICE_URL=$(gcloud run services describe segment-listener --platform managed --region $(gcloud config get-value compute/region) --format 'value(status.url)')Create a Pub/Sub topic that will receive events from Segment:
-gcloud pubsub topics create segment-eventsCreate a service account that will be used by Pub/Sub to invoke the Cloud Run app:
-gcloud iam service-accounts create cloud-run-pubsub-invoker \
- --display-name "Cloud Run Pub/Sub Invoker"Give the service account permission to invoke Cloud Run:
-gcloud run services add-iam-policy-binding segment-listener \
- --region $(gcloud config get-value compute/region) \
- --member=serviceAccount:cloud-run-pubsub-invoker@$PROJECT_ID.iam.gserviceaccount.com \
- --role=roles/run.invokerAllow Pub/Sub to create authentication tokens in your project:
-gcloud projects add-iam-policy-binding $PROJECT_ID \
- --member=serviceAccount:service-$PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
- --role=roles/iam.serviceAccountTokenCreatorCreate a Pub/Sub subscription with the service account:
-gcloud pubsub subscriptions create segment-events-cloudrun-subscription --topic projects/$PROJECT_ID/topics/segment-events \
- --push-endpoint=$SERVICE_URL \
- --push-auth-service-account=cloud-run-pubsub-invoker@$PROJECT_ID.iam.gserviceaccount.com \
- --max-retry-delay 600 \
- --min-retry-delay 30Allow Segment to publish to your topic. To do that, assign pubsub@segment-integrations.iam.gserviceaccount.com role Pub/Sub Publisher in your project at https://console.cloud.google.com/cloudpubsub/topic/list. See Segment manual for details.
Configure your Google Cloud Pub/Sub a destination in Segment. Use the full topic projects/<PROJECT_ID>/topics/segment-events and map all Segment event types (using * character) to the topic.
Use Segment’s Event Tester functionality to send a sample payload to the topic. Verify that the sample data has been stored in Vantage.
-The example shows how to deploy the app in a single region. In many cases, this setup doesn’t guarantee enough uptime. The Cloud Run app should be deployed in more than one region behind a Global Load Balancer.
-This how-to demonstrates how to send Segment events to Teradata Vantage. The configuration forwards events from Segment to Google Cloud Pub/Sub and then on to a Cloud Run application. The application writes data to Teradata Vantage.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This article outlines different use cases involving data ingestion. It lists available solutions and recommends the optimal solution for each use case.
-Available solutions:
-Stream data to object storage and then ingest using Teradata Native Object Store (NOS).
-Use the Teradata Parallel Transporter (TPT) command line utility.
-Use Teradata Query Service - REST API to execute SQL statements in the database.
-Use Teradata database drivers such as JDBC (Java), teradatasql (Python), Node.js driver, ODBC, .NET Data Provider.
-Teradata Parallel Transport API is usually the most performant solution which offers high throughput and minimum latency. Use it if you need to ingest tens of thousands of rows per second and if you are comfortable using C language.
-Use the Teradata database drivers when the number of events is in thousands per second. Consider using the Fastload protocol that is available in the most popular drivers e.g. JDBC, Python.
-If you don’t want to manage the dependency on the driver libraries, use Query Service. Since Query Service uses the regular driver protocol to communicate to the database, the throughput of this solution is similar to the throughput offered by database drivers such as JDBC. If you are a vendor and are looking to integrate your product with Teradata, please be aware that not all Teradata customers have Query Service enabled in their sites.
-If your solution can accept higher latency, a good option is to stream events to object storage and then read the data using NOS. This solution usually requires the least amount of effort.
-Available solutions:
-Flow is the recommended ingestion mechanism to bring data from object storage to VantageCloud Lake. For all other Teradata Vantage editions, Teradata NOS is the recommended option. NOS can leverage all Teradata nodes to perform ingestion. Teradata Parallel Transporter (TPT) runs on the client side. It can be used when there is no connectivity from NOS to object storage.
-Available solutions:
-TPT is the recommended option to load data from local files. TPT is optimized for scalability and parallelism, thus it has the best throughput of all available options. BTEQ can be used when an ingestion process requires scripting. It also makes sense to continue using BTEQ if all your other ingestion pipelines run in BTEQ.
-Available solutions:
-Multiple 3rd party tools such as Airbyte, Precog, Nexla, Fivetran
-Export from SaaS apps to local files and then ingest using Teradata Parallel Transporter (TPT)
-Export from SaaS apps to object storage and then ingest using Teradata Native Object Store (NOS).
-3rd party tools are usually a better option to move data from SaaS applications to Teradata Vantage. They offer broad support for data sources and eliminate the need to manage intermediate steps such as exporting and storing exported datasets.
-Available solutions:
-Export from other databases to local files and then ingest using Teradata Parallel Transporter (TPT)
-Export from other databases to object storage and then ingest using Teradata Native Object Store (NOS).
-QueryGrid is the recommended option to move limited quantities of data between different systems/platforms. This includes movement within Vantage instances, Apache Spark, Oracle, Presto, etc. It is especially suited to situations when what needs to be synced is described by complex conditions that can be expressed in SQL.
-In this article, we explored various data ingestion use cases, provided a list of available tools for each use case, and identified the recommended options for different scenarios.
-Sometimes, you need to apply complex logic to your data that can’t be easily expressed in SQL. One option is to wrap your logic in a User Defined Function (UDF). What if you already have this logic coded in a language that is not supported by UDF? Script Table Operator is a Vantage feature that allows you to bring your logic to the data and run it on Vantage. The advantage of this approach is that you don’t have to retrieve data from Vantage to operate on it. Also, by running your data applications on Vantage, you leverage its parallel nature. You don’t have to think how your applications will scale. You can let Vantage take care of it.
-You need access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Let’s start with something simple. What if you wanted the database to print "Hello World"?
-SELECT *
-FROM
- SCRIPT(
- SCRIPT_COMMAND('echo Hello World!')
- RETURNS ('Message varchar(512)'));Here is what I’ve got:
-Message ------------- -Hello World! -Hello World!-
Let’s analyze what just happened here. The SQL includes echo Hello World!. This is a Bash command. OK, so now we know how to run Bash commands. But why did we get 2 rows and not one? That’s because our simple script was run once on each AMP and I happen to have 2 AMPs:
-- Teradata magic that returns the number of AMPs in a system
-SELECT hashamp()+1 AS number_of_amps;Returns:
-number_of_amps --------------- - 2-
This simple script demonstrates the idea behind the Script Table Operator (STO). You provide your script and the database runs it in parallel, once for each AMP. This is an attractive model in case you have transformation logic in a script and a lot of data to process. Normally, you would need to build concurrency into your application. By letting STO do it, you let Teradata select the right concurrency level for your data.
-OK, so we did echo in Bash but Bash is hardly a productive environment to express complex logic. What other languages are supported then? The good news is that any binary that can run on Vantage nodes can be used in STO. Remember, that the binary and all its dependencies need to be installed on all your Vantage nodes. In practice, it means that your options will be limited to what your administrator is willing and able to maintain on your servers. Python is a very popular choice.
Ok, Hello World is super exciting, but what if we have existing logic in a large file. Surely, you don’t want to paste your entire script and escape quotes in an SQL query. We solve the script upload issue with the User Installed Files (UIF) feature.
-Say you have helloworld.py script with the following content:
print("Hello World!")Let’s assume the script is on your local machine at /tmp/helloworld.py.
First, we need to setup permissions in Vantage. We are going to do this using a new database to keep it clean.
--- Create a new database called sto
-CREATE DATABASE STO
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MB
-
--- Allow dbc user to create scripts in database STO
-GRANT CREATE EXTERNAL PROCEDURE ON STO to dbc;You can upload the script to Vantage using the following procedure call:
-call SYSUIF.install_file('helloworld',
- 'helloworld.py', 'cz!/tmp/helloworld.py');Now that the script has been uploaded, you can call it like this:
--- We switch to STO database
-DATABASE STO
-
--- We tell Vantage where to look for the script. This can be
--- any string and it will create a symbolic link to the directory
--- where our script got uploaded. By convention, we use the
--- database name.
-SET SESSION SEARCHUIFDBPATH = sto;
-
--- We now call the script. Note, how we use a relative path that
--- starts with `./sto/`, which is where SEARCHUIFDBPATH
--- is pointing.
-SELECT *
-FROM SCRIPT(
- SCRIPT_COMMAND('python3 ./sto/helloworld.py')
- RETURNS ('Message varchar(512)'));The last call should return:
-Message ------------- -Hello World! -Hello World!-
That was a lot of work and we are still at Hello World. Let’s try to pass some data into SCRIPT.
So far, we have been using SCRIPT operator to run standalone scripts. But the main purpose to run scripts on Vantage is to process data that is in Vantage. Let’s see how we can retrieve data from Vantage and pass it to SCRIPT.
We will start with creating a table with a few rows.
--- Switch to STO database.
-DATABASE STO
-
--- Create a table with a few urls
-CREATE TABLE urls(url varchar(10000));
-INS urls('https://www.google.com/finance?q=NYSE:TDC');
-INS urls('http://www.ebay.com/sch/i.html?_trksid=p2050601.m570.l1313.TR0.TRC0.H0.Xteradata+merchandise&_nkw=teradata+merchandise&_sacat=0&_from=R40');
-INS urls('https://www.youtube.com/results?search_query=teradata%20commercial&sm=3');
-INS urls('https://www.contrivedexample.com/example?mylist=1&mylist=2&mylist=...testing');We will use the following script to parse out query parameters:
-from urllib.parse import urlparse
-from urllib.parse import parse_qsl
-import sys
-
-for line in sys.stdin:
- # remove leading and trailing whitespace
- url = line.strip()
- parsed_url = urlparse(url)
- query_params = parse_qsl(parsed_url.query)
-
- for element in query_params:
- print("\t".join(element))Note, how the scripts assumes that urls will be fed into stdin one by one, line by line. Also, note how it prints results line by line, using the tab character as a delimiter between values.
Let’s install the script. Here, we assume that the script file is at /tmp/urlparser.py on our local machine:
CALL SYSUIF.install_file('urlparser',
- 'urlparser.py', 'cz!/tmp/urlparser.py');With the script installed, we will now retrieve data from urls table and feed it into the script to retrieve query parameters:
-- We inform Vantage to create a symbolic link from the UIF directory to ./sto/
-SET SESSION SEARCHUIFDBPATH = sto ;
-
-SELECT *
- FROM SCRIPT(
- ON(SELECT url FROM urls)
- SCRIPT_COMMAND('python3 ./sto/urlparser.py')
- RETURNS ('param_key varchar(512)', 'param_value varchar(512)'));As a result, we get query params and their values. There are as many rows as key/value pairs. Also, since we inserted a tab between the key and the value output in the script, we get 2 columns from STO.
-param_key |param_value -------------+----------------------------------------------------- -q |NYSE:TDC -_trksid |p2050601.m570.l1313.TR0.TRC0.H0.Xteradata merchandise -search_query|teradata commercial -_nkw |teradata merchandise -sm |3 -_sacat |0 -mylist |1 -_from |R40 -mylist |2 -mylist |...testing-
We have learned how to take data from Vantage, pass it to a script and get output. Is there an easy way to store this output in a table? Sure, there is. We can combine the select above with CREATE TABLE statement:
-- We inform Vantage to create a symbolic link from the UIF directory to ./sto/
-SET SESSION SEARCHUIFDBPATH = sto ;
-
-CREATE MULTISET TABLE
- url_params(param_key, param_value)
-AS (
- SELECT *
- FROM SCRIPT(
- ON(SELECT url FROM urls)
- SCRIPT_COMMAND('python3 ./sto/urlparser.py')
- RETURNS ('param_key varchar(512)', 'param_value varchar(512)'))
-) WITH DATA
-NO PRIMARY INDEX;Now, let’s inspect the contents of url_params table:
SELECT * FROM url_params;You should see the following output:
-param_key |param_value -------------+----------------------------------------------------- -q |NYSE:TDC -_trksid |p2050601.m570.l1313.TR0.TRC0.H0.Xteradata merchandise -search_query|teradata commercial -_nkw |teradata merchandise -sm |3 -_sacat |0 -mylist |1 -_from |R40 -mylist |2 -mylist |...testing-
In this quick start we have learned how to run scripts against data in Vantage. We ran scripts using Script Table Operator (STO). The operator allows us to bring logic to the data. It offloads concurrency considerations to the database by running our scripts in parallel, one per AMP. All you need to do is provide a script and the database will execute it in parallel.
-| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This article explains the underlying concepts of Teradata Vantage engine architecture. All editions of Vantage, including the Primary Cluster in VantageCloud Lake utilize the same engine.
-Teradata’s architecture is designed around a Massively Parallel Processing (MPP), shared-nothing architecture, which enables high-performance data processing and analytics. The MPP architecture distributes the workload into multiple vprocs or virtual processors. The virtual processor where query processing takes place is commonly referred to as an Access Module Processor (AMP). Each AMP is isolated from other AMPs, and processes the queries in parallel allowing Teradata to process large volumes of data rapidly.
-The major architectural components of the Teradata Vantage engine include the Parsing Engines (PEs), BYNET, Access Module Processors (AMPs), and Virtual Disks (Vdisks). Vdisks are assigned to AMPs in enterprise platforms, and to the Primary Cluster in the case of VantageCloud Lake environments.
-
-The Teradata Vantage engine consists of the components below:
-When a SQL query is run in Teradata, it first reaches the Parsing Engine. The functions of the Parsing Engine are:
-Manage individual user sessions (up to 120).
-Check if the objects used in the SQL query exist.
-Check if the user has required privileges against the objects used in the SQL query.
-Parse and optimize the SQL queries.
-Prepare the execution plan to execute the SQL query and passes it to the corresponding AMPs.
-Receive the response from the AMPs and send it back to the requesting client.
-BYNET is a system that enables component communication. The BYNET system provides high-speed bi-directional broadcast, multicast, and point-to-point communication and merge functions. It performs three key functions: coordinating multi-AMP queries, reading data from multiple AMPs, regulating message flow to prevent congestion, and processing platform throughput. These functions of BYNET make Vantage highly scalable and enable Massively Parallel Processing (MPP) capabilities.
-Parallel Database Extension (PDE) is an intermediary software layer positioned between the operating system and the Teradata Vantage database. PDE enables MPP systems to use features such as BYNET and shared disks. It facilitates the parallelism that is responsible for the speed and linear scalability of the Teradata Vantage database.
-AMPs are responsible for data storage and retrieval. Each AMP is associated with its own set of Virtual Disks (Vdisks) where the data is stored, and no other AMP can access that content in line with the shared-nothing architecture. The functions of AMP are:
-Access storage using Vantage’s Block File System Software
-Lock management
-Sorting rows
-Aggregating columns
-Join processing
-Output conversion
-Disk space management
-Accounting
-Recovery processing
-| - - | -
-
-
-AMPs in VantageCore IntelliFlex, VantageCore VMware, VantageCloud Enterprise, and the Primary Cluster in the case of VantageCloud Lake, store data in a Block File System (BFS) format on Vdisks. AMPs in Compute Clusters and Compute Worker Nodes on VantageCloud Lake do not have BFS, they can only access data in object storage using the Object File System (OFS). - |
-
These are units of storage space owned by an AMP. Virtual Disks are used to hold user data (rows within tables). Virtual Disks map to physical space on a disk.
-A node, in the context of Teradata systems, represents an individual server that functions as a hardware platform for the database software. It serves as a processing unit where database operations are executed under the control of a single operating system. When Teradata is deployed in a cloud, it follows the same MPP, shared-nothing architecture but the physical nodes are replaced with virtual machines (VMs).
-The concepts below are applicable to Teradata Vantage.
-Teradata is a linearly expandable RDBMS. As the workload and data volume increase, adding more hardware resources such as servers or nodes results in a proportional increase in performance and capacity. Linear Scalability allows for increased workload without decreased throughput.
-Teradata parallelism refers to the inherent ability of the Teradata Database to perform parallel processing of data and queries across multiple nodes or components simultaneously.
-Each Parsing Engine (PE) in Teradata has the capability to handle up to 120 sessions concurrently.
-The BYNET in Teradata enables parallel handling of all message activity, including data redistribution for subsequent tasks.
-All Access Module Processors (AMPs) in Teradata can collaborate in parallel to serve any incoming request.
-Each AMP can work on multiple requests concurrently, allowing for efficient parallel processing.
-
-The key steps involved in Teradata Retrieval Architecture are:
-The Parsing Engine sends a request to retrieve one or more rows.
-The BYNET activates the relevant AMP(s) for processing.
-The AMP(s) concurrently locate and retrieve the desired row(s) through parallel access.
-The BYNET returns the retrieved row(s) to the Parsing Engine.
-The Parsing Engine then delivers the row(s) back to the requesting client application.
-
-Teradata’s MPP architecture requires an efficient means of distributing and retrieving data and does so using hash partitioning. Most tables in Vantage use hashing to distribute data for the tables based on the value of the row’s Primary Index (PI) to disk storage in Block File System (BFS) and may scan the entire table or use indexes to access the data. This approach ensures scalable performance and efficient data access.
-If the Primary Index is unique then the rows in the tables are automatically distributed evenly by hash partitioning.
-The designated Primary Index column(s) are hashed to generate consistent hash codes for the same values.
-No reorganization, repartitioning, or space management is required.
-Each AMP typically contains rows from all tables, ensuring efficient data access and processing.
-
-In this article, we covered the major architectural components of Teradata Vantage, such as the Parsing Engines (PEs), BYNET, Access Module Processors (AMPs), Virtual Disk (Vdisk), other architectural components such as Parallel Database Extension (PDE), Node and the essential concepts of Teradata Vantage such as Linear Growth and Expandability, Parallelism, Data Retrieval, and Data Distribution.
-This how-to demonstrates how to connect to Vantage using teradatasql Python database driver for Teradata Vantage.
-64-bit Python 3.4 or later.
-teradatasql driver installed in your system:
pip install teradatasql| - - | -
-
-
-
|
-
Access to a Teradata Vantage instance. Currently driver is supported for use with Teradata Database 16.10 and later releases.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
This is a simple Python code to connect to Teradata Vantage using teradatasql. All that is left, is to pass connection and authentication parameters and run a query:
This how-to demonstrated how to connect to Teradata Vantage using teradatasql Python database driver. It described a sample Python code to send SQL queries to Teradata Vantage using teradatasql.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
We often have a need to move large volumes of data into Vantage. Teradata offers Teradata Parallel Transporter (TPT) utility that can efficiently load large amounts of data into Teradata Vantage. This how-to demonstrates how to use TPT. In this scenario, we will load over 300k records, over 40MB of data, in a couple of seconds.
Access to a Teradata Vantage instance.
-| - - | --If you need a test instance of Vantage, you can provision one for free at https://clearscape.teradata.com. - | -
Download Teradata Tools and Utilities (TTU) - supported platforms: Windows, MacOS, Linux (requires registration).
-We will be working with the US tax fillings for nonprofit organizations. Nonprofit tax filings are public data. The US Internal Revenue Service publishes them in S3 bucket. Let’s grab a summary of filings for 2020: https://storage.googleapis.com/clearscape_analytics_demo_data/TPT/index_2020.csv. You can use your browser, wget or curl to save the file locally.
Let’s create a database in Vantage. Use your favorite SQL tool to run the following query:
-CREATE DATABASE irs
-AS PERMANENT = 120e6, -- 120MB
- SPOOL = 120e6; -- 120MBWe will now run TPT. TPT is a command-line tool that can be used to load, extract and update data in Teradata Vantage. These various functions are implemented in so called operators. For example, loading data into Vantage is handled by the Load operator. The Load operator is very efficient in uploading large amounts of data into Vantage. The Load operator, in order to be fast, has several restrictions in place. It can only populate empty tables. Inserts to already populated tables are not supported. It doesn’t support tables with secondary indices. Also, it won’t insert duplicate records, even if a table is a MULTISET table. For the full list of restrictions check out Teradata® TPT Reference - Load Operator - Restrictions and Limitations.
TPT has its own scripting language. The language allows you to prepare the database with arbitrary SQL commands, declare the input source and define how the data should be inserted into Vantage.
-To load the csv data to Vantage, we will define and run a job. The job will prepare the database. It will remove old log and error tables and create the target table. It will then read the file and insert the data into the database.
-Create a job variable file that will tell TPT how to connect to our Vantage database. Create file jobvars.txt and insert the following content. Replace host with the host name of your database. For example, if you are using a local Vantage Express instance, use 127.0.0.1. username with the database user name, and password with the database password. Note that the preparation step (DDL) and the load step have their own configuration values and that the config values need to be entered twice to configure both the DDL and the load step.
TargetTdpId = 'host'
-TargetUserName = 'username'
-TargetUserPassword = 'password'
-
-FileReaderDirectoryPath = ''
-FileReaderFileName = 'index_2020.csv'
-FileReaderFormat = 'Delimited'
-FileReaderOpenMode = 'Read'
-FileReaderTextDelimiter = ','
-FileReaderSkipRows = 1
-
-DDLErrorList = '3807'
-
-LoadLogTable = 'irs.irs_returns_lg'
-LoadErrorTable1 = 'irs.irs_returns_et'
-LoadErrorTable2 = 'irs.irs_returns_uv'
-LoadTargetTable = 'irs.irs_returns'Create a file with the following content and save it as load.txt. See comments within the job file to understand its structure.
DEFINE JOB file_load
-DESCRIPTION 'Load a Teradata table from a file'
-(
- /*
- Define the schema of the data in the csv file
- */
- DEFINE SCHEMA SCHEMA_IRS
- (
- in_return_id VARCHAR(19),
- in_filing_type VARCHAR(5),
- in_ein VARCHAR(19),
- in_tax_period VARCHAR(19),
- in_sub_date VARCHAR(22),
- in_taxpayer_name VARCHAR(100),
- in_return_type VARCHAR(5),
- in_dln VARCHAR(19),
- in_object_id VARCHAR(19)
- );
-
- /*
- In the first step, we are sending statements to remove old tables
- and create a new one.
- This step replies on configuration stored in `od_IRS` operator
- */
- STEP st_Setup_Tables
- (
- APPLY
- ('DROP TABLE ' || @LoadLogTable || ';'),
- ('DROP TABLE ' || @LoadErrorTable1 || ';'),
- ('DROP TABLE ' || @LoadErrorTable2 || ';'),
- ('DROP TABLE ' || @LoadTargetTable || ';'),
- ('CREATE TABLE ' || @LoadTargetTable || ' (
- return_id INT,
- filing_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- ein INT,
- tax_period INT,
- sub_date VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- taxpayer_name VARCHAR(100) CHARACTER SET LATIN NOT CASESPECIFIC,
- return_type VARCHAR(5) CHARACTER SET LATIN NOT CASESPECIFIC,
- dln BIGINT,
- object_id BIGINT
- )
- PRIMARY INDEX ( return_id );')
- TO OPERATOR ($DDL);
- );
-
- /*
- Finally, in this step we read the data from the file operator
- and send it to the load operator.
- */
- STEP st_Load_File
- (
- APPLY
- ('INSERT INTO ' || @LoadTargetTable || ' (
- return_id,
- filing_type,
- ein,
- tax_period,
- sub_date,
- taxpayer_name,
- return_type,
- dln,
- object_id
- ) VALUES (
- :in_return_id,
- :in_filing_type,
- :in_ein,
- :in_tax_period,
- :in_sub_date,
- :in_taxpayer_name,
- :in_return_type,
- :in_dln,
- :in_object_id
- );')
- TO OPERATOR ($LOAD)
- SELECT * FROM OPERATOR($FILE_READER(SCHEMA_IRS));
- );
-);Run the job:
-tbuild -f load.txt -v jobvars.txt -j file_loadA successful run will return logs that look like this:
-Teradata Parallel Transporter Version 17.10.00.10 64-Bit -The global configuration file '/opt/teradata/client/17.10/tbuild/twbcfg.ini' is used. - Log Directory: /opt/teradata/client/17.10/tbuild/logs - Checkpoint Directory: /opt/teradata/client/17.10/tbuild/checkpoint - -Job log: /opt/teradata/client/17.10/tbuild/logs/file_load-4.out -Job id is file_load-4, running on osboxes -Teradata Parallel Transporter SQL DDL Operator Version 17.10.00.10 -od_IRS: private log not specified -od_IRS: connecting sessions -od_IRS: sending SQL requests -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_lg' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_et' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: TPT10508: RDBMS error 3807: Object 'irs_returns_uv' does not exist. -od_IRS: TPT18046: Error is ignored as requested in ErrorList -od_IRS: disconnecting sessions -od_IRS: Total processor time used = '0.013471 Second(s)' -od_IRS: Start : Thu Apr 7 20:56:32 2022 -od_IRS: End : Thu Apr 7 20:56:32 2022 -Job step st_Setup_Tables completed successfully -Teradata Parallel Transporter Load Operator Version 17.10.00.10 -ol_IRS: private log not specified -Teradata Parallel Transporter DataConnector Operator Version 17.10.00.10 -op_IRS[1]: Instance 1 directing private log report to 'dtacop-root-368731-1'. -op_IRS[1]: DataConnector Producer operator Instances: 1 -op_IRS[1]: ECI operator ID: 'op_IRS-368731' -op_IRS[1]: Operator instance 1 processing file 'index_2020.csv'. -ol_IRS: connecting sessions -ol_IRS: preparing target table -ol_IRS: entering Acquisition Phase -ol_IRS: entering Application Phase -ol_IRS: Statistics for Target Table: 'irs.irs_returns' -ol_IRS: Total Rows Sent To RDBMS: 333722 -ol_IRS: Total Rows Applied: 333722 -ol_IRS: Total Rows in Error Table 1: 0 -ol_IRS: Total Rows in Error Table 2: 0 -ol_IRS: Total Duplicate Rows: 0 -op_IRS[1]: Total files processed: 1. -ol_IRS: disconnecting sessions -Job step st_Load_File completed successfully -Job file_load completed successfully -ol_IRS: Performance metrics: -ol_IRS: MB/sec in Acquisition phase: 9.225 -ol_IRS: Elapsed time from start to Acquisition phase: 2 second(s) -ol_IRS: Elapsed time in Acquisition phase: 5 second(s) -ol_IRS: Elapsed time in Application phase: 3 second(s) -ol_IRS: Elapsed time from Application phase to end: < 1 second -ol_IRS: Total processor time used = '0.254337 Second(s)' -ol_IRS: Start : Thu Apr 7 20:56:32 2022 -ol_IRS: End : Thu Apr 7 20:56:42 2022 -Job start: Thu Apr 7 20:56:32 2022 -Job end: Thu Apr 7 20:56:42 2022-
TPT vs. NOSIn our case, the file is in an S3 bucket. That means, that we can use Native Object Storage (NOS) to ingest the data:
--- create an S3-backed foreign table
-CREATE FOREIGN TABLE irs_returns_nos
- USING ( LOCATION('/s3/s3.amazonaws.com/irs-form-990/index_2020.csv') );
-
--- load the data into a native table
-CREATE MULTISET TABLE irs_returns_nos_native
- (RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME)
-AS (
- SELECT RETURN_ID, FILING_TYPE, EIN, TAX_PERIOD, SUB_DATE, TAXPAYER_NAME FROM irs_returns_nos
-) WITH DATA
-NO PRIMARY INDEX;The NOS solution is convenient as it doesn’t depend on additional tools. It can be implemented using only SQL. It performs well, especially for Vantage deployments with a high number of AMPs as NOS tasks are delegated to AMPs and run in parallel. Also, splitting the data in object storage into multiple files may further improve performance.
-This how-to demonstrated how to ingest large amounts of data into Vantage. We loaded hundreds of thousands or records into Vantage in a couple of seconds using TPT.
| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
| - - | --You can now get a hosted instance of Vantage for free at https://clearscape.teradata.com/. - | -
This how-to demonstrates how to run Vantage Express in Google Cloud Platform. Vantage Express contains a fully functional Teradata SQL Engine.
-| - - | --If do not wish to pay for cloud usage you can install Vantage Express locally using VMware, VirtualBox, UTM. - | -
A Google Cloud account.
-gcloud command line utility installed on your machine. You can find installation instructions here: https://cloud.google.com/sdk/docs/install.
Create a Ubuntu VM with 4 CPU’s and 8GB of RAM, a 70GB balanced disk. The following command creates a VM in us-central1 region. For best performance, replace the region with one that is the closest to you. For the list of supported regions see Google Cloud regions documentation.
Run in Powershell:
-gcloud compute instances create teradata-vantage-express `
- --zone=us-central1-a `
- --machine-type=n2-custom-4-8192 `
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced `
- --enable-nested-virtualization `
- --tags=vegcloud compute instances create teradata-vantage-express \
- --zone=us-central1-a \
- --machine-type=n2-custom-4-8192 \
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced \
- --enable-nested-virtualization \
- --tags=vegcloud compute instances create teradata-vantage-express \
- --zone=us-central1-a \
- --machine-type=n2-custom-4-8192 \
- --create-disk=boot=yes,device-name=ve-disk,image-project=ubuntu-os-cloud,image-family=ubuntu-2004-lts,size=70,type=pd-balanced \
- --enable-nested-virtualization \
- --tags=vessh to your VM:
-gcloud compute ssh teradata-vantage-express --zone=us-central1-aSwitch to root user:
sudo -iPrepare the download directory for Vantage Express:
-mkdir /opt/downloads
-cd /opt/downloadsInstall VirtualBox and 7zip:
-apt update && apt-get install p7zip-full p7zip-rar virtualbox -yRetrieve the curl command to download Vantage Express.
-Go to Vantage Expess download page (registration required).
-Click on the latest download link, e.g. "Vantage Express 17.20". You will see a license agreement popup. Don’t accept the license yet.
-Open the network view in your browser. For example, in Chrome press F12 and navigate to Network tab:
-Accept the license by clicking on I Agree button and cancel the download.
In the network view, find the last request that starts with VantageExpress. Right click on it and select Copy → Copy as cURL:
-Head back to the ssh session and download Vantage Express by pasting the curl command. Add -o ve.7z to the command to save the download to file named ve.7z. You can remove all the HTTP headers, e.g.:
curl -o ve.7z 'http://d289lrf5tw1zls.cloudfront.net/database/teradata-express/VantageExpress17.20_Sles12_202108300444.7z?Expires=1638719978&Signature=GKBkNvery_long_signature__&Key-Pair-Id=********************'Unzip the downloaded file. It will take several minutes:
-7z x ve.7zStart the VM in VirtualBox. The command will return immediately but the VM init process will take several minutes:
-export VM_IMAGE_DIR="/opt/downloads/VantageExpress17.20_Sles12"
-DEFAULT_VM_NAME="vantage-express"
-VM_NAME="${VM_NAME:-$DEFAULT_VM_NAME}"
-vboxmanage createvm --name "$VM_NAME" --register --ostype openSUSE_64
-vboxmanage modifyvm "$VM_NAME" --ioapic on --memory 6000 --vram 128 --nic1 nat --cpus 4
-vboxmanage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk1*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk2*')"
-vboxmanage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 2 --device 0 --type hdd --medium "$(find $VM_IMAGE_DIR -name '*disk3*')"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tdssh,tcp,,4422,,22"
-vboxmanage modifyvm "$VM_NAME" --natpf1 "tddb,tcp,,1025,,1025"
-vboxmanage startvm "$VM_NAME" --type headless
-vboxmanage controlvm "$VM_NAME" keyboardputscancode 1c 1cssh to Vantage Express VM. Use root as password:
ssh -p 4422 root@localhostValidate that the DB is up:
-pdestate -aIf the command returns PDE state is RUN/STARTED. DBS state is 5: Logons are enabled - The system is quiescent, it means that Vantage Express has started.
-If the status is different, repeat pdestate -a till you get the correct status.
Once Vantage Express is up and running, start bteq client command line client. BTEQ (pronounced “bee-teek”) is a general-purpose, command-based client tool used to submit SQL queries to a Teradata Database.
bteqOnce in bteq, connect to your Vantage Express instance. When asked for the password, enter dbc:
.logon localhost/dbcUsing dbc user, we will create a new database called HR. Copy/paste this query and run press Enter:
CREATE DATABASE HR
-AS PERMANENT = 60e6, -- 60MB
- SPOOL = 120e6; -- 120MBLet’s create a sample table and insert some data and query it. We will first create a table to hold employee information:
-CREATE SET TABLE HR.Employees (
- GlobalID INTEGER,
- FirstName VARCHAR(30),
- LastName VARCHAR(30),
- DateOfBirth DATE FORMAT 'YYYY-MM-DD',
- JoinedDate DATE FORMAT 'YYYY-MM-DD',
- DepartmentCode BYTEINT
-)
-UNIQUE PRIMARY INDEX ( GlobalID );Now, let’s insert a record:
-INSERT INTO HR.Employees (
- GlobalID,
- FirstName,
- LastName,
- DateOfBirth,
- JoinedDate,
- DepartmentCode
-)
-VALUES (
- 101,
- 'Adam',
- 'Tworkowski',
- '1980-01-05',
- '2004-08-01',
- 01
-);Finally, let’s see if we can retrieve the data:
-SELECT * FROM HR.Employees;You should get the following results:
-GlobalID FirstName LastName DateOfBirth JoinedDate DepartmentCode --------- --------- ---------- ----------- ---------- -------------- - 101 Adam Tworkowski 1980-01-05 2004-08-01 1-
If you intend to stop and start the VM, you may want to add Vantage Express to autostart. ssh to your VM and run the following commands:
-sudo -i
-
-cat <<EOF >> /etc/default/virtualbox
-VBOXAUTOSTART_DB=/etc/vbox
-VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg
-EOF
-
-cat <<EOF > /etc/systemd/system/vantage-express.service
-[Unit]
-Description=vm1
-After=network.target virtualbox.service
-Before=runlevel2.target shutdown.target
-[Service]
-User=root
-Group=root
-Type=forking
-Restart=no
-TimeoutSec=5min
-IgnoreSIGPIPE=no
-KillMode=process
-GuessMainPID=no
-RemainAfterExit=yes
-ExecStart=/usr/bin/VBoxManage startvm vantage-express --type headless
-ExecStop=/usr/bin/VBoxManage controlvm vantage-express savestate
-[Install]
-WantedBy=multi-user.target
-EOF
-
-systemctl daemon-reload
-systemctl enable vantage-express
-systemctl start vantage-expressIf you would like to connect to Vantage Express from the Internet, you will need to open up firewall holes to your VM. You should also change the default password to dbc user:
To change the password for dbc user go to your VM and start bteq:
bteqLogin to your database using dbc as username and password:
.logon localhost/dbcChange the password for dbc user:
MODIFY USER dbc AS PASSWORD = new_password;You can now open up port 1025 to the internet using gcloud command:
-gcloud compute firewall-rules create vantage-express --allow=tcp:1025 --direction=IN --target-tags=veTo stop incurring charges, delete the VM:
-gcloud compute instances delete teradata-vantage-express --zone=us-central1-aAlso, remember to remove any firewall rules that you have added, e.g.:
-gcloud compute firewall-rules delete vantage-express| - - | --If you have any questions or need further assistance, please visit our community forum where you can get support and interact with other community members. - | -
This quickstart details the process for running the Teradata Jupyter Notebook Demos for VantageCloud Lake, on Microsoft Azure.
-Access to a Microsoft Azure account
-Access to a VantageCloud Lake environment
- -In this section we will cover in detail each of the steps below:
-Create a Microsoft Azure Web App based on Teradata Jupyter Lab extensions Docker image
-Configure Jupyter Lab extensions Azure Web App
-Load Vantagecloud Lake demos to Jupyter Lab extensions Azure Web App
-Find the IP of the Jupyter Lab extensions Azure Web App
-Login to Microsoft Azure and click on "APP Services"
-
-In "App Services" click Web App
-
-On the "Basics" tab:
-Select the appropriate resource group from the dropdown, or create a new one
-Enter a name for your web app.
-Select "Docker Container" in the "Publish" radio button options
-Select "Linux" as the operating system
-Select the appropriate region from the dropdown
-Select the appropriate App Service plan. If you don’t have one, a new one will be created with default configurations
-| - - | --For purposes of the VantageCloud Lake demo redundancy is not needed - | -
After completing this tab, click the "Docker" tab to continue
-
-On the "Docker" tab:
-Select "Single Container" from the dropdown
-In the "Image Source" dropdown select "Docker Hub"
-In the "Access Type" dropdown select "Public"
-In "Image and tag" type teradata/jupyterlab-extensions:latest
| - - | --A startup command is not needed for this App Service - | -
Select the "Review + Create" tab to continue
-
-In the "Review + Create" tab click the "Create" button
-
-When the deployment is complete click the "Go to Resource" button
-
-Select Configuration on the right panel
-
-Add the following Application Settings
-Application Setting |
-Value |
-
accept_license |
-Y |
-
WEBSITES_PORT |
-8888 |
-
JUPYTER_TOKEN |
-Define the Jupyter Lab access token that you would like to use. |
-
| - - | --If you don’t include the "JUPYTER_TOKEN" configuration, the container will generate a new token and log it to the console. You will need to retrieve it from the application logs. If you include the "JUPYTER_TOKEN" configuration key but leave the value blank, the system will set the token as an empty string, resulting in an unprotected Jupyter Lab environment without any token security. - | -
Click on save, your app will be restarted
-
-Return to the Overview tab on the right panel
-Click on Default domain
-
-On the Jupyter Lab start dialogue enter the defined Jupyter token and click Log in
-
-On the Jupyter Lab console click on the git icon
-
-Copy the following URI in the corresponding field
-Click Clone
-
-On the Jupyter Lab console click in the lake-demos folder
-
-In JupyterLab open a notebook with Teradata Python kernel and run the following command to find your notebook instance’s IP address.
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)The next step is whitelist this IP in your VantageCloud Lake environment to allow the connection
-This is for purposes of this guide and the notebook demos. For production environments, a more robust networking setting might be needed
-Azure App Service offers, as well, a list of all possible IP addresses that the service might expose. This is under the overview tab
-
-In the VantageCloud Lake environment, under settings, add the IP of your notebook instance
-| - - | --A lake environment supports multiple address whitelisting - | -
-vars.json should be edited to match the configuration of your VantageCloud Lake environment
-Especifically the following values should be added
-| Variable | -Value | -
|---|---|
"host" |
-Public IP value from your VantageCloud Lake environment |
-
"UES_URI" |
-Open Analytics from your VantageCloud Lake environment |
-
"dbc" |
-The master password of your VantageCloud Lake environment |
-
You’ll see that in the sample vars.json, the passwords of all users are defaulted to "password", this is just for illustration purposes, you should change all of these password fields to strong passwords, secure them as necessary, and follow other password management best practices.
-| - - | --Remember to change all passwords in the vars.json file. - | -
Open and execute all the cells in 0_Demo_Environment_Setup.ipynb to setup your environment. Followed by 1_Demo_Setup_Base_Data.ipynb to load the base data required for demo.
-To learn more about the demo notebooks, go to Teradata Lake demos page on GitHub.
-In this quick start we learned how to run Jupyter notebook demos for VantageCloud Lake in Microsoft Azure.
-In this how-to we will go through the steps for connecting to Teradata VantageCloud Lake and run demos from a Jupyter notebook in Docker.
-Docker Desktop installed
-Git installed
-Required to download git repo from https://github.com/Teradata/lake-demos.git
-A Teradata VantageCloud Lake account login
-Organization URL and login details from Teradata welcome letter
-IDE of your choice
-Follow the instructions from the VantageCloud Lake getting started to create your own environment.
-Once created, go to SETTINGS tab and provide your public IP address to access the environment.
| - - | --You can find your IP address from WhatIsMyIp.com website. Take note of the IPv4 address. - | -
-Your environment card should show Public internet access now.
-
-From OVERVIEW tab, copy:
-Public IP and
-Open Analytics Endpoint
-These values are required to access VantageCloud Lake from the Docker.
-
-Clone VantageCloud Lake Demo repository in your local machine:
-git clone https://github.com/Teradata/lake-demos.git
-cd lake-demosThe repository contains different files and folders, the important ones are:
-Jupyter Notebooks
-To connect Jupyter notebooks with VantageCloud Lake, you need to edit vars.json file and provide:
-| Variable | -Value | -
|---|---|
"host" |
-Public IP value from OVERVIEW section (see above) |
-
"UES_URI" |
-Open Analytics Endpoint value from OVERVIEW section (see above) |
-
"dbc" |
-The master password of your VantageCloud Lake environment |
-
| - - | --In the sample vars.json, the passwords of all users are defaulted to "password", this is just for illustration purposes. You should change all of these password fields to strong passwords, secure them as necessary, and follow other password management best practices. - | -
To run VantageCloud Lake demos, we need the Teradata Jupyter Extensions for Docker. The extensions provide the SQL ipython kernel, utilities to manage connections to Teradata, and the database object explorer to make you productive while interacting with the Teradata database.
-| - - | --Make sure that you are running all the commands in the same folder where you have cloned the demo repository. - | -
Start a container and bind it to the existing lake-demos directory. Choose the appropriate command based on your operating system:
-| - - | --For Windows, run the docker command in PowerShell. - | -
docker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v ${PWD}:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensions
-Click on the URL in docker logs to open Jupyter notebook in your browser.
-
-Open and execute all the cells in 0_Demo_Environment_Setup.ipynb to setup your environment, followed by 1_Demo_Setup_Base_Data.ipynb to load the base data required for the demos.
-To learn more about the demo notebooks, go to Teradata Lake demos page on GitHub.
-In this quick start we learned how to run Teradata VantageCloud Lake demos from Jupyter Notebook in Docker.
-This quickstart explains how to run Teradata Jupyter Notebook Demos for VantageCloud Lake on Vertex AI, the AI/ML platform for Google Cloud.
-Teradata modules for Jupyter Linux desktop version (download here, registration required)
-Google Cloud account with Vertex AI and Notebooks API enabled
-Google cloud storage to store startup scripts and Teradata Jupyter extension package
-When you create a new notebook instance, you can specify a startup script. This script, which runs only once after instance creation, will install the Teradata Jupyter extension package and clone a GitHub repository into the new user-managed notebooks instance.
-Download Teradata Jupyter extensions package
-Sign in and download the Teradata Linux version of the package.
-Create Google Cloud Storage Bucket
-Create a bucket with a name relevant to the project (e.g., teradata_jupyter).
-Ensure that the bucket name is globally unique. For instance, if the name teradata_jupyter has already been used, it will not be available for subsequent users.
-
-Upload the unizzped Jupyter extension package to your Google Cloud Storage bucket as a file.
-Write the following startup script and save it as startup.sh to your local machine.
Below is an example script that retrieves the Teradata Jupyter extension package from Google Cloud Storage bucket and installs Teradata SQL kernel, extensions and clones the lake-demos repository.
-| - - | -
-
-
-Remember to replace teradata_jupyter in the gsutil cp command. - |
-
#! /bin/bash
-
-cd /home/jupyter
-mkdir teradata
-cd teradata
-gsutil cp gs://teradata_jupyter/* .
-unzip teradatasql*.zip
-
-# Install Teradata kernel
-cp teradatakernel /usr/local/bin
-
-jupyter kernelspec install ./teradatasql --prefix=/opt/conda
-
-# Install Teradata extensions
-pip install --find-links . teradata_preferences_prebuilt
-pip install --find-links . teradata_connection_manager_prebuilt
-pip install --find-links . teradata_sqlhighlighter_prebuilt
-pip install --find-links . teradata_resultset_renderer_prebuilt
-pip install --find-links . teradata_database_explorer_prebuilt
-
-# PIP install the Teradata Python library
-pip install teradataml==17.20.00.04
-
-# Install Teradata R library (optional, uncomment this line only if you use an environment that supports R)
-#Rscript -e "install.packages('tdplyr',repos=c('https://r-repo.teradata.com','https://cloud.r-project.org'))"
-
-# Clone the Teradata lake-demos repository
-su - jupyter -c "git clone https://github.com/Teradata/lake-demos.git"Upload this script to your Google Cloud storage bucket as a file
-
-Access Vertex AI Workbench
-Return to Vertex AI Workbench in Google Cloud console.
-Create a new User-Managed Notebook via Advanced Options or directly at https://notebook.new/.
-Under Details, name your notebook, select your region and select continue.
-
-Under Environment select Browse to select your startup.sh script from your Google Cloud Bucket.
-
-Select Create to initiate the notebook. It may take a few minutes for the notebook creation process to complete. When it is done, click on OPEN JUPYTERLAB.
-
-| - - | -
-
-
-You will have to whitelist this IP in your VantageCloud Lake environment to allow the connection. This solution is appropriate in a trial environment. For production environments, a configuration of VPCs, Subnets, and Security Groups might need to be configured and whitelisted. - |
-
On JupyterLab open a notebook with a Python kernel and run the following command for finding your notebook instance IP address.
-
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)In the VantageCloud Lake environment, under settings, add the IP of your notebook instance
-
-Navigate into the lake-demos directory in your notebook.
-Right click on vars.json to open the file with editor.
-
-Edit the vars.json file file to include the required credentials to run the demos
Variable |
-Value |
-
"host" |
-Public IP value from your VantageCloud Lake environment |
-
"UES_URI" |
-Open Analytics from your VantageCloud Lake environment |
-
"dbc" |
-The master password of your VantageCloud Lake environment. |
-
To retrieve a Public IP address and Open Analytics Endpoint follow these instructions.
-| - - | --Change passwords in the vars.json file.You’ll see that in the sample vars.json, the passwords of all users are defaulted to "password", this is just for matters of the sample file, you should change all of these password fields to strong passwords, secure them as necessary and follow other password management best practices - | -
Execute all the cells in 0_Demo_Environment_Setup.ipynb to setup your environment. Followed by 1_Demo_Setup_Base_Data.ipynb to load the base data required for demo.
-To learn more about the demo notebooks, go to Teradata Lake demos page on GitHub.
-In this quickstart guide, we configured Google Cloud Vertex AI Workbench Notebooks to run Teradata Jupyter Notebook Demos for VantageCloud Lake.
-This quickstart details the process for running the Teradata Jupyter Notebook Demos for VantageCloud Lake, on Amazon SageMaker, the AI/ML platform from AWS.
-Teradata modules for Jupyter (download here, registration required)
-AWS account with access to S3 and SageMaker
-In this section we will cover in detail each of the steps below:
-Upload the Teradata modules for Jupyter to a S3 bucket
-Create an IAM role for your Jupyter notebook instance
-Create a lifecycle configuration for your Jupyter notebook instance
-Create Jupyter notebook instance
-Find the IP CIDR of your Jupyter notebook instance
-On AWS S3 create a bucket and keep note of the assigned name
-Default options are appropiate for this bucket
-In the created bucket upload the Teradata modules for Jupyter
-
-On SageMaker navigate to the role manager
-
-Create a new role (if not already defined)
-For purposes of this guide the role created is assigned the data scientist persona
-
-On the settings, it is appropiate to keep the defaults
-In the corresponding screen define the bucket where you uploaded the Teradata Jupyter modules
-
-In the next configuration we add the corresponding policies for access to the S3 bucket
-
-On SageMaker navigate to lifecycle configurations and click on create
-
-Define a lifecycle configuration with the following scripts
-When working from a Windows environment, we recommend copying the scripts into the lifecycle configuration editor line by line. Press 'Enter' after each line directly in the editor to avoid copying issues. This approach helps prevent carriage return errors that can occur due to encoding differences between Windows and Linux. Such errors often manifest as "/bin/bash^M: bad interpreter" and can disrupt script execution.
-
-On create script:
-#!/bin/bash
-
-set -e
-
-# This script installs a custom, persistent installation of conda on the Notebook Instance's EBS volume, and ensures
-# that these custom environments are available as kernels in Jupyter.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-# Install a separate conda installation via Miniconda
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-mkdir -p "$WORKING_DIR"
-wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
-bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda"
-rm -rf "$WORKING_DIR/miniconda.sh"
-# Create a custom conda environment
-source "$WORKING_DIR/miniconda/bin/activate"
-KERNEL_NAME="teradatasql"
-
-PYTHON="3.8"
-conda create --yes --name "$KERNEL_NAME" python="$PYTHON"
-conda activate "$KERNEL_NAME"
-pip install --quiet ipykernel
-
-EOFOn start script (In this script substitute name of your bucket and confirm version of Jupyter modules)
-#!/bin/bash
-
-set -e
-
-# This script installs Teradata Jupyter kernel and extensions.
-
-
-sudo -u ec2-user -i <<'EOF'
-unset SUDO_UID
-
-WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
-
-source "$WORKING_DIR/miniconda/bin/activate" teradatasql
-
-# Install teradatasql, teradataml, and pandas in the teradatasql environment
-pip install teradataml
-pip install pandas
-
-# fetch Teradata Jupyter extensions package from S3 and unzip it
-mkdir -p "$WORKING_DIR/teradata"
-aws s3 cp s3://resources-jp-extensions/teradatasqllinux_3.4.1-d05242023.zip "$WORKING_DIR/teradata"
-cd "$WORKING_DIR/teradata"
-unzip -o teradatasqllinux_3.4.1-d05242023
-cp teradatakernel /home/ec2-user/anaconda3/condabin
-jupyter kernelspec install --user ./teradatasql
-source /home/ec2-user/anaconda3/bin/activate JupyterSystemEnv
-
-# Install other Teradata-related packages
-pip install teradata_connection_manager_prebuilt-3.4.1.tar.gz
-pip install teradata_database_explorer_prebuilt-3.4.1.tar.gz
-pip install teradata_preferences_prebuilt-3.4.1.tar.gz
-pip install teradata_resultset_renderer_prebuilt-3.4.1.tar.gz
-pip install teradata_sqlhighlighter_prebuilt-3.4.1.tar.gz
-
-conda deactivate
-EOFOn SageMaker navigate Notebooks, Notebook instances, create notebook instance
-Choose a name for your notebook instance, define size (for demos the smaller available instance is enough)
-Click in additional configurations and assign the recently created lifecycle configuration
-
-Click in additional configurations and assign the recently created lifecycle configuration
-Assign the recently created IAM role to the notebook instance
-
-Paste the following link https://github.com/Teradata/lake-demos as the default github repository for the notebook instance
-
-Once the instance is running click on open JupyterLab
-
-
-On JupyterLab open a notebook with Teradata Python kernel and run the following command for finding your notebook instance IP address.
-We will whitelist this IP in your VantageCloud Lake environment in order to allow the connection.
-This is for purposes of this guide and the notebooks demos. For production environments, a configuration of VPCs, Subnets and Security Groups might need to be configured and whitelisted.
-import requests
-def get_public_ip():
- try:
- response = requests.get('https://api.ipify.org')
- return response.text
- except requests.RequestException as e:
- return "Error: " + str(e)
-my_public_ip = get_public_ip()
-print("My Public IP is:", my_public_ip)In the VantageCloud Lake environment, under settings, add the IP of your notebook instance
-
-The file vars.json file should be edited to match the configuration of your VantageCloud Lake environment
-Especifically the following values should be added
-| Variable | -Value | -
|---|---|
"host" |
-Public IP value from your VantageCloud Lake environment |
-
"UES_URI" |
-Open Analytics from your VantageCloud Lake environment |
-
"dbc" |
-The master password of your VantageCloud Lake environment |
-
| - - | --Remember to change all passwords in the vars.json file. - | -
You’ll see that in the sample vars.json, the passwords of all users are defaulted to "password", this is just for illustration purposes, you should change all of these password fields to strong passwords, secure them as necessary, and follow other password management best practices.
-Open and execute all the cells in 0_Demo_Environment_Setup.ipynb to setup your environment. Followed by 1_Demo_Setup_Base_Data.ipynb to load the base data required for demo.
-To learn more about the demo notebooks, go to Teradata Lake demos page on GitHub.
-In this quick start we learned how to run Jupyter notebook demos for VantageCloud Lake in Amazon SageMaker.
-Visual Studio Code is a popular open-source code editor compatible with Windows, MacOs, and Linux. Developers use this Integrated Development Environment (IDE) for coding, debugging, building, and deploying applications. In this quickstart guide, we launch VantageCloud Lake Jupyter notebook demos within Visual Studio Code.
-
-Before you begin, ensure you have the following prerequisites in place:
-Docker Desktop installed
-Git installed
-Required to download git repo from https://github.com/Teradata/lake-demos.git
-Visual Studio Code installed
-A Teradata VantageCloud Lake account with organization URL and login details from the Teradata welcome letter
-Once logged in follow these intructions to create a VantageCloud Lake Enviorment
-Begin by cloning the GitHub repository and navigating to the project directory:
-git clone https://github.com/Teradata/lake-demos.git
-cd lake-demosTo launch Teradata VantageCloud Lake demos, we need the Teradata Jupyter Extensions for Docker. These extensions provide the SQL ipython kernel, utilities to manage connections to Teradata, and the database object explorer to make you productive while interacting with the Teradata database.
-Next, start a container and bind it to the existing lake-demos directory. Choose the appropriate command based on your operating system:
-| - - | --For Windows, run the docker command in PowerShell. - | -
docker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v ${PWD}:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsdocker run -e "accept_license=Y" -p 127.0.0.1:8888:8888 -v $PWD:/home/jovyan/JupyterLabRoot teradata/jupyterlab-extensionsTake note of the resulting URL and token; you’ll need them to establish the connection from Visual Studio Code.
-
-Open lake-demos project directory in Visual Studio Code. The repository contains the following project tree:
LAKE_DEMOS
-Edit the vars.json file file to include the required credentials to run the demos
Variable |
-Value |
-
"host" |
-Public IP value from your VantageCloud Lake environment |
-
"UES_URI" |
-Open Analytics from your VantageCloud Lake environment |
-
"dbc" |
-The master password of your VantageCloud Lake environment. |
-
To retrieve a Public IP address and Open Analytics Endpoint follow these instructions.
-| - - | --Change passwords in the vars.json file. - You’ll see that in the sample vars.json, the passwords of all users are defaulted to "password", this is just for matters of the sample file, you should change all of these password fields to strong passwords, secure them as necessary and follow other password management best practices. - | -
In the UseCases directory, all .ipynb files use the path ../../vars.json to load the variables from the JSON file when working from Jupyterlab. To work directly from Visual Studio Code, update the code in each .ipynb to point to vars.json.
-The quickest way to make these changes is via search feature on the left vertical menu. Search for
-'../../vars.json'-
and replace with:
-'vars.json'-
-
-Open 0_Demo_Environment_Setup.ipynb and click on Select Kernel at the top right corner of Visual Studio Code.
-If you have not installed Jupyter and Python extensions, Visual Studio Code will prompt you to install them. These extensions are necessary for Visual Studio Code to detect Kernels. To install them, select 'Install/Enable suggested extensions for Python and Jupyter.'
-
-Once you’ve installed the necessary extensions, you’ll find options in the drop-down menu. Choose Existing Jupyter Kernel.
-
-Enter the URL of the running Jupyter Server and press enter.
-http://localhost:8888-
-Enter the token found in your terminal when mounting files to the Docker container and press Enter.
-
-Change Server Display Name (Leave Blank To Use URL)
-
-You now have access to all the Teradata Vantage extension kernels. Select Python 3 (ipykernel) from the running Jupyter server.
-
-Execute all the cells in 0_Demo_Environment_Setup.ipynb to setup your environment. Followed by 1_Demo_Setup_Base_Data.ipynb to load the base data required for demo. -To learn more about the demo notebooks, go to Teradata Lake demos page on GitHub.
-
-In this quickstart guide, we configured Visual Studio Code to access VantageCloud Lake demos using Jupyter notebooks.
-