Amazon S3 desde cero: tu primer paso en el almacenamiento en la nube ☁️
Learn Amazon S3 through a simple mental model that connects buckets, objects, permissions, regions, storage classes, and real-world use cases without unnecessary complexity.
☁️ Amazon S3 is not just “a place to store files”
When people first learn AWS, Amazon S3 is usually explained like this:
“S3 is cloud storage.”
That is correct.
But it is also incomplete.
If you only think of Amazon S3 as a folder in the cloud, you may understand how to upload a file, but you will not fully understand why S3 is used in websites, backups, data platforms, mobile applications, machine learning workflows, static websites, logs, and large-scale systems.
A better way to understand Amazon S3 is this:
Amazon S3 is a highly scalable object storage system where applications store and retrieve data using unique object keys.
That sentence may sound technical.
So let us break it down in the simplest possible way.
🧠 The mental model: Bucket → Object → Key
Imagine you have a digital warehouse.
The warehouse itself is your bucket.
Inside the warehouse, you store many items.
Those items are your objects.
Every object needs a way to be identified.
That identifier is called the key.
So the basic S3 mental model is:
Amazon S3
↓
Bucket
↓
Object
↓
Key
For example:
Bucket:
my-learning-project Object:
profile-picture.jpg Key:
users/123/profile-picture.jpg This is one of the most important concepts to understand about S3.
🪣 What exactly is a bucket?
A bucket is the main container used to store objects in Amazon S3.
You can think of it as the starting point of your storage architecture.
For example, you could create buckets such as:
company-backups student-project-assets application-images analytics-data Inside each bucket, you can store a very large number of objects.
But there is something important to understand:
Buckets are not exactly folders
When you look at S3 in the AWS Console, it may appear that you are creating folders.
For example:
images/ documents/ users/ But internally, Amazon S3 is based on object keys, not traditional computer folders.
An object could have this key:
users/42/images/profile.jpg It looks like a folder structure.
But S3 sees it primarily as a key identifying one object.
That distinction becomes very important when working with S3 programmatically.
📦 So what is an object?
An object is the actual data stored in S3.
It could be:
- An image
- A PDF
- A video
- A CSV file
- A JSON file
- A ZIP file
- A backup
- A log file
- A machine learning dataset
But an S3 object is more than the file itself.
Conceptually, an object contains:
Data + Key + Metadata
For example:
File:
report.pdf Key:
reports/2026/report.pdf Metadata could describe information related to the object, such as its content type.
This structure is what makes S3 very powerful.
🔑 Why are object keys so important?
Imagine an application with thousands of users.
Each user uploads a profile picture.
Instead of thinking about physical folders, your application could generate keys like:
users/1001/profile.jpg users/1002/profile.jpg users/1003/profile.jpg The key gives your application a predictable way to locate each object.
This means S3 can become part of your application's architecture.
Your application does not need to think:
“Which physical hard drive contains this file?”
It only needs to know:
“Which bucket and which key contain the object?”
That is a major idea behind cloud infrastructure.
🌎 Where does the data live?
When you create an S3 bucket, you choose an AWS Region.
For example, your architecture might use a region located closer to your users or one selected because of business, compliance, latency, or service availability requirements.
This introduces an important AWS concept:
Cloud resources exist somewhere.
“The cloud” does not mean that data has no location.
AWS operates infrastructure across geographic regions, and the region you select becomes part of your architecture.
For beginners, this is worth remembering early:
Region selection is an architectural decision.
🔐 The most important beginner lesson: private by default
One of the biggest mistakes people can make while learning S3 is trying to make everything public just to access a file.
A better mental model is:
Keep data private unless there is a specific reason to expose it.
Access to S3 can be controlled using mechanisms such as:
- IAM policies
- Bucket policies
- S3 Block Public Access
- Roles
- Temporary credentials
- Pre-signed URLs
You do not need to master all of them on your first day.
But you should understand the principle:
Uploading a file and giving someone permission to access that file are two different problems.
That distinction is extremely important in AWS security.
🚀 Let us build something small
Now that we understand the theory, let us create a simple example.
Imagine we are building a small university application.
Students can upload documents.
Instead of storing those files directly on the application server, we decide to use Amazon S3.
The architecture could look like this:
Student
↓
Web Application
↓
Amazon S3
↓
Uploaded Document
For example:
Bucket:
university-document-app Object key:
students/583/documents/project.pdf Now our application can reference the file using the bucket and object key.
🛠️ Creating your first S3 bucket
Open the AWS Management Console and search for:
Amazon S3
Then select:
Create bucket
You will see several configuration options.
At first, focus on the fundamentals.
1. Bucket name
Choose a valid bucket name.
For example:
my-s3-learning-lab Bucket names must follow specific naming rules and must be unique within the required S3 naming scope.
2. AWS Region
Choose the region where the bucket will be created.
For learning purposes, using the same region as the rest of your project usually makes things easier to understand.
3. Public access
For a basic learning lab, keep the default protection against public access unless your specific exercise requires something different.
Then create the bucket.
You have now created your first storage container in Amazon S3.
📤 Upload your first object
Open the bucket.
Select:
Upload
Then:
Add files
Choose a simple file such as:
hello-s3.txt Upload it.
You have just created an S3 object.
At this point, connect the action to the mental model:
Bucket:
my-s3-learning-lab Object:
hello-s3.txt Key:
hello-s3.txt If you later upload the file under something that appears as:
documents/hello-s3.txt the key becomes:
documents/hello-s3.txt This is why understanding keys matters.
⚙️ What really happens when an application uses S3?
This is where S3 becomes more interesting.
Imagine a user uploads an image to your application.
Your application can send that object to S3.
Later, when the user needs the image again, the application can request it using the bucket and key.
Conceptually:
Upload
User
↓
Application
↓
S3 Bucket
↓
Object stored
Download
Application
↓
Request object by key
↓
S3
↓
Object returned
This simple pattern appears in countless real systems.
🌐 Why not just store everything on the server?
Imagine your application runs on a virtual server.
You could store uploaded images directly on that server's disk.
That might work for a small experiment.
But what happens if:
- The server is replaced?
- You create multiple servers?
- Thousands of users upload files?
- You need durable storage?
- Another application needs the same data?
- You need to process the files later?
Separating application compute from object storage becomes extremely useful.
Your application can handle business logic.
S3 can handle object storage.
This is a fundamental cloud architecture pattern.
🧩 S3 starts becoming powerful when other AWS services use it
S3 is rarely interesting because of S3 alone.
Its real power appears when you connect it to other AWS services.
For example:
Amazon CloudFront
You can distribute content stored in S3 to users through a content delivery network.
Conceptually:
User → CloudFront → S3
AWS Lambda
An uploaded file can trigger processing.
For example:
User uploads image
↓
S3
↓
Lambda function
↓
Image processing
A file arriving in S3 can become an event.
That means S3 can participate directly in event-driven architectures.
Amazon Athena
You can store datasets in S3 and query them for analytics.
For example:
CSV / JSON / Parquet files
↓
Amazon S3
↓
Amazon Athena
↓
SQL queries
Now S3 is not just storing files.
It becomes part of a data platform.
AWS Glue
S3 can also serve as a data source for data discovery, transformation, and analytics workflows.
💾 Not all data needs the same type of storage
Imagine two files.
File A:
A profile image accessed every day.
File B:
A backup that may not be accessed for several years.
Should both files be stored in exactly the same way?
Not necessarily.
That is why S3 provides different storage classes.
The basic idea is simple:
Different data access patterns can use different storage strategies.
Examples include storage classes designed for:
- Frequently accessed data
- Infrequently accessed data
- Archive workloads
- Automatically changing access patterns
This allows architects to balance:
Performance
Availability
Access patterns
Cost
You do not need to memorize every storage class immediately.
First understand the reason they exist.
💰 Understanding S3 cost without memorizing pricing tables
A beginner often asks:
“How much does S3 cost?”
The better question is:
“What actions in my architecture generate S3 costs?”
In general, think about several dimensions:
How much data are you storing?
How often are you requesting it?
How is the data being transferred?
Which storage class are you using?
How are you retrieving archived data?
This way of thinking is more useful than memorizing a price.
Prices can change.
The architecture concepts remain valuable.
🔄 Versioning: what happens if somebody overwrites a file?
Suppose you have:
configuration.json Then somebody uploads a new file using the same key.
Without additional protection, mistakes can become painful.
S3 Versioning can help preserve multiple versions of an object.
Conceptually:
configuration.json Version 1
Version 2
Version 3
This can be useful when you want protection against accidental overwrites or deletion.
Again, the important idea is not simply the feature.
The architectural question is:
“What happens if my data changes or gets deleted accidentally?”
Good cloud architecture often begins by asking questions like this.
⏳ Lifecycle rules: your data does not need to stay the same forever
Imagine you store application logs.
During the first month, you access them frequently.
After six months, you rarely need them.
After several years, maybe they can be deleted.
S3 Lifecycle rules allow you to automate actions based on the age of objects.
Conceptually:
New data
↓
Frequently accessed storage
↓
Older data
↓
Lower-cost storage
↓
Very old data
↓
Archive or deletion
This introduces another important cloud idea:
Good architectures manage the entire lifecycle of data, not just its creation.
🔗 Pre-signed URLs: controlled temporary access
Imagine you have a private file.
You do not want to make the entire bucket public.
But you want one user to download one specific file for a limited amount of time.
One solution is a pre-signed URL.
Conceptually:
Private Object
↓
Application generates temporary permission
↓
User receives temporary URL
↓
User accesses the object
This is a much better mental model than:
“Make the bucket public so the user can download the file.”
Understanding this difference can prevent serious security mistakes.
🏗️ A more realistic architecture
Now let us connect several concepts.
Imagine we are creating an application where users upload photos.
A possible architecture could be:
User
↓
Web Application
↓
Amazon S3
↓
Photo stored privately
Then:
Amazon S3
↓
Event
↓
AWS Lambda
↓
Generate smaller image
Then:
Amazon CloudFront
↓
Deliver content efficiently to users
S3 is now participating in:
- Storage
- Security
- Events
- Content delivery
- Application architecture
This is why learning S3 properly is so useful.
❌ Common beginner mistakes
Understanding mistakes is often more useful than memorizing definitions.
1. Thinking S3 is a traditional file system
It is object storage.
The “folders” you see are primarily based on object key prefixes.
2. Making a bucket public just to access a file
Public access should be a deliberate architectural decision.
Do not disable security controls without understanding why.
3. Forgetting about the AWS Region
Resources exist in regions.
Region selection matters.
4. Ignoring cost because the project is small
Learning environments should also teach good cost habits.
Create resources.
Use them.
Understand them.
Delete them when they are no longer needed.
5. Learning buttons instead of concepts
Knowing where the Upload button is located is useful today.
Understanding:
Bucket → Object → Key → Permission
is useful for years.
AWS interfaces can change.
The concepts are what really matter.
🧠 The complete S3 mental model
If you remember only one section from this article, remember this:
Storage
S3 stores objects.
Organization
Objects live inside buckets.
Identification
Every object is identified by a key.
Location
Buckets are created in an AWS Region.
Security
Access must be explicitly controlled.
Cost
Storage, requests, retrieval patterns, and data transfer can affect cost.
Lifecycle
Objects can move through different storage strategies over time.
Integration
S3 becomes especially powerful when connected to other AWS services.
That is Amazon S3 in one mental model.
🧹 One final habit: clean up your lab
If you created resources only for this exercise:
- Remove the objects you uploaded.
- Verify that the bucket no longer contains anything you need.
- Delete the bucket if the lab is finished.
Learning how to create resources is important.
Learning how to clean them up is also part of becoming a good cloud builder.
🚀 What should you learn after S3?
A useful learning path could be:
1. Amazon S3
Understand objects and cloud storage.
↓
2. AWS IAM
Understand identities, permissions, roles, and access.
↓
3. Amazon EC2
Understand compute and virtual servers.
↓
4. AWS Lambda
Understand serverless and event-driven applications.
↓
5. Amazon CloudFront
Understand content delivery.
Once you understand how these services connect, AWS stops looking like a collection of hundreds of unrelated services.
It starts looking like a toolbox for building architectures.
🎯 Final thought
You do not really understand an AWS service when you memorize its definition.
You understand it when you can answer:
What problem does it solve?
How does data move through it?
Who can access it?
What happens when the system grows?
What could fail?
What could cost money?
Amazon S3 is an excellent place to start asking those questions.
And once you understand S3 beyond the simple idea of “cloud storage,” you begin to understand something much bigger:
how cloud architecture itself is designed.
💬 Tell us
If you are currently learning AWS:
What was the first AWS service that truly made cloud computing “click” for you?
And if you already have experience with AWS:
What is one S3 concept you wish you had understood earlier?
Share it in the comments. Your experience could help another builder learn faster.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article