Instances, Families and Naming

By the end of this lesson you will be able to

• Explain what an EC2 instance is and list what it is made of: vCPUs, memory, storage, network, operating system and image.
• Name the six instance categories and pick the right one for a workload from the keywords in a question.
• Read any instance type name, such as m7g.2xlarge or c7gn.xlarge, part by part.
• Compare Graviton with Intel and AMD instances, and say what has to change before moving to Graviton.
• Calculate how long a burstable T instance can burst, and choose between standard and unlimited mode.
• Launch an instance from the console and predict what each lifecycle action (reboot, stop, start, terminate) keeps and loses.

#What an EC2 instance is

Amazon EC2 (Elastic Compute Cloud) rents you virtual servers. Each one is called an instance. Like your own computer it has processors, memory, storage and an operating system (Linux, Windows or macOS), but it runs on a physical server, the host, inside an AWS data centre, in an Availability Zone you choose.

EC2 is the classic example of IaaS (Infrastructure as a Service): AWS looks after the building, the hardware and the virtualisation layer; you look after everything from the operating system up (patches, software, data, firewall rules). AWS describes EC2 as “resizable compute capacity”: you can start one server or a thousand within minutes, make one bigger or smaller, and stop paying when you stop using it.

#What an instance is made of

When you launch an instance you decide on each of these parts:

A few of these need a closer look.

vCPU. A vCPU is one virtual processor as the operating system sees it. What sits behind it depends on the processor:

• On most Intel instances and older AMD instances (m6a and earlier), each physical core runs two hardware threads (hyperthreading), and each thread is one vCPU. So 8 vCPUs are 4 physical cores.
• On Graviton instances, and on AMD from the 7th generation (m7a, c7a, r7a and later), each vCPU is a full physical core.

This is why 8 vCPUs of one family can do more work than 8 vCPUs of another.

Memory is given in GiB (gibibytes, 1,024 × 1,024 × 1,024 bytes), the binary unit, slightly larger than a GB.

Storage comes in two kinds. An EBS (Elastic Block Store) volume is a virtual disk that lives on separate storage servers in the same Availability Zone and reaches the instance over the network. It survives a stop and can be detached and moved. An instance store is an NVMe SSD (or, on some storage types, an HDD) physically inside the host: very fast, but its data is lost when the instance stops, terminates or the host fails. Types that are “EBS-only” have no instance store at all. Chapter 5 covers both in depth.

AMI at a glance. An AMI (Amazon Machine Image) is the template the instance boots from: the operating system, its settings and any software baked in. It is built for one processor architecture (x86 or Arm) and lives in one Region. Lesson 4.3 covers AMIs fully.

What is dedicated and what is shared. The vCPUs, memory and instance store of your instance are reserved for you. The host’s network and EBS bandwidth are shared fairly between the instances on it, which is why smaller types say “up to 12.5 Gbps”: they get a baseline and can burst above it while capacity is free. Larger sizes get fixed, higher figures. Modern instances run on the AWS Nitro System, which moves networking, storage and security work onto dedicated cards so almost all of the host’s processors and memory go to the instances.

#Instance families

AWS offers hundreds of instance types. They are grouped into six categories, each tuned for one kind of work. Within a category, the first letter of the type name is the series (often called the family).

A short mnemonic for the series you will see most often:

• C = Compute / CPU-intensive.
• R = RAM.
• M = Middle of the road: balanced, general workloads.
• T = Turbo: burstable, cheap, for workloads that are usually quiet.
• I = I/O: fast local disks. D = Dense storage.
• P and G = GPUs. Trn = Trainium (training). Inf = Inferentia (inference).

#More detail on each category

