Technical and organisational measures

The Art. 32 GDPR measures, what you configure yourself, and what is not covered.

What it is

The measures Deutsche Cloud takes to protect the personal data you store on the platform, in the order of Art. 32 GDPR. Each measure says what the platform does and, where it applies, what you have to switch on or do yourself. Every statement describes the platform as it runs today.

This page is a description, not a contract. The version that binds us is the TOM annex of the data processing agreement (DPA, German: AVV) you sign; it is taken from this page with a date. To request the DPA, write to info@deutschlandgpt.de.

Last reviewed: 13 November 2026.

Concepts

Term Meaning
Platform key The installation's master key. It wraps (encrypts) every other key Deutsche Cloud holds unless you choose your own key.
Customer-managed key A KMS key in your organization (kms:*). You control who may use it, can disable it and can schedule its deletion.
Control plane The console, the API, IAM, the audit log and the services that create and manage your resources.
Managed machine A machine Deutsche Cloud creates and runs for you: database, cache, Kubernetes, file storage, VPN and NAT nodes, and app boxes.
Your instance A virtual machine you create with Compute. You hold root on it and run it yourself.

1. Confidentiality

1.1 Physical access to data centres (Zutrittskontrolle)

Deutsche Cloud runs on Hetzner Online GmbH's data centres in Falkenstein and Nuremberg, Germany. Physical security (perimeter, entry control, video surveillance, power, cooling, fire protection, hardware disposal) is Hetzner's and covered by Hetzner's ISO/IEC 27001:2022 certificate and BSI C5:2020 Type 2 attestation. See Sub-processors. Deutsche Cloud staff have no physical access to the hardware.

1.2 Access to systems (Zugangskontrolle)

Sign-in to the console:

  • Passwords are at least 8 characters with an upper-case letter and a digit, and are stored as salted scrypt hashes. Only a hash of each session token is stored.
  • Two-factor sign-in with an authenticator app (TOTP) and ten single-use recovery codes, or a passkey (WebAuthn) as the second factor.
  • An organization can require two-factor sign-in for every member (organization Settings). Members without it are sent to set it up and cannot use the console until they have. Access keys are not affected by this setting.
  • Single sign-on with your OIDC or SAML 2.0 identity provider, enforced for your verified domains. Sign-ins through SSO count as two-factor; your identity provider enforces MFA.
  • Sign-in attempts are rate-limited per e-mail address and per IP address.
  • Session cookies are HttpOnly, Secure and __Host- prefixed. A session expires after 7 days without use and at most after 30 days.

Programmatic access:

  • Access keys are shown once; the platform stores only a hash of the secret.
  • Every access key expires: by default after 90 days, at most after the organization's maximum (365 days by default, settable from 1 to 3650). The CLI's sign-in key expires after 90 days or the maximum, whichever is shorter. An expired key is refused and stays listed as expired.
  • GitHub Actions can exchange its OIDC token for credentials valid for at most one hour, so no long-lived key is stored in CI.
  • An AI assistant connected over MCP gets a one-hour token, limited to the scopes and permissions of the person who approved it.

Your part: turn on the two-factor requirement or SSO enforcement; give access keys an owner, set the lifetime your policy requires (Settings → Access keys) and rotate them before they expire. Keys made before 2026-11-13 have no expiry until you give them one there.

1.3 Access to data (Zugriffskontrolle)

  • Every request, from the console, API, CLI, MCP, Terraform, Git, the registries and the S3 gateway, is decided by one IAM policy engine. Nothing is allowed unless a policy allows it, and an explicit deny always wins. The organization owner holds a policy like every other user; there is no built-in bypass.
  • Policies are attached to users, groups and roles and name actions and resources. Conditions can require a source IP range, a time window, a two-factor sign-in, a region or a zone; a condition that cannot be evaluated fails closed.
  • Preset roles (Admin, PowerUser, Developer, ReadOnly, Billing). The read-only presets exclude reads of secret values and source code.
  • Managed databases and caches have no public interface by default. People reach them through the managed Client VPN, one granted target at a time.
  • Secrets are only returned to the apps, workflows or machines they are granted to; every reveal is logged.

