Amazon EBS Tutorial: Create, Attach, Mount, and Snapshot a Volume

Amazon EBS provides block storage that you attach to EC2 instances. Each volume is tied to one Availability Zone. A Linux instance in that same zone can use the volume like an extra disk after you format and mount it.

We'll create an 8 GiB gp3 data volume, attach it to a Linux EC2 instance in ap-south-1a, mount it under /data, write a test file, terminate the instance, and confirm the volume returns to Available. We then create a snapshot, restore a new volume from it, and mount that volume on another instance to confirm the same file is still present.

Key takeaways

• EBS volumes are AZ-scoped: a volume attaches only to an instance in the same Availability Zone.
• Delete on termination is an attachment setting. In this walkthrough, the data volume attached after launch has DeleteOnTermination=false, so it survives instance termination. Root volumes normally use true unless you change the setting.
• EBS snapshots are point-in-time backups. After the first snapshot, AWS stores later snapshots incrementally behind the scenes. You choose the destination AZ when you create a volume from a snapshot.
• On Nitro instances, /dev/sdf in the API often appears as nvme1n1 in lsblk.
• gp3 is the general-purpose SSD type recommended for most boot and data workloads in new designs.

EBS volume types at a glance

This guide uses gp3 for the data volume and for the volume created from a snapshot.

What you need

Charges apply for instances, EBS storage, and snapshots. Delete tutorial resources when finished.

Step 1: Create an EBS volume

In the AWS console, open EC2 → Elastic Block Store → Volumes → Create volume. Match the settings below so the volume can attach to an instance in the same zone.

You can confirm the same details with the CLI after you set the Region:

export AWS_DEFAULT_REGION=ap-south-1
export DATA_VOLUME_ID=vol-0abc1234567890def

Confirm the volume is available in the expected AZ:

aws ec2 describe-volumes --volume-ids "${DATA_VOLUME_ID}" \
  --query 'Volumes[0].{Id:VolumeId,State:State,Size:Size,Type:VolumeType,AZ:AvailabilityZone}' \
  --output json

Sample output:

{
    "Id": "vol-0abc1234567890def",
    "State": "available",
    "Size": 8,
    "Type": "gp3",
    "AZ": "ap-south-1a"
}

Step 2: Launch or choose an EC2 instance in the same AZ

If you already have a Linux EC2 instance in ap-south-1a, you can use it. Otherwise, open EC2 → Instances → Launch instances and create a small Linux instance in the same Availability Zone as the volume (ap-south-1a in this example). Allow a login path you will use next (EC2 Instance Connect, Session Manager, or SSH with a key pair and security group rule for port 22).

Before you attach storage, confirm both resources share an AZ:

Step 3: Attach the EBS volume

On the volume, choose Actions → Attach volume. Select your instance and a device name such as /dev/sdf.

For a data volume attached after the instance is launched, the default is to preserve the volume when the instance terminates. Confirm the attachment shows DeleteOnTermination: false before you continue.

Optional CLI check from your workstation (set INSTANCE_ID to your instance):

aws ec2 describe-volumes --volume-ids "${DATA_VOLUME_ID}" \
  --query 'Volumes[0].Attachments[0].{Device:Device,DeleteOnTermination:DeleteOnTermination,State:State}' \
  --output json

Sample output:

{
    "Device": "/dev/sdf",
    "DeleteOnTermination": false,
    "State": "attached"
}

Step 4: Format and mount the volume

Connect to the instance, then list block devices. On Nitro, the data disk is often nvme1n1:

lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

Sample output:

NAME         SIZE TYPE MOUNTPOINT
nvme0n1       10G disk 
├─nvme0n1p1    1M part 
├─nvme0n1p2  200M part /boot/efi
└─nvme0n1p3  9.8G part /
nvme1n1        8G disk 

A new empty volume has no filesystem yet. Inspect the device (use your NVMe name if it differs):

sudo file -s /dev/nvme1n1

Sample output:

/dev/nvme1n1: data

If file -s already reports a filesystem such as ext4 or XFS, do not run mkfs; mount the existing filesystem instead.

Only run mkfs on a new empty volume. Formatting a volume that already contains a filesystem destroys its existing filesystem metadata and data.

Create an ext4 filesystem, mount it, and write a test file:

sudo mkfs.ext4 /dev/nvme1n1

Create a mount point on the root filesystem:

sudo mkdir -p /data

Mount the new filesystem:

sudo mount /dev/nvme1n1 /data

Write a small test file on the EBS volume:

echo "EBS data survives the instance" | sudo tee /data/ebs-test.txt

Read it back before you terminate the instance:

cat /data/ebs-test.txt

Sample output:

EBS data survives the instance

That file is what you will read again after snapshot restore.

Step 5: Terminate EC2 and confirm the volume survives

Terminate the instance from EC2 → Instances when you are ready. The data volume should detach and return to Available because delete on termination was off for that attachment.

CLI equivalent:

aws ec2 describe-volumes --volume-ids "${DATA_VOLUME_ID}" \
  --query 'Volumes[0].{State:State,Attachments:Attachments}' --output json

Sample output:

{
    "State": "available",
    "Attachments": []
}

Step 6: Create an EBS snapshot

With the instance already terminated, there are no active application writes to flush. If you snapshot a volume that is still attached to a running workload, quiesce the application or file system when consistency matters.

Open EC2 → Snapshots → Create snapshot, select the demo-data volume, and wait until status is Completed.

From the CLI:

SNAPSHOT_ID=$(aws ec2 create-snapshot --volume-id "${DATA_VOLUME_ID}" \
  --description "demo-data backup" --query 'SnapshotId' --output text)

Wait until the snapshot reaches completed:

aws ec2 wait snapshot-completed --snapshot-ids "${SNAPSHOT_ID}"

EBS snapshots are Regional. The snapshot is not locked to the source volume AZ.

Step 7: Restore a new volume from the snapshot

Create a volume from the snapshot. This example uses ap-south-1a so it can attach to another instance in that zone, but you could choose a different AZ in ap-south-1 when you create the volume.

export AZ=ap-south-1a

Create the new volume in the target AZ:

RESTORE_VOLUME_ID=$(aws ec2 create-volume \
  --snapshot-id "${SNAPSHOT_ID}" \
  --availability-zone "${AZ}" \
  --volume-type gp3 \
  --query 'VolumeId' --output text)

Wait until the restored volume is ready to attach:

aws ec2 wait volume-available --volume-ids "${RESTORE_VOLUME_ID}"

A restored volume may show higher latency the first time snapshot-backed blocks are read while EBS initializes them. That behavior does not mean the restore failed.

Attach the restored volume to a Linux instance in ${AZ} the same way as in Step 3, then connect to the instance.

List block devices and filesystem labels so you pick the restored disk, not the root volume:

lsblk -f

Identify the device that contains the restored ext4 filesystem. In this example it appears as /dev/nvme1n1, but your device name may differ (for example nvme2n1 on another instance).

Create the mount point:

sudo mkdir -p /data-restore

Mount the restored ext4 filesystem on the device you identified:

sudo mount /dev/nvme1n1 /data-restore

Confirm the snapshot preserved the file:

cat /data-restore/ebs-test.txt

Sample output:

EBS data survives the instance

The same text confirms the snapshot carried your formatted filesystem and data.

Troubleshooting

Clean up

Delete the restored volume, snapshot, and original data volume when the tutorial is done. Each volume must be available and detached first.

aws ec2 delete-volume --volume-id "${RESTORE_VOLUME_ID}"

delete-volume returns no output when the call succeeds. Remove the snapshot next:

aws ec2 delete-snapshot --snapshot-id "${SNAPSHOT_ID}"

Delete the original data volume last:

aws ec2 delete-volume --volume-id "${DATA_VOLUME_ID}"

Terminate any EC2 instances you created for the walkthrough.

Summary

Amazon EBS provides block storage in one Availability Zone. Creating a gp3 volume, attaching it with delete on termination off, and formatting and mounting it under /data turns the raw block device into storage Linux applications can actually use. Terminating the instance leaves the data volume behind in Available state.

Snapshots capture a point-in-time copy at the Region level. Creating a volume from a snapshot lets you pick the target AZ; mounting the restored volume and reading ebs-test.txt shows the data survived independently of the original instance. For capacity growth on an existing mount, use growpart on EC2 instead of repeating this attach workflow.

References

• Amazon EBS
• EBS volume types
• Attach an EBS volume
• Amazon EBS snapshots