How to Configure Teradata Proxy

Published
Length
3 min read

Luis Felipe Dias

All posts

You set up a teradata proxy by granting connect-through rights to a service account. This setup lets a middle-tier app log in and act on behalf of a specific user. Many data teams start by sharing one broad database login across an entire reporting tool. That shortcut hides who ran each query and gives every user the same wide permissions. How the native teradata proxy feature works In a standard setup, business apps use a single pool of database sessions. Without connect-through rules, the d

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

You set up a teradata proxy by granting connect-through rights to a service account. This setup lets a middle-tier app log in and act on behalf of a specific user. Many data teams start by sharing one broad database login across an entire reporting tool. That shortcut hides who ran each query and gives every user the same wide permissions.

How the native teradata proxy feature works

In a standard setup, business apps use a single pool of database sessions. Without connect-through rules, the database only sees the app account name in its system logs. Native connect-through rules fix this problem by separating the session owner from the active user.

First, an admin creates a trusted service account for the middle-tier reporting app. Next, the admin grants that service account permission to switch into specific end-user profiles. The admin can also assign a set of database roles to that connect-through rule.

When a person opens a dashboard, the app logs in with its own service credentials. The app then sends a statement that sets the query band to the human user. The database checks the connect-through rule and applies the human user's permissions to the session. When the task finishes, the app clears the user name and reuses the open session.

Where native connect-through rules fall short

Native connect-through rules solve the shared account problem inside the data warehouse. Database logs now record both the middle-tier app name and the actual human user. You can also restrict which tables a person can read through that specific reporting tool.

Still, this native feature only controls who starts a session and which role applies. It does not inspect individual statements in flight or pause risky queries for a review. Once a user enters a valid session, they can run any command their role allows.

Engineers and analysts still need direct database access for ad-hoc checks and schema fixes. Connect-through rules are built for middle-tier apps, not for people using desktop query tools. Teams end up managing static passwords on engineer laptops and building custom scripts for reviews.

Database Proxy (ProxySQL, PgBouncer) + End-to-End Encryption: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Also, native role rules apply at the table or view level. If an analyst queries a customer table, the database returns every column in that view. Protecting sensitive fields like emails, phone numbers, or card numbers requires extra custom database views. Creating and updating those views across dozens of schemas adds heavy work for database admins.

Managing direct database sessions for engineers

To close these gaps, teams must separate app connection pools from human database sessions. Middle-tier apps can keep using native connect-through rules to manage their internal session pools. Human engineers and automated scripts need a more direct way to log in safely.

Instead of distributing static database accounts, teams should link database logins to their identity provider. Each query should pass through a check that evaluates the statement before it runs. Dynamic data masking can then rewrite sensitive fields in the query results on the fly. This approach keeps audit logs accurate and protects raw data without building extra database views.

Add runtime guardrails and masking beside your databases and APIs

Login rules, role grants, and CI checks govern who connects to your stack. Yet any allowed script, engineer, or AI agent still runs commands with the full scope of its role. For workloads on Postgres, MySQL, SQL Server, MongoDB, ClickHouse, Kubernetes, SSH, or internal HTTP services, hoop.dev sits inline in the protocol beside the service as an open-source proxy, a sidecar for your database or API. On every production query an agent or human runs, hoop.dev decides whether to pass, mask, block, or escalate it for review.

Before a query runs, hoop.dev guardrails check the statement against your rules, an AI Analyzer you configure can score intent or hold risky calls for human approval, and hoop.dev data masking rewrites sensitive fields in responses in memory. Explore the MIT-licensed project on GitHub.

Frequently asked questions

What is the difference between a permanent user and an application user in Teradata?

A permanent user has a full database account with its own profile and permissions. An app user exists only in the query band and inherits roles from the rule.

Does connect-through access hide sensitive columns from analysts automatically?

No, connect-through rules only assign database roles to the active session. To hide emails or card numbers natively, you must build separate restricted views first.

How do you audit queries that run through a middle-tier connection pool?

When you enable query logging, the database records both the trusted app account and the proxy user. This dual record shows which human ran a query through the shared pool.

Short role checks help teams work fast. Simple rules make each review clear. Good logs keep every team safe. Scoped keys stop bad changes early.

The query runs. The emails stay hidden.