Deutsche Cloud operations staff reach the control plane through the same IAM engine, with permissions held in the platform's own organization, which a customer cannot grant. These actions are recorded in Deutsche Cloud's own audit log.

Staff reach a managed machine (database, cache, Kubernetes, VPN, NAT, file-system, function and app machines) over SSH only for break-glass support, and only like this:

  • There is no shared key. A member of staff signed in with a second factor asks for an SSH certificate for one named machine, giving a reason. It is valid for 15 minutes, only from the control plane's address, with no agent or port forwarding.
  • Managed machines trust only the installation's certificate authority, for their own name; keys in authorized_keys and passwords are not accepted. Port 22 admits only the control plane.
  • Every certificate is recorded before it is issued, in Deutsche Cloud's audit log and in your organization's audit log (operator:IssueSshCertificate: who, which machine, why, valid until). The machine's SSH log records each login with the same identity.

Machines created before 2026-11-13 still accept the earlier operator key until they are replaced; their port 22 is narrowed to the control plane as their firewall is next reconciled. Your own instances are created with only the SSH keys you choose and never trust the staff authority.

Your part: grant least privilege; review who has which policy.

1.4 Separation (Trennungskontrolle)

  • Every resource belongs to one organization. The organization is taken from the verified session or access key, never from the request.
  • Each VPC is its own private network. Managed machines get firewalls that admit only the traffic their service needs.
  • Each build and each CI run gets a fresh machine that is deleted afterwards, with credentials scoped to that run.
  • You can run machines in a Hetzner project of your own instead of Deutsche Cloud's.
  • Projects, VPCs and environments separate development, test and production inside an organization.

1.5 Encryption and pseudonymisation

At rest:

Data Encryption
Disks of managed PostgreSQL, Valkey, file storage LUKS2, AES-256-XTS, one key per disk, always on
Compute volumes LUKS2, AES-256-XTS, on by default (can be turned off at creation)
Kubernetes persistent volumes LUKS2, on by default (a StorageClass can turn it off); Kubernetes Secrets are encrypted through KMS
Buckets Each bucket has its own 256-bit key; objects written through Deutsche Cloud are stored encrypted at Hetzner
Database backups and archived WAL AES-256 on the database machine before upload, one key per database
Cache snapshots AES-256 on the cache machine before upload, one key per snapshot
Secrets AES-256-GCM under a customer-managed key
  • Disk, bucket and backup keys are wrapped by the platform key or, if you choose one, by your customer-managed key. While your key is disabled, a disk under it does not open when its machine starts.
  • A disk key is released only to the machine the disk is attached to, checked against the provider's records and the request's source address. It is passed to the disk encryption and never written to the machine's storage.
  • On an organization's own hosts (a rack behind NAT) a disk key never crosses a network: it is handed to the machine through the site's hypervisor, and only after the hypervisor confirms that the disk is attached to that running machine, and that the host answers with the identity confirmed for the site (hypervisor certificate and name, hardware serials). The platform stops releasing keys on a site by itself when its host answers with another identity or returns after an outage longer than the site's threshold (6 hours by default), until the operator confirms the site; the operator can also suspend it for a site whose hardware is lost. It does not protect against root on the rack's host or the holder of the site's hypervisor credential.
  • Deleting a disk deletes its key.
  • Keys can be rotated per disk; the platform key can be rotated by the operator.

In transit:

  • TLS for the console, API, Git over HTTPS, the registries and your apps' domains, with certificates issued automatically. HSTS, a Content Security Policy and frame denial on the console.
  • Managed PostgreSQL requires TLS by default, with certificates from the platform's own CA so sslmode=verify-full works. Managed Valkey serves TLS only by default.
  • Git over SSH accepts public keys only and modern ciphers only.
  • Client VPN uses WireGuard.

Your part: keep TLS required on databases and caches; choose a customer-managed key if you want to be able to revoke access to your data yourself.

2. Integrity