• General purpose. M gives a steady, balanced machine and is the safe default when you do not know the bottleneck yet. T is cheaper and burstable (its own section below). Mac instances run macOS on real Apple hardware for building iPhone and Mac apps; they run on a Dedicated Host with a 24-hour minimum allocation.
• Compute optimised. Same processors as M, but half the memory per vCPU, so you pay for processor power, not RAM you will not use.
• Memory optimised. R for most memory-hungry work. X for very large in-memory databases. U (high memory) for the largest in-memory databases, with up to 32 TiB of RAM in one instance. z1d adds a very high, sustained processor clock for software licensed per core, where fewer, faster cores save licence money.
• Storage optimised. The point is the local instance store. I types have NVMe SSDs with very high random read/write speed and very low latency. D and H types have large hard disks for cheap sequential throughput. Because the data lives on instance store, the software must copy or replicate it (Cassandra, MongoDB and Hadoop do this themselves).
• Accelerated computing. Hardware accelerators work alongside the processors: GPUs (P, G), AWS-designed machine-learning chips (Trn, Inf), and FPGAs that you program with your own hardware logic (F).
• HPC optimised. Hpc types are built for large simulations where hundreds of nodes exchange data constantly. They come with very fast networking between nodes and are available in fewer Regions. Placement groups for these clusters are in lesson 4.5.

#Reading an instance type name

Every instance type name has the same shape: series, generation, options, a dot, size.

The options letters you need to know:

Two quirks: the a series (the old a1 type) also meant Graviton, and the u high-memory types put their memory in the name, such as u7i-12tb.

Sizes double. Within a family each step up doubles vCPUs, memory and the price:

Smaller sizes exist in some families (nano, micro, small in T). metal gives you the whole physical server with no virtualisation, for software that needs direct hardware access or its own hypervisor.

Same size, different family. Because each category has its own memory-per-vCPU ratio, the same size word means different machines:

Some real examples to see how the numbers line up (check the current figures with the commands in “Try it yourself”):

#Processors: Graviton, Intel and AMD

Most series come with a choice of processor, shown by the options letter:

AWS states that Graviton gives up to 40% better price performance than comparable x86 instances, and a Graviton type is typically around 20% cheaper per hour than the Intel type of the same size and generation. It also uses less energy for the same work.

The catch is software. Graviton runs Arm code, so everything on the instance must be built for arm64:

• Code that runs on an interpreter or runtime (Python, Node.js, Java, PHP, Ruby) and most open-source software work as they are.
• Containers need an arm64 or multi-architecture image.
• A vendor program shipped only for x86, and any Windows workload, cannot move.

#Burstable T instances and CPU credits

Many servers sit almost idle most of the day and need full speed only now and then: a small website, a development box, a build agent. Paying for full-time processors would waste money. Burstable (T) instances (t2, t3, t3a, t4g, t8i) solve this with a baseline and CPU credits.

• Each size has a baseline: the share of each vCPU it may use all the time, for example 10% for t3.micro.
• One CPU credit = one vCPU at 100% for one minute (or one vCPU at 50% for two minutes, or two vCPUs at 25% for two minutes).
• The instance earns credits at a fixed rate every hour it runs, and spends credits for the CPU it actually uses. Below the baseline it saves the difference; above the baseline it spends its savings.
• Saved credits are capped at 24 hours’ worth of earnings. Beyond that, new credits are thrown away.

The earn rate follows from the baseline: credits per hour = vCPUs × baseline × 60. For t3.micro: 2 × 10% × 60 = 12 credits per hour.

A worked example. A t3.micro with a full balance of 288 credits suddenly runs both vCPUs at 50%. It spends 2 × 50% × 60 = 60 credits per hour and still earns 12, so the balance falls by 48 per hour: 288 ÷ 48 = 6 hours of burst before the balance is empty.

What happens when the balance is empty depends on the credit mode:

More details the exam likes:

• t2 instances in standard mode get a few launch credits to start quickly, and they lose all saved credits when stopped. t3, t3a, t4g and t8i keep their saved credits for 7 days after a stop.
• You can switch modes at any time, on a running or stopped instance.
• CloudWatch shows the credit balance (CPUCreditBalance) and, in unlimited mode, the surplus spent (CPUSurplusCreditBalance). A balance that keeps dropping to zero is the warning sign.
• A T instance that runs well above its baseline all day is the wrong choice in either mode: in standard mode it is slow, in unlimited mode it pays the extra charge and can end up costing more than an m instance. Move it to a fixed-performance type (M or C).

