How to Create an S3 Bucket Using Terraform: From Basic Code Snippet to Advanced Configurations


Amazon S3 is a key player in cloud storage, essential for various applications and data management needs. Managing these resources efficiently is crucial, and Terraform offers a solution. As an infrastructure as code tool, Terraform automates and streamlines the provisioning of resources like S3 buckets, ensuring consistent and manageable cloud infrastructures.

This article guides you through setting up and configuring S3 buckets using Terraform, covering basic setups to advanced configurations, catering to both beginners and experienced practitioners in cloud infrastructure management.

Setting Up Your Environment

To effectively manage AWS resources, including S3 buckets, with Terraform, it is crucial to properly set up and configure Terraform for AWS. This setup is a foundational step that enables you to automate and manage your AWS infrastructure efficiently.

This article assumes you are familar with setting up Terraform. If you’re not familiar with this process, refer to our article on Setting up Terraform for detailed instructions.

How to Create an S3 Bucket Using Terraform: Basic Configuration

Creating an S3 bucket with Terraform is a straightforward process, ideal for those starting with AWS and Terraform. This section guides you through the necessary steps and the basic configuration to get your S3 bucket up and running.

Step 1: Define the Terraform Configuration

Start by creating a Terraform configuration file. This file, typically named, will contain the code that tells Terraform what resources to manage. Here, you’ll define an aws_s3_bucket resource:

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-unique-bucket-name"
  acl    = "private"
  • aws_s3_bucket: This is the Terraform resource type for an S3 bucket.
  • my_bucket: A local name for the resource in your Terraform script.
  • bucket: The globally unique name of your S3 bucket.
  • acl: The access control list setting, private in this case, which restricts access to the bucket owner only.

Step 2: Initialize Terraform

In the directory containing your Terraform configuration file, run the terraform init command. This command initializes Terraform, installs the AWS provider, and prepares your project for Terraform commands.

Step 3: Apply Your Configuration

Execute terraform apply to create the S3 bucket. Terraform will display a plan showing the resources to be created and ask for your approval before proceeding. Once you confirm, Terraform will create the S3 bucket as specified in your configuration.


  • Bucket Naming: Ensure your bucket name is unique across all existing bucket names in Amazon S3. It’s a good practice to use names that are descriptive and adhere to your organization’s naming conventions.
  • Access Control: The acl setting is crucial for defining who can access the bucket. While private is a common setting for restricted access, other options like public-read are available depending on your requirements.

By following these steps, you’ve successfully created a basic S3 bucket using Terraform. This setup serves as a foundation for more advanced configurations and management tasks, which you can build upon as your use case demands.

Advanced S3 Bucket Configurations using Terraform

Enabling Bucket Versioning

Versioning in Amazon S3 is a powerful feature that keeps multiple versions of an object in the same bucket, providing a way to recover from unintended overwrites or deletions. Enabling versioning on your S3 bucket using Terraform involves adding a simple configuration to your existing bucket definition. Here’s how you can do it:

Step 1: Modify Terraform Configuration

