id
stringlengths 14
16
| text
stringlengths 1
2.43k
| source
stringlengths 99
229
|
|---|---|---|
c9185b4d0a7b-0 | You can deregister an AMI when you have finished with it\. After you deregister an AMI, it can't be used to launch new instances\. Existing instances launched from the AMI are not affected\. For more information, see [Deregistering your Linux AMI](deregister-ami.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AMIs.md |
55217df2f557-0 | Amazon Linux 2 and the Amazon Linux AMI are supported and maintained Linux images provided by AWS\. The following are some of the features of Amazon Linux 2 and Amazon Linux AMI:
+ A stable, secure, and high\-performance execution environment for applications running on Amazon EC2\.
+ Provided at no additional charge to Amazon EC2 users\.
+ Repository access to multiple versions of MySQL, PostgreSQL, Python, Ruby, Tomcat, and many more common packages\.
+ Updated on a regular basis to include the latest components, and these updates are also made available in the yum repositories for installation on running instances\.
+ Includes packages that enable easy integration with AWS services, such as the AWS CLI, Amazon EC2 API and AMI tools, the Boto library for Python, and the Elastic Load Balancing tools\.
For more information, see [Amazon Linux](amazon-linux-ami-basics.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AMIs.md |
0530d1365bf6-0 | Traditional Amazon EC2 instance types provide fixed CPU utilization, while burstable performance instances provide a baseline level of CPU utilization with the ability to burst CPU utilization above the baseline level\. The baseline utilization and ability to burst are governed by CPU credits\.
A CPU credit provides for 100% utilization of a full CPU core for one minute\. Other combinations of number of vCPUs, utilization, and time can also equate to one CPU credit\. For example, one CPU credit is equal to one vCPU running at 50% utilization for two minutes, or two vCPUs running at 25% utilization for two minutes\.
**Contents**
+ [Earning CPU credits](#earning-CPU-credits)
+ [CPU credit earn rate](#CPU-credit-earn-rate)
+ [CPU credit accrual limit](#CPU-credit-accrual-limit)
+ [Accrued CPU credits life span](#accrued-CPU-credits-life-span)
+ [Baseline utilization](#baseline_performance) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
96b48fc2408d-0 | Each burstable performance instance continuously earns \(at a millisecond\-level resolution\) a set rate of CPU credits per hour, depending on the instance size\. The accounting process for whether credits are accrued or spent also happens at a millisecond\-level resolution, so you don't have to worry about overspending CPU credits; a short burst of CPU uses a small fraction of a CPU credit\.
If a burstable performance instance uses fewer CPU resources than is required for baseline utilization \(such as when it is idle\), the unspent CPU credits are accrued in the CPU credit balance\. If a burstable performance instance needs to burst above the baseline utilization level, it spends the accrued credits\. The more credits that a burstable performance instance has accrued, the more time it can burst beyond its baseline when more CPU utilization is needed\.
The following table lists the burstable performance instance types, the rate at which CPU credits are earned per hour, the maximum number of earned CPU credits that an instance can accrue, the number of vCPUs per instance, and the baseline utilization as a percentage of a full core \(using a single vCPU\)\.
| Instance type | CPU credits earned per hour | Maximum earned credits that can be accrued\* | vCPUs | Baseline utilization per vCPU |
| --- | --- | --- | --- | --- |
| **T2** | | | | |
| t2\.nano | 3 | 72 | 1 | 5% |
| t2\.micro | 6 | 144 | 1 | 10% |
| t2\.small | 12 | 288 | 1 | 20% | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
96b48fc2408d-1 | | t2\.micro | 6 | 144 | 1 | 10% |
| t2\.small | 12 | 288 | 1 | 20% |
| t2\.medium | 24 | 576 | 2 | 20%\*\* |
| t2\.large | 36 | 864 | 2 | 30%\*\* |
| t2\.xlarge | 54 | 1296 | 4 | 22\.5%\*\* |
| t2\.2xlarge | 81\.6 | 1958\.4 | 8 | 17%\*\* |
| **T3** | | | | |
| t3\.nano | 6 | 144 | 2 | 5%\*\* |
| t3\.micro | 12 | 288 | 2 | 10%\*\* |
| t3\.small | 24 | 576 | 2 | 20%\*\* |
| t3\.medium | 24 | 576 | 2 | 20%\*\* |
| t3\.large | 36 | 864 | 2 | 30%\*\* |
| t3\.xlarge | 96 | 2304 | 4 | 40%\*\* |
| t3\.2xlarge | 192 | 4608 | 8 | 40%\*\* |
| **T3a** | | | | |
| t3a\.nano | 6 | 144 | 2 | 5%\*\* | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
96b48fc2408d-2 | | **T3a** | | | | |
| t3a\.nano | 6 | 144 | 2 | 5%\*\* |
| t3a\.micro | 12 | 288 | 2 | 10%\*\* |
| t3a\.small | 24 | 576 | 2 | 20%\*\* |
| t3a\.medium | 24 | 576 | 2 | 20%\*\* |
| t3a\.large | 36 | 864 | 2 | 30%\*\* |
| t3a\.xlarge | 96 | 2304 | 4 | 40%\*\* |
| t3a\.2xlarge | 192 | 4608 | 8 | 40%\*\* |
| **T4g** | | | | |
| t4g\.nano | 6 | 144 | 2 | 5%\*\* |
| t4g\.micro | 12 | 288 | 2 | 10%\*\* |
| t4g\.small | 24 | 576 | 2 | 20%\*\* |
| t4g\.medium | 24 | 576 | 2 | 20%\*\* |
| t4g\.large | 36 | 864 | 2 | 30%\*\* |
| t4g\.xlarge | 96 | 2304 | 4 | 40%\*\* | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
96b48fc2408d-3 | | t4g\.xlarge | 96 | 2304 | 4 | 40%\*\* |
| t4g\.2xlarge | 192 | 4608 | 8 | 40%\*\* |
| |
| --- |
| \* The number of credits that can be accrued is equivalent to the number of credits that can be earned in a 24\-hour period\. |
| \*\* The percentage baseline utilization in the table is per vCPU\. In CloudWatch, CPU utilization is shown per vCPU\. For example, the CPU utilization for a `t3.large` instance operating at the baseline level is shown as 30% in CloudWatch CPU metrics\. For information about how to calculate the baseline utilization, see [Baseline utilization](#baseline_performance)\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
bacacd7615f3-0 | The number of CPU credits earned per hour is determined by the instance size\. For example, a `t3.nano` earns six credits per hour, while a `t3.small` earns 24 credits per hour\. The preceding table lists the credit earn rate for all instances\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
a0644cd7c73e-0 | While earned credits never expire on a running instance, there is a limit to the number of earned credits that an instance can accrue\. The limit is determined by the CPU credit balance limit\. After the limit is reached, any new credits that are earned are discarded, as indicated by the following image\. The full bucket indicates the CPU credit balance limit, and the spillover indicates the newly earned credits that exceed the limit\.
![\[Image NOT FOUND\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/t2-t3-bucket.png)
The CPU credit balance limit differs for each instance size\. For example, a `t3.micro` instance can accrue a maximum of 288 earned CPU credits in the CPU credit balance\. The preceding table lists the maximum number of earned credits that each instance can accrue\.
T2 Standard instances also earn launch credits\. Launch credits do not count towards the CPU credit balance limit\. If a T2 instance has not spent its launch credits, and remains idle over a 24\-hour period while accruing earned credits, its CPU credit balance appears as over the limit\. For more information, see [Launch credits](burstable-performance-instances-standard-mode-concepts.md#launch-credits)\.
T3 and T4g instances do not earn launch credits\. These instances launch as `unlimited` by default, and therefore can burst immediately upon start without any launch credits\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
07a7d1c0f442-0 | CPU credits on a running instance do not expire\.
For T2, the CPU credit balance does not persist between instance stops and starts\. If you stop a T2 instance, the instance loses all its accrued credits\.
For T3 and T4g, the CPU credit balance persists for seven days after an instance stops and the credits are lost thereafter\. If you start the instance within seven days, no credits are lost\.
For more information, see `CPUCreditBalance` in the [CloudWatch metrics table](burstable-performance-instances-monitoring-cpu-credits.md#burstable-performance-instances-CW-metrics-table)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
714b3008341b-0 | The *baseline utilization* is the level at which the CPU can be utilized for a net credit balance of zero, when the number CPU credits being earned matches the number of CPU credits being used\. Baseline utilization is also known as *the baseline*\.
Baseline utilization is expressed as a percentage of vCPU utilization, which is calculated as follows:
`(number of credits earned/number of vCPUs)/60 minutes = % baseline utilization`
For example, a `t3.nano` instance, with 2 vCPUs, earns 6 credits per hour, resulting in a baseline utilization of 5% , which is calculated as follows:
`(6 credits earned/2 vCPUs)/60 minutes = 5% baseline utilization`
A `t3.xlarge` instance, with 4 vCPUs, earns 96 credits per hour, resulting in a baseline utilization of 40% \(`(96/4)/60`\)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/burstable-credits-baseline-concepts.md |
5b967ffa61f0-0 | After you launch your instance, you can connect to it and use it the way that you'd use a computer sitting in front of you\.
The following instructions explain how to connect to your instance using an SSH client\. If you receive an error while attempting to connect to your instance, see [Troubleshooting connecting to your instance](TroubleshootingInstancesConnecting.md)\. For more connection options, see [Connect to your Linux instance](AccessingInstances.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
571ab2bccf66-0 | Before you connect to your Linux instance, complete the following prerequisites\.
**Verify that the instance is ready**
After you launch an instance, it can take a few minutes for the instance to be ready so that you can connect to it\. Check that your instance has passed its status checks\. You can view this information in the **Status Checks** column on the **Instances** page\.
**Verify the general prerequisites for connecting to your instance**
To find the public DNS name or IP address of your instance and the user name that you should use to connect to your instance, see [General prerequisites for connecting to your instance](connection-prereqs.md)\.
**Install an SSH client on your local computer as needed**
Your local computer might have an SSH client installed by default\. You can verify this by typing ssh at the command line\. If your compute doesn't recognize the command, you can install an SSH client\.
+ Recent versions of Windows Server 2019 and Windows 10 \- OpenSSH is included as an installable component\. For information, see [OpenSSH in Windows](https://docs.microsoft.com/en-us/windows-server/administration/openssh/openssh_overview)\.
+ Earlier versions of Windows \- Download and install OpenSSH\. For more information, see [Win32\-OpenSSH](https://github.com/PowerShell/Win32-OpenSSH/wiki)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
571ab2bccf66-1 | + Linux and macOS X \- Download and install OpenSSH\. For more information, see [http://www\.openssh\.com](http://www.openssh.com/)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4f2dd585c47c-0 | Use the following procedure to connect to your Linux instance using an SSH client\. If you receive an error while attempting to connect to your instance, see [Troubleshooting connecting to your instance](TroubleshootingInstancesConnecting.md)\.
**To connect to your instance using SSH**
1. In a terminal window, use the ssh command to connect to the instance\. You specify the path and file name of the private key \(`.pem`\), the user name for your instance, and the public DNS name or IPv6 address for your instance\. For more information about how to find the private key, the user name for your instance, and the DNS name or IPv6 address for an instance, see [Locate the private key](connection-prereqs.md#connection-prereqs-private-key) and [Get information about your instance](connection-prereqs.md#connection-prereqs-get-info-about-instance)\. To connect to your instance, use one of the following commands\.
+ \(Public DNS\) To connect using your instance's public DNS name, enter the following command\.
```
ssh -i /path/my-key-pair.pem my-instance-user-name@my-instance-public-dns-name
```
+ \(IPv6\) Alternatively, if your instance has an IPv6 address, to connect using your instance's IPv6 address, enter the following command\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4f2dd585c47c-1 | ```
ssh -i /path/my-key-pair.pem my-instance-user-name@my-instance-IPv6-address
```
You see a response like the following:
```
The authenticity of host 'ec2-198-51-100-1.compute-1.amazonaws.com (198-51-100-1)' can't be established.
ECDSA key fingerprint is l4UB/neBad9tvkgJf1QZWxheQmR59WgrgzEimCG6kZY.
Are you sure you want to continue connecting (yes/no)?
```
1. \(Optional\) Verify that the fingerprint in the security alert matches the fingerprint that you previously obtained in [\(Optional\) Get the instance fingerprint](connection-prereqs.md#connection-prereqs-fingerprint)\. If these fingerprints don't match, someone might be attempting a "man\-in\-the\-middle" attack\. If they match, continue to the next step\.
1. Enter **yes**\.
You see a response like the following:
```
Warning: Permanently added 'ec2-198-51-100-1.compute-1.amazonaws.com' (ECDSA) to the list of known hosts.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4ffb00c1e75d-0 | One way to transfer files between your local computer and a Linux instance is to use the secure copy protocol \(SCP\)\. This section describes how to transfer files with SCP\. The procedure is similar to the procedure for connecting to an instance with SSH\.
**Prerequisites**
+ **Verify the general prerequisites for transferring files to your instance\.**
The general prerequisites for transferring files to an instance are the same as the general prerequisites for connecting to an instance\. For more information, see [General prerequisites for connecting to your instance](connection-prereqs.md)\.
+ **Install an SCP client**
Most Linux, Unix, and Apple computers include an SCP client by default\. If yours doesn't, the OpenSSH project provides a free implementation of the full suite of SSH tools, including an SCP client\. For more information, see [http://www\.openssh\.org](http://www.openssh.org/)\.
The following procedure steps you through using SCP to transfer a file\. If you've already connected to the instance with SSH and have verified its fingerprints, you can start with the step that contains the SCP command \(step 4\)\.
**To use SCP to transfer a file** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4ffb00c1e75d-1 | **To use SCP to transfer a file**
1. Transfer a file to your instance using the instance's public DNS name, or the IPv6 address if your instance has one\. For example, if the name of your private key file is `my-key-pair`, the file to transfer is `SampleFile.txt`, the user name for your instance is `my-instance-user-name`, and the public DNS name of the instance is `my-instance-public-dns-name`, or `my-instance-IPv6-address` if your instance has an IPv6 address, use one of the following commands to copy the file to the `my-instance-user-name` home directory\.
+ \(Public DNS\) To transfer a file to your instance using your instance's public DNS name, enter the following command\.
```
scp -i /path/my-key-pair.pem /path/SampleFile.txt my-instance-user-name@my-instance-public-dns-name:~
```
+ \(IPv6\) Alternatively, if your instance has an IPv6 address, to transfer a file using the instance's IPv6 address, enter the following command\. The IPv6 address must be enclosed in square brackets \(`[ ]`\), which must be escaped \(`\`\)\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4ffb00c1e75d-2 | ```
scp -i /path/my-key-pair.pem /path/SampleFile.txt my-instance-user-name@\[my-instance-IPv6-address\]:~
```
You see a response like the following:
```
The authenticity of host 'ec2-198-51-100-1.compute-1.amazonaws.com (10.254.142.33)'
can't be established.
RSA key fingerprint is 1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f.
Are you sure you want to continue connecting (yes/no)?
```
1. \(Optional\) Verify that the fingerprint in the security alert matches the fingerprint that you previously obtained in [\(Optional\) Get the instance fingerprint](connection-prereqs.md#connection-prereqs-fingerprint)\. If these fingerprints don't match, someone might be attempting a "man\-in\-the\-middle" attack\. If they match, continue to the next step\.
1. Enter **yes**\.
You see a response like the following:
```
Warning: Permanently added 'ec2-198-51-100-1.compute-1.amazonaws.com' (RSA)
to the list of known hosts. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4ffb00c1e75d-3 | to the list of known hosts.
Sending file modes: C0644 20 SampleFile.txt
Sink: C0644 20 SampleFile.txt
SampleFile.txt 100% 20 0.0KB/s 00:00
```
If you receive a "bash: scp: command not found" error, you must first install scp on your Linux instance\. For some operating systems, this is located in the `openssh-clients` package\. For Amazon Linux variants, such as the Amazon ECS\-optimized AMI, use the following command to install scp:
```
[ec2-user ~]$ sudo yum install -y openssh-clients
```
1. To transfer files in the other direction \(from your Amazon EC2 instance to your local computer\), reverse the order of the host parameters\. For example, to transfer the `SampleFile.txt` file from your EC2 instance back to the home directory on your local computer as `SampleFile2.txt`, use of the following commands on your local computer\.
+ \(Public DNS\) To transfer a file from your instance using your instance's public DNS name, enter the following command\.
```
scp -i /path/my-key-pair.pem my-instance-user-name@my-instance-public-dns-name:~/SampleFile.txt ~/SampleFile2.txt
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
4ffb00c1e75d-4 | ```
+ \(IPv6\) Alternatively, if your instance has an IPv6 address, to transfer a file using the instance's IPv6 address, enter the following command\. The IPv6 address must be enclosed in square brackets \(`[ ]`\), which must be escaped \(`\`\)\.
```
scp -i /path/my-key-pair.pem my-instance-user-name@\[my-instance-IPv6-address\]:~/SampleFile.txt ~/SampleFile2.txt
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/AccessingInstancesLinux.md |
83b03bf257d2-0 | General purpose instances provide a balance of compute, memory, and networking resources, and can be used for a wide range of workloads\.
**A1 instances**
These instances are ideally suited for scale\-out workloads that are supported by the Arm ecosystem\. These instances are well\-suited for the following:
+ Web servers
+ Containerized microservices
Bare metal instances, such as `a1.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\.
For more information, see [AWS Graviton Processor](https://aws.amazon.com/ec2/graviton) and [Amazon EC2 A1 Instances](https://aws.amazon.com/ec2/instance-types/a1)\.
**M5 and M5a instances**
These instances provide an ideal cloud infrastructure, offering a balance of compute, memory, and networking resources for a broad range of applications that are deployed in the cloud\. They are well\-suited for the following:
+ Small and midsize databases
+ Data processing tasks that require additional memory
+ Caching fleets
+ Backend servers for SAP, Microsoft SharePoint, cluster computing, and other enterprise applications
For more information, see [Amazon EC2 M5 and M5a Instances](https://aws.amazon.com/ec2/instance-types/m5)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
83b03bf257d2-1 | Bare metal instances, such as `m5.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\. These instances are well suited for the following:
+ Workloads that require access to low\-level hardware features \(for example, Intel VT\) that are not available or fully supported in virtualized environments
+ Applications that require a non\-virtualized environment for licensing or support
**M6g and M6gd instances**
These instances are powered by AWS Graviton2 processors and deliver balanced compute, memory, and networking for a broad range a general purpose workloads\. They are well suited for the following:
+ Application servers
+ Microservices
+ Gaming servers
+ Midsize data stores
+ Caching fleets
Bare metal instances, such as `m6g.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\.
For more information, see [Amazon EC2 M6g Instances](https://aws.amazon.com/ec2/instance-types/m6)\.
**T2, T3, T3a, and T4g instances**
These instances provide a baseline level of CPU performance with the ability to burst to a higher level when required by your workload\. An Unlimited instance can sustain high CPU performance for any period of time whenever required\. For more information, see [Burstable performance instances](burstable-performance-instances.md)\. These instances are well\-suited for the following:
+ Websites and web applications | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
83b03bf257d2-2 | + Websites and web applications
+ Code repositories
+ Development, build, test, and staging environments
+ Microservices
For more information, see [Amazon EC2 T2 Instances](http://aws.amazon.com/ec2/instance-types/t2/), [Amazon EC2 T3 Instances](http://aws.amazon.com/ec2/instance-types/t3/), and [Amazon EC2 T4g Instances](http://aws.amazon.com/ec2/instance-types/t4/)\.
**Topics**
+ [Hardware specifications](#general-purpose-hardware)
+ [Instance performance](#general-purpose-performance)
+ [Network performance](#general-purpose-network-performance)
+ [SSD I/O performance](#general-purpose-ssd-perf)
+ [Instance features](#general-purpose-features)
+ [Release notes](#general-purpose-instances-limits)
+ [Burstable performance instances](burstable-performance-instances.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-0 | The following is a summary of the hardware specifications for general purpose instances\.
| Instance type | Default vCPUs | Memory \(GiB\) |
| --- | --- | --- |
| a1\.medium | 1 | 2 |
| a1\.large | 2 | 4 |
| a1\.xlarge | 4 | 8 |
| a1\.2xlarge | 8 | 16 |
| a1\.4xlarge | 16 | 32 |
| a1\.metal | 16 | 32 |
| m4\.large | 2 | 8 |
| m4\.xlarge | 4 | 16 |
| m4\.2xlarge | 8 | 32 |
| m4\.4xlarge | 16 | 64 |
| m4\.10xlarge | 40 | 160 |
| m4\.16xlarge | 64 | 256 |
| m5\.large | 2 | 8 |
| m5\.xlarge | 4 | 16 |
| m5\.2xlarge | 8 | 32 |
| m5\.4xlarge | 16 | 64 |
| m5\.8xlarge | 32 | 128 |
| m5\.12xlarge | 48 | 192 |
| m5\.16xlarge | 64 | 256 |
| m5\.24xlarge | 96 | 384 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-1 | | m5\.16xlarge | 64 | 256 |
| m5\.24xlarge | 96 | 384 |
| m5\.metal | 96 | 384 |
| m5a\.large | 2 | 8 |
| m5a\.xlarge | 4 | 16 |
| m5a\.2xlarge | 8 | 32 |
| m5a\.4xlarge | 16 | 64 |
| m5a\.8xlarge | 32 | 128 |
| m5a\.12xlarge | 48 | 192 |
| m5a\.16xlarge | 64 | 256 |
| m5a\.24xlarge | 96 | 384 |
| m5ad\.large | 2 | 8 |
| m5ad\.xlarge | 4 | 16 |
| m5ad\.2xlarge | 8 | 32 |
| m5ad\.4xlarge | 16 | 64 |
| m5ad\.8xlarge | 32 | 128 |
| m5ad\.12xlarge | 48 | 192 |
| m5ad\.16xlarge | 64 | 256 |
| m5ad\.24xlarge | 96 | 384 |
| m5d\.large | 2 | 8 |
| m5d\.xlarge | 4 | 16 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-2 | | m5d\.large | 2 | 8 |
| m5d\.xlarge | 4 | 16 |
| m5d\.2xlarge | 8 | 32 |
| m5d\.4xlarge | 16 | 64 |
| m5d\.8xlarge | 32 | 128 |
| m5d\.12xlarge | 48 | 192 |
| m5d\.16xlarge | 64 | 256 |
| m5d\.24xlarge | 96 | 384 |
| m5d\.metal | 96 | 384 |
| m5dn\.large | 2 | 8 |
| m5dn\.xlarge | 4 | 16 |
| m5dn\.2xlarge | 8 | 32 |
| m5dn\.4xlarge | 16 | 64 |
| m5dn\.8xlarge | 32 | 128 |
| m5dn\.12xlarge | 48 | 192 |
| m5dn\.16xlarge | 64 | 256 |
| m5dn\.24xlarge | 96 | 384 |
| m5n\.large | 2 | 8 |
| m5n\.xlarge | 4 | 16 |
| m5n\.2xlarge | 8 | 32 |
| m5n\.4xlarge | 16 | 64 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-3 | | m5n\.2xlarge | 8 | 32 |
| m5n\.4xlarge | 16 | 64 |
| m5n\.8xlarge | 32 | 128 |
| m5n\.12xlarge | 48 | 192 |
| m5n\.16xlarge | 64 | 256 |
| m5n\.24xlarge | 96 | 384 |
| m6g\.medium | 1 | 4 |
| m6g\.large | 2 | 8 |
| m6g\.xlarge | 4 | 16 |
| m6g\.2xlarge | 8 | 32 |
| m6g\.4xlarge | 16 | 64 |
| m6g\.8xlarge | 32 | 128 |
| m6g\.12xlarge | 48 | 192 |
| m6g\.16xlarge | 64 | 256 |
| m6g\.metal | 64 | 256 |
| m6gd\.medium | 1 | 4 |
| m6gd\.large | 2 | 8 |
| m6gd\.xlarge | 4 | 16 |
| m6gd\.2xlarge | 8 | 32 |
| m6gd\.4xlarge | 16 | 64 |
| m6gd\.8xlarge | 32 | 128 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-4 | | m6gd\.4xlarge | 16 | 64 |
| m6gd\.8xlarge | 32 | 128 |
| m6gd\.12xlarge | 48 | 192 |
| m6gd\.16xlarge | 64 | 256 |
| m6gd\.metal | 64 | 256 |
| t2\.nano | 1 | 0\.5 |
| t2\.micro | 1 | 1 |
| t2\.small | 1 | 2 |
| t2\.medium | 2 | 4 |
| t2\.large | 2 | 8 |
| t2\.xlarge | 4 | 16 |
| t2\.2xlarge | 8 | 32 |
| t3\.nano | 2 | 0\.5 |
| t3\.micro | 2 | 1 |
| t3\.small | 2 | 2 |
| t3\.medium | 2 | 4 |
| t3\.large | 2 | 8 |
| t3\.xlarge | 4 | 16 |
| t3\.2xlarge | 8 | 32 |
| t3a\.nano | 2 | 0\.5 |
| t3a\.micro | 2 | 1 |
| t3a\.small | 2 | 2 |
| t3a\.medium | 2 | 4 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
50690bdfd08f-5 | | t3a\.small | 2 | 2 |
| t3a\.medium | 2 | 4 |
| t3a\.large | 2 | 8 |
| t3a\.xlarge | 4 | 16 |
| t3a\.2xlarge | 8 | 32 |
| t4g\.nano | 2 | 0\.5 |
| t4g\.micro | 2 | 1 |
| t4g\.small | 2 | 2 |
| t4g\.medium | 2 | 4 |
| t4g\.large | 2 | 8 |
| t4g\.xlarge | 4 | 16 |
| t4g\.2xlarge | 8 | 32 |
For more information about the hardware specifications for each Amazon EC2 instance type, see [Amazon EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/)\.
For more information about specifying CPU options, see [Optimizing CPU options](instance-optimize-cpu.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
b87454cc4591-0 | EBS\-optimized instances enable you to get consistently high performance for your EBS volumes by eliminating contention between Amazon EBS I/O and other network traffic from your instance\. Some general purpose instances are EBS\-optimized by default at no additional cost\. For more information, see [Amazon EBS–optimized instances](ebs-optimized.md)\.
Some general purpose instance types provide the ability to control processor C\-states and P\-states on Linux\. C\-states control the sleep levels that a core can enter when it is inactive, while P\-states control the desired performance \(in CPU frequency\) from a core\. For more information, see [Processor state control for your EC2 instance](processor_state_control.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
0e28fd816970-0 | You can enable enhanced networking on supported instance types to provide lower latencies, lower network jitter, and higher packet\-per\-second \(PPS\) performance\. Most applications do not consistently need a high level of network performance, but can benefit from access to increased bandwidth when they send or receive data\. For more information, see [Enhanced networking on Linux](enhanced-networking.md)\.
The following is a summary of network performance for general purpose instances that support enhanced networking\.
| Instance type | Network performance | Enhanced networking |
| --- | --- | --- |
| t2\.nano \| t2\.micro \| t2\.small \| t2\.medium \| t2\.large \| t2\.xlarge \| t2\.2xlarge | Up to 1 Gbps | Not supported | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
0e28fd816970-1 | | t3\.nano \| t3\.micro \| t3\.small \| t3\.medium \| t3\.large \| t3\.xlarge \| t3\.2xlarge \| t3a\.nano \| t3a\.micro \| t3a\.small \| t3a\.medium \| t3a\.large \| t3a\.xlarge \| t3a\.2xlarge \| t4g\.nano \| t4g\.micro \| t4g\.small \| t4g\.medium \| t4g\.large \| t4g\.xlarge \| t4g\.2xlarge | Up to 5 Gbps † | [ENA](enhanced-networking-ena.md) |
| m4\.large | Moderate | [Intel 82599 VF](sriov-networking.md) |
| m4\.xlarge \| m4\.2xlarge \| m4\.4xlarge | High | [Intel 82599 VF](sriov-networking.md) | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
0e28fd816970-2 | | a1\.4xlarge and smaller \| a1\.metal \| m5\.4xlarge and smaller \| m5a\.8xlarge and smaller \| m5ad\.8xlarge and smaller \| m5d\.4xlarge and smaller \| m6g\.4xlarge and smaller \| m6gd\.4xlarge and smaller | Up to 10 Gbps † | [ENA](enhanced-networking-ena.md) |
| m4\.10xlarge | 10 Gbps | [Intel 82599 VF](sriov-networking.md) |
| m5\.8xlarge \| m5a\.12xlarge \| m5ad\.12xlarge \| m5d\.8xlarge | 10 Gbps | [ENA](enhanced-networking-ena.md) |
| m5\.12xlarge \| m5a\.16xlarge \| m5ad\.16xlarge \| m5d\.12xlarge \| m6g\.8xlarge \| m6gd\.8xlarge | 12 Gbps | [ENA](enhanced-networking-ena.md) |
| m5\.16xlarge \| m5a\.24xlarge \| m5ad\.24xlarge \| m5d\.16xlarge \| m6g\.12xlarge \| m6gd\.12xlarge | 20 Gbps | [ENA](enhanced-networking-ena.md) | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
0e28fd816970-3 | | m5dn\.4xlarge and smaller \| m5n\.4xlarge and smaller | Up to 25 Gbps † | [ENA](enhanced-networking-ena.md) |
| m4\.16xlarge \| m5\.24xlarge \| m5\.metal \| m5d\.24xlarge \| m5d\.metal \| m5dn\.8xlarge \| m5n\.8xlarge \| m6g\.16xlarge \| m6g\.metal \| m6gd\.16xlarge \| m6gd\.metal | 25 Gbps | [ENA](enhanced-networking-ena.md) |
| m5dn\.12xlarge \| m5n\.12xlarge | 50 Gbps | [ENA](enhanced-networking-ena.md) |
| m5dn\.16xlarge \| m5n\.16xlarge | 75 Gbps | [ENA](enhanced-networking-ena.md) |
| m5dn\.24xlarge \| m5n\.24xlarge | 100 Gbps | [ENA](enhanced-networking-ena.md) | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
0e28fd816970-4 | † These instances use a network I/O credit mechanism to allocate network bandwidth to instances based on average bandwidth utilization\. They accrue credits when their bandwidth is below their baseline bandwidth, and can use these credits when they perform network data transfers\. For more information, open a support case and ask about baseline bandwidth for the specific instance types that you are interested in\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
f412327c8f4f-0 | If you use a Linux AMI with kernel version 4\.4 or later and use all the SSD\-based instance store volumes available to your instance, you get the IOPS \(4,096 byte block size\) performance listed in the following table \(at queue depth saturation\)\. Otherwise, you get lower IOPS performance\.
| Instance Size | 100% Random Read IOPS | Write IOPS |
| --- | --- | --- |
| m5ad\.large \* | 30,000 | 15,000 |
| m5ad\.xlarge \* | 59,000 | 29,000 |
| m5ad\.2xlarge \* | 117,000 | 57,000 |
| m5ad\.4xlarge \* | 234,000 | 114,000 |
| m5ad\.8xlarge | 466,666 | 233,333 |
| m5ad\.12xlarge | 700,000 | 340,000 |
| m5ad\.16xlarge | 933,333 | 466,666 |
| m5ad\.24xlarge | 1,400,000 | 680,000 |
| m5d\.large \* | 30,000 | 15,000 |
| m5d\.xlarge \* | 59,000 | 29,000 |
| m5d\.2xlarge \* | 117,000 | 57,000 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
f412327c8f4f-1 | | m5d\.2xlarge \* | 117,000 | 57,000 |
| m5d\.4xlarge \* | 234,000 | 114,000 |
| m5d\.8xlarge | 466,666 | 233,333 |
| m5d\.12xlarge | 700,000 | 340,000 |
| m5d\.16xlarge | 933,333 | 466,666 |
| m5d\.24xlarge | 1,400,000 | 680,000 |
| m5d\.metal | 1,400,000 | 680,000 |
| m5dn\.large \* | 30,000 | 15,000 |
| m5dn\.xlarge \* | 59,000 | 29,000 |
| m5dn\.2xlarge \* | 117,000 | 57,000 |
| m5dn\.4xlarge \* | 234,000 | 114,000 |
| m5dn\.8xlarge | 466,666 | 233,333 |
| m5dn\.12xlarge | 700,000 | 340,000 |
| m5dn\.16xlarge | 933,333 | 466,666 |
| m5dn\.24xlarge | 1,400,000 | 680,000 |
| m6gd\.medium | 13,438 | 5,625 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
f412327c8f4f-2 | | m6gd\.medium | 13,438 | 5,625 |
| m6gd\.large | 26,875 | 11,250 |
| m6gd\.xlarge | 53,750 | 22,500 |
| m6gd\.2xlarge | 107,500 | 45,000 |
| m6gd\.4xlarge | 215,000 | 90,000 |
| m6gd\.8xlarge | 430,000 | 180,000 |
| m6gd\.12xlarge | 645,000 | 270,000 |
| m6gd\.16xlarge | 860,000 | 360,000 |
| m6gd\.metal | 860,000 | 360,000 |
\* For these instances, you can get up to the specified performance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
f412327c8f4f-3 | | m6gd\.metal | 860,000 | 360,000 |
\* For these instances, you can get up to the specified performance\.
As you fill the SSD\-based instance store volumes for your instance, the number of write IOPS that you can achieve decreases\. This is due to the extra work the SSD controller must do to find available space, rewrite existing data, and erase unused space so that it can be rewritten\. This process of garbage collection results in internal write amplification to the SSD, expressed as the ratio of SSD write operations to user write operations\. This decrease in performance is even larger if the write operations are not in multiples of 4,096 bytes or not aligned to a 4,096\-byte boundary\. If you write a smaller amount of bytes or bytes that are not aligned, the SSD controller must read the surrounding data and store the result in a new location\. This pattern results in significantly increased write amplification, increased latency, and dramatically reduced I/O performance\.
SSD controllers can use several strategies to reduce the impact of write amplification\. One such strategy is to reserve space in the SSD instance storage so that the controller can more efficiently manage the space available for write operations\. This is called *over\-provisioning*\. The SSD\-based instance store volumes provided to an instance don't have any space reserved for over\-provisioning\. To reduce write amplification, we recommend that you leave 10% of the volume unpartitioned so that the SSD controller can use it for over\-provisioning\. This decreases the storage that you can use, but increases performance even if the disk is close to full capacity\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
f412327c8f4f-4 | For instance store volumes that support TRIM, you can use the TRIM command to notify the SSD controller whenever you no longer need data that you've written\. This provides the controller with more free space, which can reduce write amplification and increase performance\. For more information, see [Instance store volume TRIM support](ssd-instance-store.md#InstanceStoreTrimSupport)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
d2347d76167a-0 | The following is a summary of features for general purpose instances:
| | EBS only | NVMe EBS | Instance store | Placement group |
| --- | --- | --- | --- | --- |
| A1 | Yes | Yes | No | Yes |
| M4 | Yes | No | No | Yes |
| M5 | Yes | Yes | No | Yes |
| M5a | Yes | Yes | No | Yes |
| M5ad | No | Yes | NVMe \* | Yes |
| M5d | No | Yes | NVMe \* | Yes |
| M5dn | No | Yes | NVMe \* | Yes |
| M5n | Yes | Yes | No | Yes |
| M6g | Yes | Yes | No | Yes |
| M6gd | No | Yes | NVMe \* | Yes |
| T2 | Yes | No | No | No |
| T3 | Yes | Yes | No | No |
| T3a | Yes | Yes | No | No |
| T4g | Yes | Yes | No | No |
**\*** The root device volume must be an Amazon EBS volume\.
For more information, see the following:
+ [Amazon EBS and NVMe on Linux instances](nvme-ebs-volumes.md)
+ [Amazon EC2 instance store](InstanceStorage.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
d2347d76167a-1 | + [Amazon EC2 instance store](InstanceStorage.md)
+ [Placement groups](placement-groups.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
e27d4fc898b6-0 | + M5, M5d, and T3 instances feature a 3\.1 GHz Intel Xeon Platinum 8000 series processor from either the first generation \(Skylake\-SP\) or second generation \(Cascade Lake\)\.
+ M5a, M5ad, and T3a instances feature a 2\.5 GHz AMD EPYC 7000 series processor\.
+ A1 instances feature a 2\.3 GHz AWS Graviton processor based on 64\-bit Arm architecture\.
+ M6g and M6gd instances feature an AWS Graviton2 processor based on 64\-bit Arm architecture\.
+ T4g instances feature an AWS Graviton2 processor based on 64\-bit Arm architecture\.
+ M4, M5, M5a, M5ad, M5d, `t2.large` and larger, and `t3.large` and larger, and `t3a.large` and larger instance types require 64\-bit HVM AMIs\. They have high\-memory, and require a 64\-bit operating system to take advantage of that capacity\. HVM AMIs provide superior performance in comparison to paravirtual \(PV\) AMIs on high\-memory instance types\. In addition, you must use an HVM AMI to take advantage of enhanced networking\.
+ Instances built on the [Nitro System](instance-types.md#ec2-nitro-instances) have the following requirements:
+ [NVMe drivers](nvme-ebs-volumes.md) must be installed | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
e27d4fc898b6-1 | + [NVMe drivers](nvme-ebs-volumes.md) must be installed
+ [Elastic Network Adapter \(ENA\) drivers](enhanced-networking-ena.md) must be installed
The following Linux AMIs meet these requirements:
+ Amazon Linux 2
+ Amazon Linux AMI 2018\.03
+ Ubuntu 14\.04 \(with `linux-aws` kernel\) or later
+ Red Hat Enterprise Linux 7\.4 or later
+ SUSE Linux Enterprise Server 12 SP2 or later
+ CentOS 7\.4\.1708 or later
+ FreeBSD 11\.1 or later
+ Debian GNU/Linux 9 or later
+ Instances with an [AWS Graviton Processor](https://aws.amazon.com/ec2/graviton) have the following requirements:
+ Use an AMI for the 64\-bit Arm architecture\.
+ Support booting through UEFI with ACPI tables and support ACPI hot\-plug of PCI devices\.
The following Linux AMIs meet these requirements:
+ Amazon Linux 2 \(64\-bit Arm\)
+ Ubuntu 16\.04 or later \(64\-bit Arm\)
+ Red Hat Enterprise Linux 8\.0 or later \(64\-bit Arm\)
+ SUSE Linux Enterprise Server 15 or later \(64\-bit Arm\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
e27d4fc898b6-2 | + SUSE Linux Enterprise Server 15 or later \(64\-bit Arm\)
+ Instances built on the Nitro System support a maximum of 28 attachments, including network interfaces, EBS volumes, and NVMe instance store volumes\. For more information, see [Nitro System volume limits](volume_limits.md#instance-type-volume-limits)\.
+ Launching a bare metal instance boots the underlying server, which includes verifying all hardware and firmware components\. This means that it can take 20 minutes from the time the instance enters the running state until it becomes available over the network\.
+ To attach or detach EBS volumes or secondary network interfaces from a bare metal instance requires PCIe native hotplug support\. Amazon Linux 2 and the latest versions of the Amazon Linux AMI support PCIe native hotplug, but earlier versions do not\. You must enable the following Linux kernel configuration options:
```
CONFIG_HOTPLUG_PCI_PCIE=y
CONFIG_PCIEASPM=y
```
+ Bare metal instances use a PCI\-based serial device rather than an I/O port\-based serial device\. The upstream Linux kernel and the latest Amazon Linux AMIs support this device\. Bare metal instances also provide an ACPI SPCR table to enable the system to automatically use the PCI\-based serial device\. The latest Windows AMIs automatically use the PCI\-based serial device\.
+ Instances built on the Nitro System should have system\-logind or acpid installed to support clean shutdown through API requests\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |
e27d4fc898b6-3 | + Instances built on the Nitro System should have system\-logind or acpid installed to support clean shutdown through API requests\.
+ There is a limit on the total number of instances that you can launch in a Region, and there are additional limits on some instance types\. For more information, see [How many instances can I run in Amazon EC2?](https://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2) in the Amazon EC2 FAQ\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/general-purpose-instances.md |