Try it free

Configure TLS certificates and secrets for EdgeConnect

  • Latest Dynatrace
  • How-to guide
  • 4-min read
  • Published Nov 06, 2026

Custom TLS certificates let EdgeConnect reach hosts that don't use publicly trusted certificates. Secrets let apps and workflows send credentials without storing them. Both are optional, and both need two parts:

  • A setting in the EdgeConnect configuration.
  • A file or environment variable in the container.

Where to add the configuration

Where you add certificate_paths and secrets depends on how you deploy EdgeConnect:

  • Docker: the mounted edgeConnect.yaml file. See Deploy EdgeConnect on Docker.
  • Kubernetes without Dynatrace Operator: the edge-connect-config Secret in deployment.yaml. You can't set either one through environment variables or mapped files, so mount the configuration file. See Configure EdgeConnect deployment.
  • Kubernetes with Dynatrace Operator: the EdgeConnect custom resource. See EdgeConnect Operator parameters.

Add custom TLS certificates

Over HTTPS and secure WebSockets, EdgeConnect verifies a host by its certificate and trusts it only if a publicly trusted certificate authority (CA) signed it. Internal services often use a private CA or a self-signed certificate, and an intercepting proxy re-signs traffic with its own certificate. Such connections fail until EdgeConnect trusts the signing certificate.

Add the CA certificate that directly or indirectly signs the host's certificate, not the host certificate itself. EdgeConnect supports PEM (.pem, .crt, .cer) and DER (.der) files.

  1. Add the in-container path to certificate_paths, or set the EDGE_CONNECT_CERTIFICATE_PATHS environment variable. By convention, certificates go in /etc/edge_connect_certs.

    certificate_paths:
    - "/etc/edge_connect_certs/certificate.pem"
  2. Mount the certificate into the container at that path.

    docker run \
    --mount type=bind,src=${PWD}/edgeConnect.yaml,dst=/edgeConnect.yaml \
    -d --restart always \
    -v /host/path/to/certificate.pem:/etc/edge_connect_certs/certificate.pem \
    dynatrace/edgeconnect

    Store the certificate in a Kubernetes Secret.

    kubectl create secret generic edge-connect-certs \
    --from-file=certificate.pem=/path/to/certificate.pem \
    -n dynatrace

    Add these entries to the existing volumeMounts and volumes lists in deployment.yaml. Each key in the Secret becomes a file under the mount path.

    volumeMounts:
    - name: certs
    mountPath: "/etc/edge_connect_certs"
    readOnly: true
    # ...
    volumes:
    - name: certs
    secret:
    secretName: edge-connect-certs
Proxy with TLS interception

If a proxy performs TLS interception, also add the proxy's own certificate to certificate_paths.

For common verification errors, see TLS certificate troubleshooting.

Inject secrets into requests

Apps and workflows need credentials, such as API tokens or passwords, to call services in your network. Anyone who can open or export the app can read a credential stored in it.

Put a placeholder token in the request instead, and define the real value in the EdgeConnect configuration. EdgeConnect replaces the token in query parameters, headers, and bodies immediately before it forwards the request, so the app never holds the value. EdgeConnect rejects a request that carries the token to a host outside restrict_hosts_to.

Each secret needs a generated token, a value the container reads from an environment variable or a file, and a list of allowed hosts.

  1. Add the secrets to the EdgeConnect configuration. Configure exactly one source per secret: from_env or from_file. For the token format and all fields, see Secrets.

    To generate a cryptographically secure token on Linux, run the following command. It requires openssl and the base32 utility, which is part of GNU coreutils and typically preinstalled.

    echo "dt0e01.`openssl rand -out /dev/stdout 15 \
    | base32 \
    | tr '[:lower:]' '[:upper:]'`.`\
    openssl rand -out /dev/stdout 40 \
    | base32 \
    | tr '[:lower:]' '[:upper:]'`"

    The example defines two secrets: one from an environment variable and one from a file, both restricted to hosts in restrict_hosts_to.

    secrets:
    - name: My secret
    token: dt0e01.some-token-name.some-token-secret
    from_env: MY_SECRET
    restrict_hosts_to:
    - dynatrace.com
    - name: My other secret
    token: dt0e01.another-token-name.another-token-secret
    from_file: /path/to/my/other/secret
    restrict_hosts_to:
    - internal.example.com
  2. Provide the values to the container. Mount the file at the from_file path.

    docker run \
    --mount type=bind,src=${PWD}/edgeConnect.yaml,dst=/edgeConnect.yaml \
    -d --restart always \
    -e MY_SECRET=******* \
    -v /host/path/to/my/other/secret:/path/to/my/other/secret \
    dynatrace/edgeconnect

    Store the values in a Kubernetes Secret.

    kubectl create secret generic edge-connect-request-secrets \
    --from-literal=my-secret=******* \
    --from-file=my-other-secret=/path/to/my/other/secret \
    -n dynatrace

    Add these entries to the existing env, volumeMounts, and volumes lists in deployment.yaml.

    env:
    - name: MY_SECRET
    valueFrom:
    secretKeyRef:
    name: edge-connect-request-secrets
    key: my-secret
    volumeMounts:
    - name: request-secrets
    mountPath: "/path/to/my/other/secret"
    subPath: "my-other-secret"
    readOnly: true
    # ...
    volumes:
    - name: request-secrets
    secret:
    secretName: edge-connect-request-secrets

Next steps

For all parameters and environment variables, see EdgeConnect reference.

Related topics

  • Deploy EdgeConnect on Docker
  • Deploy EdgeConnect on Kubernetes without Dynatrace Operator
  • EdgeConnect reference
Related tags
Infrastructure Observability