Flex instances (m7i-flex, c7i-flex, m8i-flex, c8i-flex, r8i-flex) are a newer, simpler middle ground: a baseline of 40% CPU, the ability to reach full speed for 95% of the time over a 24-hour window, no credits to manage, and a lower price than the matching non-flex type. They suit general workloads that do not run flat out all day.

#How to choose an instance type

1. Find the bottleneck

   Is the work limited by processor, memory, local disk speed, network, or a GPU? Measure an existing system, or estimate from the software’s documentation.

2. Pick the category

   General purpose if balanced or unknown; C for processor; R/X for memory; I/D for local disk; P/G/Trn/Inf for accelerators; T or flex when it is usually idle.

3. Pick the processor and generation

   Prefer the latest generation you can get in your Region: it is usually faster and cheaper for the same work. Try Graviton if your software runs on Arm.

4. Pick the smallest size that fits, then measure

   Start small, watch CPU and memory in CloudWatch, and resize. AWS Compute Optimizer analyses real usage and recommends right-sized types.

5. Decide between bigger and more

   A bigger instance (scaling up, vertical) has a ceiling and is one point of failure. More instances (scaling out, horizontal) behind a load balancer survive the loss of one. Production designs scale out.

To resize an EBS-backed instance, stop it, change the instance type, and start it. The new type must be compatible: same architecture (x86 ↔ x86, Arm ↔ Arm), and the AMI must have the network and storage drivers that modern Nitro types need. A resize therefore always needs a short downtime; zero-downtime resizing is done by adding new instances and removing old ones.

#Launching your first instance

The console’s Launch an instance page is one form, top to bottom:

1. Name and tags

   Give the instance a name (stored as the tag Name) and any other tags, such as env=dev.

2. Application and OS image (AMI)

   Pick an operating system, for example Amazon Linux 2023, Ubuntu or Windows Server, and the architecture: 64-bit (x86) or 64-bit (Arm). The architecture you pick limits which instance types you can choose next.

3. Instance type

   Choose a type such as t3.micro. The console marks Free Tier eligible types: t2.micro and t3.micro on accounts created before 15 July 2025; t3.micro, t3.small, t4g.micro, t4g.small, c7i-flex.large and m7i-flex.large on newer accounts, whose Free Tier works with credits for six months.

4. Key pair (login)

   Create or choose a key pair for SSH (Linux) or for decrypting the Windows password. Lesson 4.2 covers key pairs, Instance Connect and Session Manager, which needs no key at all.

5. Network settings

   Choose the VPC and subnet (which decides the Availability Zone), whether to auto-assign a public IP, and the security group: create one, or select existing ones.

6. Configure storage

   Set the root EBS volume’s size and type (gp3 by default), and add more volumes if needed.

7. Advanced details

   Optional settings: an IAM instance profile (role), user data (a first-boot script), termination and stop protection, shutdown behaviour, the purchasing option (On-Demand, Spot), the instance metadata settings, and the credit mode for T instances.

8. Summary and launch

   Choose how many instances to launch and select Launch instance. The instance appears in the list in the pending state.

#The instance lifecycle

An instance moves through a small set of states:

A reboot is not a state of its own: the instance stays running on the same host, like restarting your computer.

What each action keeps and loses:

Settings that protect you from mistakes:

• Termination protection blocks terminate from the console, CLI and API. It does not stop Auto Scaling from terminating an instance (use scale-in protection for that), and it does not apply when the operating system shuts itself down with shutdown behaviour set to terminate.
• Stop protection does the same for stop.
• Shutdown behaviour decides what a shutdown from inside the instance (sudo shutdown -h now) does: stop (the default) or terminate.
• An instance whose root volume is an instance store (only some old AMIs) cannot be stopped: it can only reboot or terminate.

#What goes wrong

#How it is used in system design

#Try it yourself