2.1 Transfer control (Weitergabekontrolle)

  • Data travels over TLS or WireGuard as listed above.
  • Machines that report to the control plane authenticate with a token scoped to that one resource.
  • Exports leave the platform only through actions your IAM policies allow (S3, Git, registry pulls, database dumps), and the sensitive ones are in the audit log.

2.2 Input control (Eingabekontrolle)

  • The audit log records every change, every refusal of a change, every read of secret values or source code, and sign-in events (success, failure, two-factor, password and session changes). Each entry names the principal, the access key or session, the source IP address and user agent, the action, the resource, the request and the result.
  • Entries of each organization form a SHA-256 hash chain, and the head of the chain is signed with Ed25519 every hour. Anyone with the public key can check that no entry was changed, removed or inserted.
  • Entries are kept for 400 days by default; you can choose 90 to 3,650 days. They can be streamed to your own bucket, webhook or syslog server, and exported as JSON lines or CSV.

Your part: set the retention your obligations require; stream the log to storage you control if you need it beyond that.

3. Availability and resilience

3.1 Availability control (Verfügbarkeitskontrolle)

  • Managed PostgreSQL as a three-node cluster with automatic failover, nodes spread over both zones, synchronous commit by default. Up to five read replicas.
  • Managed Valkey with up to two replicas and automatic failover.
  • Backups of managed PostgreSQL: a daily full backup plus WAL archived at least every five minutes, kept 0 to 35 days (default 7), restorable to any second in that window.
  • Cache snapshots daily, kept 7 days. Volume snapshot schedules with a retention count you set.
  • Bucket versioning and object lock, if you turn them on.
  • Deletion protection for databases.
  • Operating-system security updates are installed automatically on managed machines.

Your part: choose a cluster where you need failover; set backup retention; turn on versioning or object lock for buckets that need it; snapshot your own instances.

3.2 Recovery (rasche Wiederherstellbarkeit)

  • Point-in-time restore of databases into a new database.
  • A disk that loses its machine is reattached to a replacement machine.
  • The platform database is backed up nightly, encrypted, and kept 30 nights, plus a separate daily backup kept 14 days. The restore procedure is documented and has been rehearsed.

4. Regular review

  • Every image pushed to the container registry is scanned for known vulnerabilities, and the findings are shown next to the tag.
  • The platform's own dependencies are checked against vulnerability databases every six hours and on every change; updates are proposed automatically.
  • Every change to the platform runs automated checks (type checks, tests, IAM invariants). A change is deployed automatically only when its checks passed; production releases are started by hand.
  • Security reports: /.well-known/security.txt names the contact.

5. Processor control (Auftragskontrolle)

  • Deutsche Cloud processes your data only to provide the service and on your instructions as set in the DPA.
  • Sub-processors are listed on Sub-processors, with their certificates.

What is not covered

  • Root disks of your instances are not encrypted by Deutsche Cloud. Keep data that needs encryption on an encrypted volume.
  • The storage behind Git repositories, the container and npm registries, CI logs and CI caches is not encrypted by Deutsche Cloud; it is held at Hetzner in Germany.
  • Kubernetes control-plane disks (etcd) are not encrypted, apart from Secrets.
  • Objects that were in a bucket before bucket encryption existed stay as they were until they are written again.
  • Keys are held in software under the platform key. There is no hardware security module.
  • Staff SSH sessions are recorded as the certificate that opened them (who, which machine, why, until when) and in the machine's own SSH log; what was typed during a session is not recorded.
  • Access keys made before 2026-11-13 have no expiry until the organization gives them one.
  • Nothing is sent to the assistant's model unless someone opens the assistant and sends a message; an organization can switch the assistant off (Account → AI settings). The assistant uses DeutschlandGPT's model API; the models it can reach are set on the platform's API key, Deutsche Cloud offers only those the API reports as hosted in Germany or the EU, and the organization picks one there (default Auto).
  • There is no single export of everything in an organization; data leaves through each service's own interface (Git, registry, S3, database dumps, DNS zone export).
Did this page help you?