To enable versioning, you need to modify the aws_s3_bucket resource in your Terraform configuration file ( Add the versioning block inside your resource definition:

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-unique-bucket-name"
  acl    = "private"

  versioning {
    enabled = true
  • versioning: This block is where you specify versioning settings.
  • enabled: Set this to true to enable versioning on the bucket.

Step 2: Apply the Updated Configuration

Run terraform apply again in your project directory. Terraform will show the changes to be applied, including enabling versioning on the specified bucket. Confirm the action to apply these changes.


  • Data Retrieval: With versioning enabled, all versions of an object are stored. Be aware that this can increase storage costs, as each version is stored as a separate object.
  • Lifecycle Policies: Consider implementing lifecycle policies to manage the retention and deletion of object versions, which can help in controlling costs and maintaining compliance.
  • Disabling Versioning: It’s important to note that once enabled, versioning cannot be fully turned off. You can only suspend it, meaning new objects won’t be versioned, but existing versions will remain.

Implementing Server-Side Encryption for S3 Bucket using Terraform

Server-side encryption (SSE) in Amazon S3 ensures that your data is encrypted at rest, enhancing the security of your stored data. Implementing server-side encryption with Terraform involves specifying additional configuration in your S3 bucket resource. This process is straightforward and can significantly bolster your data security.

Step 1: Update Terraform Configuration

To enable server-side encryption, you need to modify the aws_s3_bucket resource in your Terraform configuration ( This involves adding the server_side_encryption_configuration block to your bucket definition:

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-unique-bucket-name"
  acl    = "private"

  server_side_encryption_configuration {
    rule {
      apply_server_side_encryption_by_default {
        sse_algorithm = "AES256"
  • server_side_encryption_configuration: This block specifies the encryption settings.
  • sse_algorithm: This sets the encryption algorithm, AES256 in this case, which stands for AES-256 encryption. Another common option is aws:kms, which uses AWS Key Management Service for encryption.

Step 2: Apply the Configuration

Run terraform apply in your project directory to apply these changes. Terraform will update your bucket to include the server-side encryption configuration.


  • Encryption Types: AWS offers several encryption options. The two main types are AES256, which is managed by S3, and aws:kms, which allows for more detailed key management and auditing through KMS.
  • Compliance and Security: Using SSE is often a requirement for compliance with various security standards. It’s a best practice to encrypt sensitive data stored in the cloud.
  • Cost Implications: While using AES256 does not incur additional costs, using KMS-managed keys (aws:kms) can have cost implications depending on the usage and the key management features required.

Implementing server-side encryption via Terraform allows you to integrate this crucial security measure into your infrastructure as code strategy. It ensures that all data uploaded to your S3 bucket is automatically encrypted, providing a consistent and automated approach to data security.

Setting Up Bucket Lifecycle Policies using Terraform

Lifecycle policies in Amazon S3 are rules that automatically manage the lifecycle of objects within a bucket, such as transitioning objects to less expensive storage classes or deleting old objects. Implementing these policies through Terraform is an effective way to manage your storage costs and adhere to data retention policies.

Step 1: Define Lifecycle Rules in Terraform Configuration

To set up lifecycle policies, you need to modify your aws_s3_bucket resource in your Terraform configuration file ( Add a lifecycle_rule block to define the rules:

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-unique-bucket-name"
  acl    = "private"

  lifecycle_rule {
    id      = "example-rule"
    enabled = true

    transition {
      days          = 30
      storage_class = "STANDARD_IA"  # Transition to Standard-Infrequent Access

    expiration {
      days = 365  # Delete objects after 1 year
  • lifecycle_rule: This block specifies a lifecycle rule.
  • id: A unique identifier for the rule.
  • enabled: Set this to true to enable the rule.
  • transition: This block defines when objects are transitioned to a different storage class.
  • expiration: This block specifies when objects should be automatically deleted.

Step 2: Apply the Configuration

Run terraform apply in your Terraform project directory. This command will apply the lifecycle rules to your S3 bucket as defined in your configuration.


  • Multiple Rules: You can define multiple lifecycle_rule blocks for different purposes, such as archiving older files or cleaning up incomplete multipart uploads.
  • Storage Classes: Understand the different S3 storage classes (like STANDARD_IA, GLACIER, etc.) and their cost implications and accessibility features.
  • Rule Effects: Be aware that lifecycle rules can result in deletions or transitions that might not be easily reversible. Ensure that your rules align with your data retention and access requirements.

Setting up lifecycle policies for your S3 bucket via Terraform allows for automated and efficient management of your objects, helping to optimize costs and adhere to data policies. It’s an essential aspect of managing S3 buckets, especially for larger or long-lived buckets with significant amounts of data.

Adding Logging Configuration

Access logging in Amazon S3 provides detailed records for the requests made to your S3 bucket, an essential feature for monitoring access and ensuring security compliance. Here’s how you can set up logging for your S3 bucket using Terraform:

Steps to Enable Access Logging

  1. Update Terraform Configuration: Enhance your aws_s3_bucket resource in your Terraform configuration file ( by adding the logging configuration:

    resource "aws_s3_bucket" "my_bucket" {
      bucket = "my-unique-bucket-name"
      acl    = "private"
      logging {
        target_bucket = "my-logging-bucket"
        target_prefix = "log/"
    • logging: This block is where you define the logging configuration.
    • target_bucket: The name of the S3 bucket where you want to store the log files.
    • target_prefix: A prefix for log file names, used to organize logs in the target bucket.
  2. Apply the Configuration: Run terraform apply to enable logging for your S3 bucket.


  • Separate Logging Bucket: It’s a good practice to use a separate bucket for storing logs to avoid mixing log files with other data.
  • Permission Settings: Ensure that the logging target bucket has the necessary permissions to receive log files from other buckets.
  • Monitor Storage: Log files can accumulate and consume significant storage space. Implement lifecycle policies on the logging bucket to manage old log files.

Specifying a Bucket Policy

A bucket policy is a powerful tool to manage access to your S3 bucket. Terraform can be used to specify and apply these policies.

Creating and Applying a Bucket Policy

  1. Define the Policy in Terraform: In your aws_s3_bucket resource, add a policy block. Here’s an example policy that grants read-only access to all objects in the bucket:

    resource "aws_s3_bucket" "my_bucket" {
      bucket = "my-unique-bucket-name"
      acl    = "private"
      policy = <<POLICY
      "Version": "2012-10-17",
      "Statement": [
          "Effect": "Allow",
          "Principal": "*",
          "Action": "s3:GetObject",
          "Resource": "arn:aws:s3:::my-unique-bucket-name/*"

    This policy allows anyone to read objects from the bucket.

  2. Apply the Policy: Execute terraform apply to apply the new bucket policy.


  • Policy Scope: Be cautious with the scope of permissions in your policy. Granting too broad access can lead to security vulnerabilities.
  • Policy Syntax: JSON syntax must be correct in the policy definition. Errors can lead to access issues.

Configuring Cross-Origin Resource Sharing (CORS) while creating S3 Bucket using Terraform

Cross-Origin Resource Sharing (CORS) is a mechanism that allows many resources (e.g., fonts, JavaScript, etc.) on a web page to be requested from another domain outside the domain from which the resource originated.

Setting Up CORS Rules

  1. Update Terraform Configuration: Add a cors_rule block to your aws_s3_bucket resource:

    resource "aws_s3_bucket" "my_bucket" {
      bucket = "my-unique-bucket-name"
      acl    = "private"
      cors_rule {
        allowed_headers = ["*"]
        allowed_methods = ["PUT", "POST"]
        allowed_origins = [""]
        expose_headers  = ["ETag"]
        max_age_seconds = 3000
    • allowed_headers, allowed_methods, allowed_origins: Define which origins, HTTP methods, and headers are allowed.
    • expose_headers: Headers that browsers are allowed to access.
    • max_age_seconds: How long the results of a preflight request can be cached.
  2. Apply the CORS Configuration: Running terraform apply will set the CORS configuration for your bucket.

Understanding CORS Parameters

  • Security Implications: Incorrectly configured CORS policies can expose your resources to cross-site scripting (XSS) attacks.
  • Use Cases: Commonly used in web applications where resources are loaded from multiple domains.
  • Testing: Always test CORS configurations in a safe environment before applying them to production buckets to ensure they work as expected and do not unintentionally block legitimate requests.

Configuring CORS rules, bucket policies, and logging are advanced S3 features that enhance the security, compliance, and usability of your buckets. With Terraform, you can seamlessly integrate these configurations into your IaC workflows, ensuring a robust and secure cloud storage setup.

Best Practices and Considerations

When managing S3 buckets with Terraform, there are several best practices and considerations to keep in mind:

Naming Conventions

  • Uniqueness: Bucket names must be globally unique. Choose names that are descriptive and follow your organizational naming conventions.


  • Access Control: Carefully manage who has access to your buckets. Use IAM roles and policies for fine-grained access control.
  • Encryption: Always consider encrypting sensitive data, both in transit and at rest.

Performance Optimization

  • Storage Classes: Choose appropriate storage classes for your data based on access patterns to optimize costs.
  • Lifecycle Management: Implement lifecycle policies to automate the deletion of old objects and transition to cost-effective storage options.


In this comprehensive guide, we’ve explored how to set up and manage Amazon S3 buckets using Terraform. From basic bucket creation to implementing advanced features like versioning, server-side encryption, and lifecycle policies, we’ve covered a range of topics that provide a solid foundation for efficiently managing cloud storage with Terraform.

As cloud infrastructure continues to evolve, the skills to manage it effectively become increasingly valuable. Terraform, with its powerful and declarative approach to infrastructure as code, is a key tool in any cloud professional’s arsenal. We encourage you to experiment with the different configurations and techniques discussed, and continue exploring Terraform’s capabilities to further enhance your cloud management skills.

FAQ for Setting Up S3 Bucket Using Terraform

What is Terraform and how is it used with Amazon S3?

Answer: Terraform is an open-source infrastructure as code tool used for automating the deployment and management of cloud resources. With Terraform, you can efficiently manage AWS S3 buckets by defining the aws_s3_bucket resource in your configurations. This approach allows you to automate the setup, configuration, and maintenance of Terraform S3 buckets, ensuring a scalable and consistent environment for cloud storage solutions in AWS.

2. How do I create an S3 bucket using Terraform?

Answer: To create an S3 bucket using Terraform, define an aws_s3_bucket resource in your Terraform configuration file with necessary parameters like bucket and acl. Then, run terraform init followed by terraform apply to create the bucket in AWS.

3. Can I enable versioning on an S3 bucket with Terraform?

Answer: Yes, you can enable versioning on an S3 bucket in Terraform by adding the versioning block inside your bucket resource configuration and setting enabled to true.

4. How do I implement server-side encryption for an S3 bucket using Terraform?

Answer: Implement server-side encryption by adding the server_side_encryption_configuration block to your S3 bucket resource in Terraform. Specify the encryption algorithm, such as AES256 or aws:kms, within this block.

5. What are S3 lifecycle policies and how do I set them up in Terraform?

Answer: S3 lifecycle policies are rules to automate managing the lifecycle of objects in a bucket, like transitioning them to different storage classes or deleting old objects. Set these up in Terraform using the lifecycle_rule block within the S3 bucket resource.

6. How can I configure access logging for my S3 bucket in Terraform?

Answer: Configure access logging in Terraform by including a logging block in your S3 bucket resource. Specify the target_bucket for storing log files and a target_prefix for log file names.

7. How do I specify a bucket policy for an S3 bucket in Terraform?

Answer: Specify a bucket policy in Terraform by adding a policy attribute to your S3 bucket resource. Write the policy in JSON format, outlining the permissions and actions allowed for your bucket.

8. What is CORS and how do I configure it for an S3 bucket using Terraform?

Answer: CORS (Cross-Origin Resource Sharing) allows resources on a web page to be requested from another domain. Configure CORS for an S3 bucket in Terraform by adding a cors_rule block to your bucket resource, specifying parameters like allowed_methods and allowed_origins.

9. Are there any best practices for naming S3 buckets in Terraform?

Answer: Yes, it’s important to choose globally unique and descriptive names for your S3 buckets. Stick to your organization’s naming conventions, and avoid using sensitive or personal information in bucket names.