# What is an m7g.2xlarge? vCPUs, memory, architecture, network
aws ec2 describe-instance-types --instance-types m7g.2xlarge \
  --query "InstanceTypes[].{Type:InstanceType,vCPU:VCpuInfo.DefaultVCpus,MemMiB:MemoryInfo.SizeInMiB,Arch:ProcessorInfo.SupportedArchitectures,Net:NetworkInfo.NetworkPerformance}" \
  --output table

# All current-generation Graviton types with local instance store
aws ec2 describe-instance-types \
  --filters Name=processor-info.supported-architecture,Values=arm64 \
            Name=current-generation,Values=true \
            Name=instance-storage-supported,Values=true \
  --query "InstanceTypes[].InstanceType" --output text

# Every burstable type in this Region
aws ec2 describe-instance-types --filters Name=burstable-performance-supported,Values=true \
  --query "sort(InstanceTypes[].InstanceType)" --output text

# Which Availability Zones offer c7gn.xlarge?
aws ec2 describe-instance-type-offerings --location-type availability-zone \
  --filters Name=instance-type,Values=c7gn.xlarge --output table

# Latest Amazon Linux 2023 AMI for Arm, then launch a t4g.micro in standard credit mode
AMI=$(aws ssm get-parameter --name /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64 \
  --query Parameter.Value --output text)
ID=$(aws ec2 run-instances --image-id $AMI --instance-type t4g.micro \
  --credit-specification CpuCredits=standard \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=first-instance}]' \
  --query "Instances[0].InstanceId" --output text)

# Watch the state, then protect it from termination
aws ec2 describe-instances --instance-ids $ID --query "Reservations[].Instances[].State.Name"
aws ec2 modify-instance-attribute --instance-id $ID --disable-api-termination

# Switch to unlimited mode, then resize: stop, change type, start
aws ec2 modify-instance-credit-specification \
  --instance-credit-specifications "InstanceId=$ID,CpuCredits=unlimited"
aws ec2 stop-instances --instance-ids $ID && aws ec2 wait instance-stopped --instance-ids $ID
aws ec2 modify-instance-attribute --instance-id $ID --instance-type "{\"Value\": \"t4g.small\"}"
aws ec2 start-instances --instance-ids $ID

# Clean up: remove protection, then terminate
aws ec2 modify-instance-attribute --instance-id $ID --no-disable-api-termination
aws ec2 terminate-instances --instance-ids $ID

#Summary

Key takeaways

• EC2 rents virtual servers (IaaS): you choose vCPUs, memory, storage, network and an AMI, and manage everything from the operating system up.
• vCPU: one hyperthread on Intel and older AMD; a full core on Graviton and AMD 7a onwards. Memory is in GiB.
• EBS is network storage that survives a stop; instance store is a fast local disk that loses its data on stop, terminate or host failure.
• Six categories: general purpose (M, T), compute (C), memory (R, X, U), storage (I, D, H), accelerated (P, G, Trn, Inf, F), HPC (Hpc). Machine-learning training is P or Trn, not C.
• Name = series + generation + options . size: m7g.2xlarge is general purpose, 7th generation, Graviton, 8 vCPUs. Options: g Graviton, i Intel, a AMD, d instance store, n network, e extra, z high clock. Each size step doubles.
• Graviton is cheaper for the same work but needs arm64 software and an Arm AMI; no Windows; no stop-and-change-type from x86.
• T instances: 1 credit = 1 vCPU at 100% for 1 minute; earn per hour = vCPUs × baseline × 60; keep up to 24 hours’ worth. Standard mode throttles to baseline; unlimited keeps bursting and charges only if the 24-hour average is above baseline. t3/t4g default to unlimited.
• Lifecycle: pending → running → stopping → stopped → (start) → running, or shutting-down → terminated. Billed for compute only while running. Stop/start: new host, new public IPv4, instance store wiped; private IP and EBS kept. Terminate deletes the root volume by default.
• Resize = stop, change type, start, within the same architecture.

Self-check: instances, families and naming32 questions