<!doctype html>
<html lang="en" dir="ltr" class="docs-wrapper docs-doc-page docs-version-current plugin-docs plugin-id-default docs-doc-id-development/extensions-core/s3">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.1">
<title data-rh="true">S3-compatible | Apache® Druid</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" name="twitter:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" property="og:url" content="https://druid.apache.org/docs/latest/development/extensions-core/s3"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docusaurus_version" content="current"><meta data-rh="true" name="docusaurus_tag" content="docs-default-current"><meta data-rh="true" name="docsearch:version" content="current"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-current"><meta data-rh="true" property="og:title" content="S3-compatible | Apache® Druid"><meta data-rh="true" name="description" content="&lt;!--"><meta data-rh="true" property="og:description" content="&lt;!--"><link data-rh="true" rel="icon" href="/img/favicon.png"><link data-rh="true" rel="canonical" href="https://druid.apache.org/docs/latest/development/extensions-core/s3"><link data-rh="true" rel="alternate" href="https://druid.apache.org/docs/latest/development/extensions-core/s3" hreflang="en"><link data-rh="true" rel="alternate" href="https://druid.apache.org/docs/latest/development/extensions-core/s3" hreflang="x-default"><link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-131010415-1"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","UA-131010415-1",{})</script>




<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.4/clipboard.min.js"></script><link rel="stylesheet" href="/assets/css/styles.546f39eb.css">
<link rel="preload" href="/assets/js/runtime~main.4c9a7172.js" as="script">
<link rel="preload" href="/assets/js/main.3a5ab01b.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top navbar--dark"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--dark_i4oU"></div></a></div><div class="navbar__items navbar__items--right"><a class="navbar__item navbar__link" href="/technology">Technology</a><a class="navbar__item navbar__link" href="/use-cases">Use Cases</a><a class="navbar__item navbar__link" href="/druid-powered">Powered By</a><a class="navbar__item navbar__link" href="/docs/latest/design/">Docs</a><a class="navbar__item navbar__link" href="/community/">Community</a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Apache®</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://apachecon.com/?ref=druid.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><a class="navbar__item navbar__link" href="/downloads/">Download</a><div class="searchBox_ZlJk"><div class="navbar__search"><span aria-label="expand searchbar" role="button" class="search-icon" tabindex="0"></span><input type="search" id="search_input_react" placeholder="Loading..." aria-label="Search" class="navbar__search-input search-bar" disabled=""></div></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0 docsWrapper_BCFX"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type="button"></button><div class="docPage__5DB"><main class="docMainContainer_gTbr docMainContainerEnhanced_Uz_u"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_VOVn"><div class="docItemContainer_Djhp"><article><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type="button" class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>S3-compatible</h1></header><h2 class="anchor anchorWithStickyNavbar_LWe7" id="s3-extension">S3 extension<a href="#s3-extension" class="hash-link" aria-label="Direct link to S3 extension" title="Direct link to S3 extension">​</a></h2><p>This extension allows you to do 2 things:</p><ul><li><a href="#reading-data-from-s3">Ingest data</a> from files stored in S3.</li><li>Write segments to <a href="#deep-storage">deep storage</a> in S3.</li></ul><p>To use this Apache Druid extension, <a href="/docs/latest/configuration/extensions#loading-extensions">include</a> <code>druid-s3-extensions</code> in the extensions load list.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="reading-data-from-s3">Reading data from S3<a href="#reading-data-from-s3" class="hash-link" aria-label="Direct link to Reading data from S3" title="Direct link to Reading data from S3">​</a></h3><p>Use a native batch <a href="/docs/latest/ingestion/native-batch">Parallel task</a> with an <a href="/docs/latest/ingestion/input-sources#s3-input-source">S3 input source</a> to read objects directly from S3.</p><p>Alternatively, use a <a href="/docs/latest/ingestion/hadoop">Hadoop task</a>,
and specify S3 paths in your <a href="/docs/latest/ingestion/hadoop#inputspec"><code>inputSpec</code></a>.</p><p>To read objects from S3, you must supply <a href="#configuration">connection information</a> in configuration.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="deep-storage">Deep Storage<a href="#deep-storage" class="hash-link" aria-label="Direct link to Deep Storage" title="Direct link to Deep Storage">​</a></h3><p>S3-compatible deep storage means either AWS S3 or a compatible service like Google Storage which exposes the same API as S3.</p><p>S3 deep storage needs to be explicitly enabled by setting <code>druid.storage.type=s3</code>. <strong>Only after setting the storage type to S3 will any of the settings below take effect.</strong></p><p>To use S3 for Deep Storage, you must supply <a href="#configuration">connection information</a> in configuration <em>and</em> set additional configuration, specific for <a href="#deep-storage-specific-configuration">Deep Storage</a>.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="deep-storage-specific-configuration">Deep storage specific configuration<a href="#deep-storage-specific-configuration" class="hash-link" aria-label="Direct link to Deep storage specific configuration" title="Direct link to Deep storage specific configuration">​</a></h4><table><thead><tr><th>Property</th><th>Description</th><th>Default</th></tr></thead><tbody><tr><td><code>druid.storage.bucket</code></td><td>Bucket to store in.</td><td>Must be set.</td></tr><tr><td><code>druid.storage.baseKey</code></td><td>A prefix string that will be prepended to the object names for the segments published to S3 deep storage</td><td>Must be set.</td></tr><tr><td><code>druid.storage.type</code></td><td>Global deep storage provider. Must be set to <code>s3</code> to make use of this extension.</td><td>Must be set (likely <code>s3</code>).</td></tr><tr><td><code>druid.storage.archiveBucket</code></td><td>S3 bucket name for archiving when running the <em>archive task</em>.</td><td>none</td></tr><tr><td><code>druid.storage.archiveBaseKey</code></td><td>S3 object key prefix for archiving.</td><td>none</td></tr><tr><td><code>druid.storage.disableAcl</code></td><td>Boolean flag for how object permissions are handled. To use ACLs, set this property to <code>false</code>. To use Object Ownership, set it to <code>true</code>. The permission requirements for ACLs and Object Ownership are different. For more information, see <a href="#s3-permissions-settings">S3 permissions settings</a>.</td><td>false</td></tr><tr><td><code>druid.storage.useS3aSchema</code></td><td>If true, use the &quot;s3a&quot; filesystem when using Hadoop-based ingestion. If false, the &quot;s3n&quot; filesystem will be used. Only affects Hadoop-based ingestion.</td><td>false</td></tr></tbody></table><h2 class="anchor anchorWithStickyNavbar_LWe7" id="configuration">Configuration<a href="#configuration" class="hash-link" aria-label="Direct link to Configuration" title="Direct link to Configuration">​</a></h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="s3-authentication-methods">S3 authentication methods<a href="#s3-authentication-methods" class="hash-link" aria-label="Direct link to S3 authentication methods" title="Direct link to S3 authentication methods">​</a></h3><p>You can provide credentials to connect to S3 in a number of ways, whether for <a href="#deep-storage">deep storage</a> or as an <a href="#reading-data-from-s3">ingestion source</a>.</p><p>The configuration options are listed in order of precedence.  For example, if you would like to use profile information given in <code>~/.aws/credentials</code>, do not set <code>druid.s3.accessKey</code> and <code>druid.s3.secretKey</code> in your Druid config file because they would take precedence.</p><table><thead><tr><th>order</th><th>type</th><th>details</th></tr></thead><tbody><tr><td>1</td><td>Druid config file</td><td>Based on your runtime.properties if it contains values <code>druid.s3.accessKey</code> and <code>druid.s3.secretKey</code></td></tr><tr><td>2</td><td>Custom properties file</td><td>Based on custom properties file where you can supply <code>sessionToken</code>, <code>accessKey</code> and <code>secretKey</code> values. This file is provided to Druid through <code>druid.s3.fileSessionCredentials</code> properties</td></tr><tr><td>3</td><td>Environment variables</td><td>Based on environment variables <code>AWS_ACCESS_KEY_ID</code> and <code>AWS_SECRET_ACCESS_KEY</code></td></tr><tr><td>4</td><td>Java system properties</td><td>Based on JVM properties <code>aws.accessKeyId</code> and <code>aws.secretKey</code></td></tr><tr><td>5</td><td>Profile information</td><td>Based on credentials you may have on your druid instance (generally in <code>~/.aws/credentials</code>)</td></tr><tr><td>6</td><td>ECS container credentials</td><td>Based on environment variables available on AWS ECS (AWS_CONTAINER_CREDENTIALS_RELATIVE_URI or AWS_CONTAINER_CREDENTIALS_FULL_URI) as described in the <a href="https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/EC2ContainerCredentialsProviderWrapper.html" target="_blank" rel="noopener noreferrer">EC2ContainerCredentialsProviderWrapper documentation</a></td></tr><tr><td>7</td><td>Instance profile information</td><td>Based on the instance profile you may have attached to your druid instance</td></tr></tbody></table><p>For more information, refer to the <a href="https://docs.aws.amazon.com/fr_fr/sdk-for-java/v1/developer-guide/credentials" target="_blank" rel="noopener noreferrer">Amazon Developer Guide</a>.</p><p>Alternatively, you can bypass this chain by specifying an access key and secret key using a <a href="/docs/latest/ingestion/input-sources#s3-input-source">Properties Object</a> inside your ingestion specification.</p><p>Use the property <a href="/docs/latest/configuration/#startup-logging"><code>druid.startup.logging.maskProperties</code></a> to mask credentials information in Druid logs. For example, <code>[&quot;password&quot;, &quot;secretKey&quot;, &quot;awsSecretAccessKey&quot;]</code>.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="s3-permissions-settings">S3 permissions settings<a href="#s3-permissions-settings" class="hash-link" aria-label="Direct link to S3 permissions settings" title="Direct link to S3 permissions settings">​</a></h3><p>To manage the permissions for objects in an S3 bucket, you can use either ACLs or Object Ownership. The permissions required for each method are different.</p><p>By default, Druid uses ACLs. With ACLs, any object that Druid puts into the bucket inherits the ACL settings from the bucket.</p><p>You can switch from using ACLs to Object Ownership by setting <code>druid.storage.disableAcl</code> to <code>true</code>. The bucket owner owns any object that gets created, so you need to use S3&#x27;s bucket policies to manage permissions.</p><p>Note that this setting only affects Druid&#x27;s behavior. Changing S3 to use Object Ownership requires additional configuration. For more information, see the AWS documentation on <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html" target="_blank" rel="noopener noreferrer">Controlling ownership of objects and disabling ACLs for your bucket</a>.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="acl-permissions">ACL permissions<a href="#acl-permissions" class="hash-link" aria-label="Direct link to ACL permissions" title="Direct link to ACL permissions">​</a></h4><p>If you&#x27;re using ACLs, Druid needs the following permissions:</p><ul><li><code>s3:GetObject</code></li><li><code>s3:PutObject</code></li><li><code>s3:DeleteObject</code></li><li><code>s3:GetBucketAcl</code></li><li><code>s3:PutObjectAcl</code></li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="object-ownership-permissions">Object Ownership permissions<a href="#object-ownership-permissions" class="hash-link" aria-label="Direct link to Object Ownership permissions" title="Direct link to Object Ownership permissions">​</a></h4><p>If you&#x27;re using Object Ownership, Druid needs the following permissions:</p><ul><li><code>s3:GetObject</code></li><li><code>s3:PutObject</code></li><li><code>s3:DeleteObject</code></li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="aws-region">AWS region<a href="#aws-region" class="hash-link" aria-label="Direct link to AWS region" title="Direct link to AWS region">​</a></h3><p>The AWS SDK requires that a target region be specified.  You can set these by using the JVM system property <code>aws.region</code> or by setting an environment variable <code>AWS_REGION</code>.</p><p>For example, to set the region to &#x27;us-east-1&#x27; through system properties:</p><ul><li>Add <code>-Daws.region=us-east-1</code> to the <code>jvm.config</code> file for all Druid services.</li><li>Add <code>-Daws.region=us-east-1</code> to <code>druid.indexer.runner.javaOpts</code> in <a href="/docs/latest/configuration/#middlemanager-configuration">Middle Manager configuration</a> so that the property will be passed to Peon (worker) processes.</li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="connecting-to-s3-configuration">Connecting to S3 configuration<a href="#connecting-to-s3-configuration" class="hash-link" aria-label="Direct link to Connecting to S3 configuration" title="Direct link to Connecting to S3 configuration">​</a></h3><table><thead><tr><th>Property</th><th>Description</th><th>Default</th></tr></thead><tbody><tr><td><code>druid.s3.accessKey</code></td><td>S3 access key. See <a href="#s3-authentication-methods">S3 authentication methods</a> for more details</td><td>Can be omitted according to authentication methods chosen.</td></tr><tr><td><code>druid.s3.secretKey</code></td><td>S3 secret key. See <a href="#s3-authentication-methods">S3 authentication methods</a> for more details</td><td>Can be omitted according to authentication methods chosen.</td></tr><tr><td><code>druid.s3.fileSessionCredentials</code></td><td>Path to properties file containing <code>sessionToken</code>, <code>accessKey</code> and <code>secretKey</code> value. One key/value pair per line (format <code>key=value</code>). See <a href="#s3-authentication-methods">S3 authentication methods</a> for more details</td><td>Can be omitted according to authentication methods chosen.</td></tr><tr><td><code>druid.s3.protocol</code></td><td>Communication protocol type to use when sending requests to AWS. <code>http</code> or <code>https</code> can be used. This configuration would be ignored if <code>druid.s3.endpoint.url</code> is filled with a URL with a different protocol.</td><td><code>https</code></td></tr><tr><td><code>druid.s3.disableChunkedEncoding</code></td><td>Disables chunked encoding. See <a href="https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/AmazonS3Builder.html#disableChunkedEncoding--" target="_blank" rel="noopener noreferrer">AWS document</a> for details.</td><td>false</td></tr><tr><td><code>druid.s3.enablePathStyleAccess</code></td><td>Enables path style access. See <a href="https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/AmazonS3Builder.html#enablePathStyleAccess--" target="_blank" rel="noopener noreferrer">AWS document</a> for details.</td><td>false</td></tr><tr><td><code>druid.s3.forceGlobalBucketAccessEnabled</code></td><td>Enables global bucket access. See <a href="https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/AmazonS3Builder.html#setForceGlobalBucketAccessEnabled-java.lang.Boolean-" target="_blank" rel="noopener noreferrer">AWS document</a> for details.</td><td>false</td></tr><tr><td><code>druid.s3.endpoint.url</code></td><td>Service endpoint either with or without the protocol.</td><td>None</td></tr><tr><td><code>druid.s3.endpoint.signingRegion</code></td><td>Region to use for SigV4 signing of requests (e.g. us-west-1).</td><td>None</td></tr><tr><td><code>druid.s3.proxy.host</code></td><td>Proxy host to connect through.</td><td>None</td></tr><tr><td><code>druid.s3.proxy.port</code></td><td>Port on the proxy host to connect through.</td><td>None</td></tr><tr><td><code>druid.s3.proxy.username</code></td><td>User name to use when connecting through a proxy.</td><td>None</td></tr><tr><td><code>druid.s3.proxy.password</code></td><td>Password to use when connecting through a proxy.</td><td>None</td></tr><tr><td><code>druid.storage.sse.type</code></td><td>Server-side encryption type. Should be one of <code>s3</code>, <code>kms</code>, and <code>custom</code>. See the below <a href="#server-side-encryption">Server-side encryption section</a> for more details.</td><td>None</td></tr><tr><td><code>druid.storage.sse.kms.keyId</code></td><td>AWS KMS key ID. This is used only when <code>druid.storage.sse.type</code> is <code>kms</code> and can be empty to use the default key ID.</td><td>None</td></tr><tr><td><code>druid.storage.sse.custom.base64EncodedKey</code></td><td>Base64-encoded key. Should be specified if <code>druid.storage.sse.type</code> is <code>custom</code>.</td><td>None</td></tr></tbody></table><h2 class="anchor anchorWithStickyNavbar_LWe7" id="server-side-encryption">Server-side encryption<a href="#server-side-encryption" class="hash-link" aria-label="Direct link to Server-side encryption" title="Direct link to Server-side encryption">​</a></h2><p>You can enable <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption" target="_blank" rel="noopener noreferrer">server-side encryption</a> by setting
<code>druid.storage.sse.type</code> to a supported type of server-side encryption. The current supported types are:</p><ul><li>s3: <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption" target="_blank" rel="noopener noreferrer">Server-side encryption with S3-managed encryption keys</a></li><li>kms: <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption" target="_blank" rel="noopener noreferrer">Server-side encryption with AWS KMS–Managed Keys</a></li><li>custom: <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys" target="_blank" rel="noopener noreferrer">Server-side encryption with Customer-Provided Encryption Keys</a></li></ul></div></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages"></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#s3-extension" class="table-of-contents__link toc-highlight">S3 extension</a><ul><li><a href="#reading-data-from-s3" class="table-of-contents__link toc-highlight">Reading data from S3</a></li><li><a href="#deep-storage" class="table-of-contents__link toc-highlight">Deep Storage</a></li></ul></li><li><a href="#configuration" class="table-of-contents__link toc-highlight">Configuration</a><ul><li><a href="#s3-authentication-methods" class="table-of-contents__link toc-highlight">S3 authentication methods</a></li><li><a href="#s3-permissions-settings" class="table-of-contents__link toc-highlight">S3 permissions settings</a></li><li><a href="#aws-region" class="table-of-contents__link toc-highlight">AWS region</a></li><li><a href="#connecting-to-s3-configuration" class="table-of-contents__link toc-highlight">Connecting to S3 configuration</a></li></ul></li><li><a href="#server-side-encryption" class="table-of-contents__link toc-highlight">Server-side encryption</a></li></ul></div></div></div></div></main></div></div><footer class="footer"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></div><div class="footer__copyright">Copyright © 2023 Apache Software Foundation. Except where otherwise noted, licensed under CC BY-SA 4.0. Apache Druid, Druid, and the Druid logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</div></div></div></footer></div>
<script src="/assets/js/runtime~main.4c9a7172.js"></script>
<script src="/assets/js/main.3a5ab01b.js"></script>
</body>
</html>