Especificar atributos para seleção de tipo de instância para frota do EC2 ou frota spot - Amazon Elastic Compute Cloud
Como funciona a seleção de tipo de instância baseada em atributosProteção de preçoProteção de performanceConsideraçõesCriar uma Frota do EC2 com seleção de tipo de instância baseada em atributosCriar uma frota spot com seleção de tipo de instância baseada em atributosExemplos de configurações de frota do EC2 que são válidas e não válidasExemplos de configurações de frota spot que são válidas e não válidasPrevisualizar os tipos de instância com os atributos especificados

Especificar atributos para seleção de tipo de instância para frota do EC2 ou frota spot

Ao criar uma frota do EC2 ou frota spot, você deve especificar um ou mais tipos de instância para configurar as instâncias sob-demanda e as instâncias spot na frota. Como alternativa à especificação manual dos tipos de instância, você pode especificar os atributos que uma instância deve ter, e o Amazon EC2 identificará todos os tipos de instância com esses atributos. Isso é conhecido como seleção de tipo de instância baseada em atributos. Por exemplo, você pode especificar o número mínimo e máximo de vCPUs necessárias para suas instâncias, e a frota inicializará as instâncias usando todos os tipos de instância disponíveis que atendam a esses requisitos de vCPU.

A seleção de tipo de instância baseada em atributos é ideal para workloads e frameworks que possam ser flexíveis em relação a que tipos de instância elas usam, como ao executar contêineres ou frotas da Web, processar big data e implementar ferramentas de integração e implantação contínuas (CI/CD).

Benefícios

A seleção de tipo de instância baseada em atributos oferece os seguintes benefícios:

  • Use facilmente os tipos de instâncias certos: com tantos tipos de instância disponíveis, encontrar os tipos de instância corretos para a workload pode ser demorado. Se você especificar os atributos de instância, os tipos de instância terão automaticamente os atributos necessários para sua workload.

  • Configuração simplificada: para especificar manualmente vários tipos de instância para uma frota, crie uma substituição de modelo de inicialização separada para cada tipo de instância. Mas, com a seleção de tipo de instância baseada em atributos, para fornecer vários tipos de instância, você só precisa especificar os atributos das instâncias no modelo de lançamento ou em uma substituição de modelo de lançamento.

  • Uso automático de novos tipos de instâncias: quando atributos de instância são especificados em vez de tipos de instância, sua frota pode usar tipos de instância de gerações mais novas à medida que são lançados, tornando a configuração da frota "à prova de obsolescência".

  • Flexibilidade de tipo de instância: quando você especifica atributos de instância em vez de tipos de instância, a frota pode selecionar em uma ampla variedade de tipos de instância para inicializar instâncias spot, o que atende às Práticas recomendadas para instâncias spot da flexibilidade de tipo de instância.

Como funciona a seleção de tipo de instância baseada em atributos

Para usar a seleção de tipo de instância baseada em atributos na configuração de frota, substitua a lista dos tipos de instância por uma lista dos atributos de instância que suas instâncias requerem. A frota do EC2 ou a frota spot inicializará instâncias em todos os tipos de instância disponíveis que tenham os atributos de instância especificados.

Tipos de atributos de instância

Há vários atributos de instância que você pode especificar para expressar seus requisitos de computação, p. ex.:

  • Contagem de vCPUs: o número mínimo e máximo de vCPUs por instância.

  • Memória: o mínimo e o máximo de GiBs de memória por instância.

  • Armazenamento local: se o sistema deve usar o EBS ou volumes de armazenamento de instâncias para armazenamento local.

  • Performance intermitente: se o sistema deve usar a família de instâncias T, incluindo os tipos T4g, T3a, T3 e T2.

Para obter uma descrição de cada atributo e os valores padrão, consulte InstanceRequirements na Referência de API do Amazon EC2.

Onde configurar a seleção de tipo de instância baseada em atributos

Dependendo de você usar o console ou a AWS CLI, é possível especificar os atributos de instância para a seleção de tipo de instância baseada em atributos da seguinte forma:

No console, você pode especificar os atributos de instância nos seguintes componentes de configuração de frota:

  • Em um modelo de inicialização, referencie o modelo de inicialização na solicitação da frota

  • (Somente frota spot) Na solicitação de frota

Na AWS CLI, você pode especificar os atributos de instância em um ou ambos os componentes de configuração de frota a seguir:

  • Em um modelo de inicialização, referencie o modelo de inicialização na solicitação da frota

  • Em uma substituição de modelo de lançamento

    Se desejar uma combinação de instâncias que usam AMIs diferentes, você pode especificar atributos de instância em várias substituições de modelo de lançamento. Por exemplo, diferentes tipos de instância podem usar processadores baseados em x86 e Arm.

  • (Somente frota spot) Em uma especificação de inicialização

Como a frota do EC2 ou a frota spot usa a seleção de tipo de instância baseada em atributos ao provisionar uma frota

A frota do EC2 ou a frota spot provisiona uma frota da seguinte maneira:

  • Ela identifica os tipos de instância que têm os atributos especificados.

  • Ela usa proteção de preço para determinar quais tipos de instância excluir.

  • Ela determina os grupos de capacidade dos quais considerará inicializar as instâncias com base nas regiões ou zonas de disponibilidade da AWS que possuem os tipos de instância correspondentes.

  • Ela aplica a estratégia de alocação especificada para determinar os grupos de capacidade dos quais as instâncias serão inicializadas.

    Observe que a seleção de tipo de instância baseada em atributos não escolhe os grupos de capacidade dos quais provisionará a frota; isso cabe às estratégias de alocação.

    Se você especificar uma estratégia de alocação, a frota inicializará as instâncias de acordo com a estratégia de alocação especificada.

    • Nas instâncias spot, a seleção do tipo de instância baseada em atributos oferece suporte às estratégias de alocação otimizada para capacidade de preço, capacidade otimizada e menor preço. Não recomendamos a estratégia de alocação de spot menor preço porque ela representa o risco mais alto de interrupção para as instâncias spot.

    • Para instâncias sob demanda, a seleção de tipo de instância baseada em atributos oferece suporte à estratégia de alocação menor preço.

  • Se não houver capacidade para os tipos de instância com os atributos de instância especificados, nenhuma instância poderá ser iniciada e a frota retornará um erro.

Proteção de preço

A proteção de preços é um recurso que impede que a frota do EC2 ou a frota spot use tipos de instância que você consideraria muito caros, mesmo que atendessem aos atributos especificados. Para usar a proteção de preço, você define um limite de preço. Em seguida, quando o Amazon EC2 selecionar tipos de instância com seus atributos, ele excluirá os tipos de instância que tenham preços acima do limite.

A forma como o Amazon EC2 calcula o limite de preço é a seguinte:

  • Primeiro, o Amazon EC2 identifica o tipo de instância com o menor preço dentre aqueles que correspondem aos seus atributos.

  • Em seguida, o Amazon EC2 pegará o valor (expresso como uma porcentagem) que você especificou para o parâmetro de proteção de preço e o multiplicará pelo preço do tipo de instância identificado. O resultado é o preço usado como o limite de preço.

Há limites distintos de preço para instâncias sob demanda e instâncias spot.

Quando você cria uma frota com seleção de tipo de instância baseada em atributos, a proteção de preço é habilitada por padrão. É possível manter os valores padrão ou especificar seus próprios valores.

Você também pode desativar a proteção de preços. Para indicar que não há limite de proteção de preço, especifique um valor percentual alto, como 999999.

Identificação do tipo de instância com o menor preço

O Amazon EC2 determina o preço básico do limite de preço ao identificar o tipo de instância com o menor preço dentre aquelas que correspondem aos atributos especificados. Ele faz isso da seguinte maneira:

  • Primeiro, ele analisa os tipos de instância C, M ou R da geração atual que correspondem aos seus atributos. Se houver alguma correspondência, ele identificará o tipo de instância com o menor preço.

  • Se não houver uma correspondência, ele analisará os tipos de instância da geração atual que correspondem aos seus atributos. Se houver alguma correspondência, ele identificará o tipo de instância com o menor preço.

  • Se não houver correspondência, ele examinará todos os tipos de instância da geração anterior que correspondam aos seus atributos e identificará o tipo de instância com o menor preço.

Proteção de preço de instância sob demanda

O limite de proteção de preço para tipos de instância sob demanda é calculado como uma porcentagem maior do que o tipo de instância sob demanda de menor preço identificado (OnDemandMaxPricePercentageOverLowestPrice). Você especifica maior a porcentagem que está disposto a pagar. Se você não especificar esse parâmetro, um valor padrão de 20 será usado para calcular um limite de proteção de preço 20% superior ao preço identificado.

Por exemplo, se o preço da instância sob demanda identificada for 0.4271, e você especificar 25, o limite de preço será 25% maior que 0.4271. Isso é calculado da seguinte forma: 0.4271 * 1.25 = 0.533875. O preço calculado é o máximo que você está disposto a pagar por instâncias sob demanda e, neste exemplo, o Amazon EC2 excluirá qualquer tipo de instância sob demanda com preço superior a 0.533875.

Proteção de preço de instância spot

Por padrão, o Amazon EC2 aplicará automaticamente a proteção de preço de instância spot ideal para selecionar de forma consistente entre uma ampla variedade de tipos de instância. Você também pode definir manualmente a proteção de preço. No entanto, deixar que o Amazon EC2 faça isso por você pode aumentar a probabilidade de que sua capacidade de spot seja atendida.

É possível especificar manualmente a proteção de preço usando uma das opções a seguir. Se você definir manualmente a proteção de preço, recomendamos usar a primeira opção.

  • Um percentual do tipo de instância sob demanda com o menor preço identificado [MaxSpotPriceAsPercentageOfOptimalOnDemandPrice]

    Por exemplo, se o preço do tipo de instância sob demanda identificada for 0.4271, e você especificar 60, o limite de preço será 60% de 0.4271. Isso é calculado da seguinte forma: 0.4271 * 0.60 = 0.25626. O preço calculado é o máximo que você está disposto a pagar por instâncias spot e, neste exemplo, o Amazon EC2 excluirá qualquer tipo de instância spot com preço superior a 0.25626.

  • Um percentual maior do que o tipo de instância spot com o menor preço identificado [SpotMaxPricePercentageOverLowestPrice]

    Por exemplo, se o preço do tipo de instância spot identificada for 0.1808, e você especificar 25, o limite de preço será 25% maior que 0.1808. Isso é calculado da seguinte forma: 0.1808 * 1.25 = 0.226. O preço calculado é o máximo que você está disposto a pagar por instâncias spot e, neste exemplo, o Amazon EC2 excluirá qualquer tipo de instância spot com preço superior a 0.266. Não é recomendável usar esse parâmetro, pois os preço spot podem flutuar e, portanto, seu limite de proteção de preço também poderá flutuar.

Especificar o limite de proteção de preço

Especificar o limite de proteção de preço usando a AWS CLI

Quando estiver criando uma frota do EC2 ou uma frota spot usando a AWS CLI, configure a frota para seleção de tipo de instância baseada em atributos e, em seguida, faça o seguinte:

  • Para especificar o limite de proteção de preço da instância sob demanda, no arquivo de configuração JSON, em estrutura InstanceRequirements, para OnDemandMaxPricePercentageOverLowestPrice, insira o limite de proteção de preço como uma porcentagem.

  • Para especificar o limite de proteção de preço da instância spot, no arquivo de configuração JSON, na estrutura InstanceRequirements, especifique um destes parâmetros:

    • Para MaxSpotPriceAsPercentageOfOptimalOnDemandPrice, insira o limite de proteção de preço como uma porcentagem.

    • Para SpotMaxPricePercentageOverLowestPrice, insira o limite de proteção de preço como uma porcentagem.

Para ter mais informações, consulte Criar uma Frota do EC2 com seleção de tipo de instância baseada em atributos ou Criar uma frota spot com seleção de tipo de instância baseada em atributos.

(Somente frota spot) Para especificar o limite de proteção de preço usando o console

Quando estiver criando uma frota spot, configure a frota para seleção de tipo de instância baseada em atributos e, em seguida, faça o seguinte:

  • Para especificar o limite de proteção de preço da instância sob demanda, em Atributo de instância adicional, escolha Proteção de preços sob demanda e Adicionar atributo e insira o limite de proteção de preço como uma porcentagem.

  • Para especificar o limite de proteção de preço da instância sob demanda, em Atributo de instância adicional, escolha Proteção de preço spot, Adicionar atributo, escolha um valor básico no qual basear o preço e, em seguida, insira o limite de proteção de preço como uma porcentagem.

nota

Ao criar a frota, se você definir TargetCapacityUnitType para vcpu ou memory-mib, o limite de proteção de preço será aplicado com base no preço por VCPU ou no preço por memória, em vez de no preço por instância.

Proteção de performance

A proteção de performance é um recurso para garantir que a frota do EC2 ou frota spot use tipos de instância que sejam semelhantes ou excedam uma linha de base de performance especificada. Para usar a proteção de performance, especifique uma família de instâncias como referência de linha de base. Os recursos da família de instâncias especificada estabelecem o nível de performance mais baixo aceitável. Quando o Amazon EC2 seleciona tipos de instância para sua frota, ele considera os atributos e a linha de base de performance especificados. Os tipos de instância que estão abaixo da linha de base de performance são automaticamente excluídos da seleção, mesmo que correspondam aos outros atributos especificados. Isso garante que todos os tipos de instância selecionados ofereçam performance semelhante ou melhor do que a linha de base estabelecida pela família de instâncias especificada. O Amazon EC2 usa essa linha de base para orientar a seleção do tipo de instância, mas não há garantia de que os tipos de instância selecionados sempre excederão a linha de base de cada aplicação.

No momento, esse recurso oferece suporte apenas à performance da CPU como fator de performance da linha de base. A performance da CPU do processador de CPU da família de instâncias especificada serve como linha de base de performance, garantindo que os tipos de instância selecionados sejam semelhantes ou excedam essa linha de base. Famílias de instâncias com os mesmos processadores de CPU levam aos mesmos resultados de filtragem, mesmo que a performance da rede ou do disco seja diferente. Por exemplo, especificar c6in ou c6i como referência de linha de base produziria resultados de filtragem idênticos com base na performance porque as duas famílias de instâncias usam o mesmo processador de CPU.

Famílias de instâncias não compatíveis

As seguintes famílias de instâncias não são compatíveis com a proteção de performance:

  • c1

  • g3 | g3s

  • hpc7g

  • m1 | m2

  • mac1 | mac2 | mac2-m1ultra | mac2-m2 | mac2-m2pro

  • p3dn | p4d | p5

  • t1

  • u-12tb1 | u-18tb1 | u-24tb1 | u-3tb1 | u-6tb1 | u-9tb1 | u7i-12tb | u7in-16tb | u7in-24tb | u7in-32tb

Se você habilitar a proteção de performance especificando uma família de instâncias compatível, os tipos de instância retornados excluirão as famílias de instâncias incompatíveis acima.

Se você especificar uma família de instâncias não compatível como um valor para a performance da linha de base, a API retornará uma resposta vazia para GetInstanceTypesFromInstanceRequirements e uma exceção para CreateFleet, RequestSpotFleet, ModifyFleet e ModifySpotFleetRequest.

Exemplo: definir uma linha de base de performance da CPU

No exemplo a seguir, o requisito da instância é ser iniciada com tipos de instância que tenham núcleos de CPU com a mesma performance da família de instâncias c6i. Isso filtrará os tipos de instância com processadores de CPU de performance inferior, mesmo que atendam aos outros requisitos de instância especificados, como o número de vCPUs. Por exemplo, se os atributos de instância especificados incluírem 4 vCPUs e 16 GB de memória, um tipo de instância com esses atributos, mas com performance de CPU inferior ao c6i, será excluído da seleção.

"BaselinePerformanceFactors": {
        "Cpu": {
            "References": [
                {
                    "InstanceFamily": "c6i"
                }
            ]
        }

Considerações

  • É possível especificar tipos de instância ou atributos de instância em uma frota do EC2 ou frota spot, mas não ambos ao mesmo tempo.

    Ao usar a CLI, as substituições do modelo de lançamento prevalecerão sobre o modelo de lançamento. Por exemplo, se o modelo de lançamento contiver um tipo de instância e a substituição do modelo de lançamento contiver atributos de instância, as instâncias identificadas pelos atributos da instância prevalecerão sobre o tipo de instância no modelo de lançamento.

  • Ao usar a CLI, quando você especifica atributos de instância como substituições, não pode especificar também pesos ou prioridades.

  • É possível especificar, no máximo, quatro estruturas de InstanceRequirements em uma configuração de solicitação.

Criar uma Frota do EC2 com seleção de tipo de instância baseada em atributos

É possível configurar uma frota do EC2 para usar a seleção de tipo de instância baseada em atributos usando a AWS CLI.

Para criar uma Frota do EC2 com a seleção de tipo de instância baseada nos atributos (AWS CLI)

Use o comando create-fleet (AWS CLI) para criar uma frota do EC2. Especifique a configuração da frota em um arquivo JSON.

aws ec2 create-fleet \
    --region us-east-1 \
    --cli-input-json file://file_name.json

Exemplo de arquivo file_name.json

O exemplo a seguir contém os parâmetros que configuram uma Frota do EC2 para usar a seleção de tipo de instância baseada nos atributos e é seguido de um texto explicativo.

{
	"SpotOptions": {
		"AllocationStrategy": "price-capacity-optimized"
	},
	"LaunchTemplateConfigs": [{
		"LaunchTemplateSpecification": {
			"LaunchTemplateName": "my-launch-template",
			"Version": "1"
		},
		"Overrides": [{
			"InstanceRequirements": {
				"VCpuCount": {
					"Min": 2
				},
				"MemoryMiB": {
					"Min": 4
				}
			}
		}]
	}],
	"TargetCapacitySpecification": {
		"TotalTargetCapacity": 20,
		"DefaultTargetCapacityType": "spot"
	},
	"Type": "instant"
}

Os parâmetros para a seleção de tipo de instância baseada nos atributos são especificados na estrutura InstanceRequirements. Neste exemplo, dois atributos são especificados:

  • VCpuCount: é especificado um mínimo de 2 vCPUs. Como nenhum máximo é especificado, não há limite máximo.

  • MemoryMiB: é especificado um mínimo de 4 MiB de memória. Como nenhum máximo é especificado, não há limite máximo.

Qualquer tipo de instância que tenha 2 ou mais vCPUs e 4 MiB ou mais de memória será identificado. Porém, a estratégia proteção de preços e de alocação pode excluir alguns tipos de instância quando a Frota do EC2 provisiona a frota.

Para obter uma lista e descrições de todos os atributos que você pode especificar, consulte InstanceRequirements na Amazon EC2 API Reference (Referência de API do Amazon EC2).

nota

Quando InstanceRequirements for incluído na configuração da frota, InstanceType e WeightedCapacity devem ser excluídos; eles não podem determinar a configuração da frota ao mesmo tempo que os atributos da instância.

O JSON também contém a seguinte configuração de frota:

  • "AllocationStrategy": "price-capacity-optimized": a estratégia de alocação para as instâncias spot na frota.

  • "LaunchTemplateName": "my-launch-template", "Version": "1": o modelo de inicialização contém algumas informações de configuração da instância, mas se algum tipo de instância for especificado, ele será substituído pelos atributos especificados em InstanceRequirements.

  • "TotalTargetCapacity": 20: a capacidade visada é de 20 instâncias.

  • "DefaultTargetCapacityType": "spot": a capacidade padrão é instâncias spot.

  • "Type": "instant": o tipo de solicitação para a frota é instant.

Criar uma frota spot com seleção de tipo de instância baseada em atributos

É possível configurar uma frota para usar a seleção de tipo de instância baseada em atributos usando o console do Amazon EC2 ou a AWS CLI.

Criar uma frota spot usando o console

Para configurar uma frota spot para seleção de tipo de instância baseada em atributos (console)

  1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.

  2. No painel de navegação, escolha Spot Requests (Solicitações de spot) e escolha Request Spot Instances (Solicitar instâncias spot).

  3. Siga as etapas para criar um frota spot. Para ter mais informações, consulte Criar uma solicitação de frota spot usando parâmetros definidos (console).

    Ao criar a frota spot, configure a frota para seleção de tipo de instância baseada em atributos da seguinte forma:

    1. Em Instance type requirements (Requisitos de tipo de instância), escolha Specify instance attributes that match your compute requirements (Especificar atributos de instância que correspondam aos requisitos de computação).

    2. Em vCPUs, insira o número mínimo e máximo desejado de vCPUs. Para não especificar nenhum limite, selecione No minimum (Sem mínimo), No maximum (Sem máximo) ou ambos.

    3. Em Memory (GiB) (Memória), insira a quantidade mínima e máxima de memória desejada. Para não especificar nenhum limite, selecione No minimum (Sem mínimo), No maximum (Sem máximo) ou ambos.

    4. (Opcional) Em Additional instance attributes (Atributos de instância adicionais), você pode, opcionalmente, especificar um ou mais atributos para expressar seus requisitos de computação com mais detalhes. Cada atributo adicional inclui mais restrições à solicitação.

    5. (Opcional) Expanda Preview matching instance types (Previsualizar os tipos de instância correspondentes) para visualizar os tipos de instância que têm os atributos especificados.

Crie uma frota spot usando a AWS CLI

Para configurar uma frota spot para seleção de tipo de instância baseada em atributos usando a AWS CLI

Use o comando request-spot-fleet para criar uma solicitação de frota spot. Especifique a configuração da frota em um arquivo JSON.

aws ec2 request-spot-fleet \
    --region us-east-1 \
    --spot-fleet-request-config file://file_name.json

Exemplo de arquivo file_name.json

O exemplo a seguir contém os parâmetros que configuram uma frota spot para usar a seleção de tipo de instância baseada em atributos e é seguido de um texto explicativo.

{
	"AllocationStrategy": "priceCapacityOptimized",
	"TargetCapacity": 20,
	"Type": "request",
	"LaunchTemplateConfigs": [{
		"LaunchTemplateSpecification": {
			"LaunchTemplateName": "my-launch-template",
			"Version": "1"
		},
		"Overrides": [{
			"InstanceRequirements": {
				"VCpuCount": {
					"Min": 2
				},
				"MemoryMiB": {
					"Min": 4
				}
			}
		}]
	}]
}

Os parâmetros para a seleção de tipo de instância baseada nos atributos são especificados na estrutura InstanceRequirements. Neste exemplo, dois atributos são especificados:

  • VCpuCount: é especificado um mínimo de 2 vCPUs. Como nenhum máximo é especificado, não há limite máximo.

  • MemoryMiB: é especificado um mínimo de 4 MiB de memória. Como nenhum máximo é especificado, não há limite máximo.

Qualquer tipo de instância que tenha 2 ou mais vCPUs e 4 MiB ou mais de memória será identificado. Porém, a estratégia proteção de preços e de alocação pode excluir alguns tipos de instância quando a frota spot provisiona a frota.

Para obter uma lista e descrições de todos os atributos que você pode especificar, consulte InstanceRequirements na Amazon EC2 API Reference (Referência de API do Amazon EC2).

nota

Quando InstanceRequirements for incluído na configuração da frota, InstanceType e WeightedCapacity devem ser excluídos; eles não podem determinar a configuração da frota ao mesmo tempo que os atributos da instância.

O JSON também contém a seguinte configuração de frota:

  • "AllocationStrategy": "priceCapacityOptimized": a estratégia de alocação para as instâncias spot na frota.

  • "LaunchTemplateName": "my-launch-template", "Version": "1": o modelo de inicialização contém algumas informações de configuração da instância, mas se algum tipo de instância for especificado, ele será substituído pelos atributos especificados em InstanceRequirements.

  • "TargetCapacity": 20: a capacidade visada é de 20 instâncias.

  • "Type": "request": o tipo de solicitação para a frota é request.

Exemplos de configurações de frota do EC2 que são válidas e não válidas

Se você usar a AWS CLI para criar uma Frota do EC2, deve garantir que a configuração de frota seja válida. Exemplos de configurações que são válidas e não válidas.

As configurações são consideradas não válidas quando contiverem o seguinte:

  • Uma única estrutura de Overrides com InstanceRequirements e InstanceType

  • Duas estruturas de Overrides, uma com InstanceRequirements e outra com InstanceType

  • Duas estruturas de InstanceRequirements com valores de atributo sobrepostos na mesma LaunchTemplateSpecification

Configuração válida: modelo de lançamento único com substituições

A configuração a seguir é válida. Ela contém um modelo de lançamento e uma estrutura de Overrides contendo uma estrutura de InstanceRequirements. A seguir está um texto explicativo do exemplo de configuração.

{
        "LaunchTemplateConfigs": [
        {
            "LaunchTemplateSpecification": {
                "LaunchTemplateName": "My-launch-template",
                "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 2,
                            "Max": 8
                        },
                        "MemoryMib": {
                            "Min": 0,
                            "Max": 10240
                        },
                        "MemoryGiBPerVCpu": {
                            "Max": 10000
                        },
                        "RequireHibernateSupport": true
                    }
                }
            ]
        }
    ],
    "TargetCapacitySpecification": {
        "TotalTargetCapacity": 5000,
        "DefaultTargetCapacityType": "spot",
        "TargetCapacityUnitType": "vcpu"
        }
    }
}
InstanceRequirements

Para usar a seleção de instância baseada em atributos, você deve incluir a estrutura de InstanceRequirements na configuração de frota e especificar os atributos desejados para as instâncias da frota.

No exemplo anterior, os seguintes atributos de instância foram especificados:

  • VCpuCount: os tipos de instância devem ter no mínimo 2 e no máximo 8 vCPUs.

  • MemoryMiB: os tipos de instância devem ter no máximo 10.240 MiB de memória. Um mínimo de 0 indica que não há limite mínimo.

  • MemoryGiBPerVCpu: os tipos de instância devem ter no máximo 10.000 GiB de memória. O parâmetro Min é opcional. Ao omiti-lo, você indica que não há limite mínimo.

TargetCapacityUnitType

O parâmetro TargetCapacityUnitType especifica a unidade da capacidade-alvo. No exemplo, a capacidade-alvo é 5000 e o tipo de unidade de capacidade-alvo é vcpu, que juntos especificam uma capacidade-alvo desejada de 5000 vCPUs. A Frota do EC2 iniciará instâncias suficientes para que o número total de vCPUs na frota seja 5.000 vCPUs.

Configuração válida: modelo de lançamento único com vários InstanceRequirements

A configuração a seguir é válida. Ela contém um modelo de lançamento e uma estrutura de Overrides contendo duas estruturas de InstanceRequirements. Os atributos especificados em InstanceRequirements são válidos porque os valores não se sobrepõem: a primeira estrutura de InstanceRequirements especifica um VCpuCount de 0 a 2 vCPUs, enquanto a segunda estrutura de InstanceRequirements especifica de 4 a 8 vCPUs.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 4,
                            "Max": 8
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
        "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Configuração válida: dois modelos de lançamento com substituições em cada

A configuração a seguir é válida. Ela contém dois modelos de lançamento, cada um deles com uma estrutura de Overrides contendo uma estrutura de InstanceRequirements. Essa configuração é útil para oferecer suporte às arquiteturas arm e x86 na mesma frota.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "armLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "x86LaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
         "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Configuração válida: somente InstanceRequirements especificados, sem valores de atributo sobrepostos

A configuração a seguir é válida. Ela contém duas estruturas de LaunchTemplateSpecification, cada uma com um modelo de lançamento e uma estrutura Overrides contendo uma estrutura de InstanceRequirements. Os atributos especificados em InstanceRequirements são válidos porque os valores não se sobrepõem: a primeira estrutura de InstanceRequirements especifica um VCpuCount de 0 a 2 vCPUs, enquanto a segunda estrutura de InstanceRequirements especifica de 4 a 8 vCPUs.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            },
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyOtherLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 4,
                            "Max": 8
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
        "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Configuração não válida: Overrides contémInstanceRequirements e InstanceType

A configuração a seguir não é válida. A estrutura de Overrides contém InstanceRequirements e InstanceType. Em Overrides, você pode especificar InstanceRequirements ou InstanceType, mas não ambos.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                    "InstanceType": "m5.large"
                }
              ]
            }
        ],
        "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Configuração não válida: duas Overrides contêm InstanceRequirements e InstanceType

A configuração a seguir não é válida. As estruturas Overrides contêm InstanceRequirements e InstanceType. É possível especificar InstanceRequirements ou InstanceType, mas não ambos, mesmo que estejam em estruturas de Overrides diferentes.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            },
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyOtherLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceType": "m5.large"
                }
              ]
            }
        ],
         "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Configuração não válida: valores de atributo sobrepostos

A configuração a seguir não é válida. As duas estruturas de InstanceRequirements contêm "VCpuCount": {"Min": 0, "Max": 2}. Os valores desses atributos se sobrepõem, o que resultará em grupos de capacidade duplicados.

{
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    },
                    {
                      "InstanceRequirements": {
                          "VCpuCount": {
                              "Min": 0,
                              "Max": 2
                          },
                          "MemoryMiB": {
                              "Min": 0
                          }
                      }
                  }
                }
              ]
            }
        ],
         "TargetCapacitySpecification": {
            "TotalTargetCapacity": 1,
            "DefaultTargetCapacityType": "spot"
        }
    }
}

Exemplos de configurações de frota spot que são válidas e não válidas

Se você usar a AWS CLI para criar uma frota spot, deverá se certificar de que a configuração da frota seja válida. Exemplos de configurações que são válidas e não válidas.

As configurações são consideradas não válidas quando contiverem o seguinte:

  • Uma única estrutura de Overrides com InstanceRequirements e InstanceType

  • Duas estruturas de Overrides, uma com InstanceRequirements e outra com InstanceType

  • Duas estruturas de InstanceRequirements com valores de atributo sobrepostos na mesma LaunchTemplateSpecification

Configuração válida: modelo de lançamento único com substituições

A configuração a seguir é válida. Ela contém um modelo de lançamento e uma estrutura de Overrides contendo uma estrutura de InstanceRequirements. A seguir está um texto explicativo do exemplo de configuração.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
        {
            "LaunchTemplateSpecification": {
                "LaunchTemplateName": "My-launch-template",
                "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 2,
                            "Max": 8
                        },
                        "MemoryMib": {
                            "Min": 0,
                            "Max": 10240
                        },
                        "MemoryGiBPerVCpu": {
                            "Max": 10000
                        },
                        "RequireHibernateSupport": true
                    }
                }
            ]
        }
    ],
        "TargetCapacity": 5000,
            "OnDemandTargetCapacity": 0,
            "TargetCapacityUnitType": "vcpu"
    }
}
InstanceRequirements

Para usar a seleção de instância baseada em atributos, você deve incluir a estrutura de InstanceRequirements na configuração de frota e especificar os atributos desejados para as instâncias da frota.

No exemplo anterior, os seguintes atributos de instância foram especificados:

  • VCpuCount: os tipos de instância devem ter no mínimo 2 e no máximo 8 vCPUs.

  • MemoryMiB: os tipos de instância devem ter no máximo 10.240 MiB de memória. Um mínimo de 0 indica que não há limite mínimo.

  • MemoryGiBPerVCpu: os tipos de instância devem ter no máximo 10.000 GiB de memória. O parâmetro Min é opcional. Ao omiti-lo, você indica que não há limite mínimo.

TargetCapacityUnitType

O parâmetro TargetCapacityUnitType especifica a unidade da capacidade-alvo. No exemplo, a capacidade-alvo é 5000 e o tipo de unidade de capacidade-alvo é vcpu, que juntos especificam uma capacidade-alvo desejada de 5000 vCPUs. A frota spot executará instâncias suficientes para que o número total de vCPUs na frota seja de 5.000 vCPUs.

Configuração válida: modelo de lançamento único com vários InstanceRequirements

A configuração a seguir é válida. Ela contém um modelo de lançamento e uma estrutura de Overrides contendo duas estruturas de InstanceRequirements. Os atributos especificados em InstanceRequirements são válidos porque os valores não se sobrepõem: a primeira estrutura de InstanceRequirements especifica um VCpuCount de 0 a 2 vCPUs, enquanto a segunda estrutura de InstanceRequirements especifica de 4 a 8 vCPUs.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 4,
                            "Max": 8
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Configuração válida: dois modelos de lançamento com substituições em cada

A configuração a seguir é válida. Ela contém dois modelos de lançamento, cada um deles com uma estrutura de Overrides contendo uma estrutura de InstanceRequirements. Essa configuração é útil para oferecer suporte às arquiteturas arm e x86 na mesma frota.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "armLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "x86LaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Configuração válida: somente InstanceRequirements especificados, sem valores de atributo sobrepostos

A configuração a seguir é válida. Ela contém duas estruturas de LaunchTemplateSpecification, cada uma com um modelo de lançamento e uma estrutura Overrides contendo uma estrutura de InstanceRequirements. Os atributos especificados em InstanceRequirements são válidos porque os valores não se sobrepõem: a primeira estrutura de InstanceRequirements especifica um VCpuCount de 0 a 2 vCPUs, enquanto a segunda estrutura de InstanceRequirements especifica de 4 a 8 vCPUs.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            },
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyOtherLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 4,
                            "Max": 8
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Configuração não válida: Overrides contémInstanceRequirements e InstanceType

A configuração a seguir não é válida. A estrutura de Overrides contém InstanceRequirements e InstanceType. Em Overrides, você pode especificar InstanceRequirements ou InstanceType, mas não ambos.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                },
                {
                    "InstanceType": "m5.large"
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Configuração não válida: duas Overrides contêm InstanceRequirements e InstanceType

A configuração a seguir não é válida. As estruturas Overrides contêm InstanceRequirements e InstanceType. É possível especificar InstanceRequirements ou InstanceType, mas não ambos, mesmo que estejam em estruturas de Overrides diferentes.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    }
                }
              ]
            },
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyOtherLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceType": "m5.large"
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Configuração não válida: valores de atributo sobrepostos

A configuração a seguir não é válida. As duas estruturas de InstanceRequirements contêm "VCpuCount": {"Min": 0, "Max": 2}. Os valores desses atributos se sobrepõem, o que resultará em grupos de capacidade duplicados.

{
    "SpotFleetRequestConfig": {
        "AllocationStrategy": "priceCapacityOptimized",
        "ExcessCapacityTerminationPolicy": "default",
        "IamFleetRole": "arn:aws:iam::000000000000:role/aws-ec2-spot-fleet-tagging-role",
        "LaunchTemplateConfigs": [
            {
                "LaunchTemplateSpecification": {
                    "LaunchTemplateName": "MyLaunchTemplate",
                    "Version": "1"
                },
                "Overrides": [
                {
                    "InstanceRequirements": {
                        "VCpuCount": {
                            "Min": 0,
                            "Max": 2
                        },
                        "MemoryMiB": {
                            "Min": 0
                        }
                    },
                    {
                      "InstanceRequirements": {
                          "VCpuCount": {
                              "Min": 0,
                              "Max": 2
                          },
                          "MemoryMiB": {
                              "Min": 0
                          }
                      }
                  }
                }
              ]
            }
        ],
        "TargetCapacity": 1,
        "OnDemandTargetCapacity": 0,
        "Type": "maintain"
    }
}

Previsualizar os tipos de instância com os atributos especificados

É possível usar o comando get-instance-types-de-instance-requirements para previsualizar os tipos de instância que correspondem aos atributos especificados por você. Isso é especialmente útil para determinar quais atributos especificar na configuração da solicitação sem iniciar nenhuma instância. Observe que o comando não considera a capacidade disponível.

Para previsualizar uma lista de tipos de instância especificando atributos usando a AWS CLI

  1. (Opcional) Para gerar todos os atributos possíveis que podem ser especificados, use o comando get-instance-types-de-instance-requirements e o parâmetro --generate-cli-skeleton. Opcionalmente, você pode direcionar a saída para um arquivo e salvá-lo usando input > attributes.json.

    aws ec2 get-instance-types-from-instance-requirements \
    --region us-east-1 \
    --generate-cli-skeleton input > attributes.json

    Saída esperada

    {
    "DryRun": true,
    "ArchitectureTypes": [
        "i386"
    ],
    "VirtualizationTypes": [
        "hvm"
    ],
    "InstanceRequirements": {
        "VCpuCount": {
            "Min": 0,
            "Max": 0
        },
        "MemoryMiB": {
            "Min": 0,
            "Max": 0
        },
        "CpuManufacturers": [
            "intel"
        ],
        "MemoryGiBPerVCpu": {
            "Min": 0.0,
            "Max": 0.0
        },
        "ExcludedInstanceTypes": [
            ""
        ],
        "InstanceGenerations": [
            "current"
        ],
        "SpotMaxPricePercentageOverLowestPrice": 0,
        "OnDemandMaxPricePercentageOverLowestPrice": 0,
        "BareMetal": "included",
        "BurstablePerformance": "included",
        "RequireHibernateSupport": true,
        "NetworkInterfaceCount": {
            "Min": 0,
            "Max": 0
        },
        "LocalStorage": "included",
        "LocalStorageTypes": [
            "hdd"
        ],
        "TotalLocalStorageGB": {
            "Min": 0.0,
            "Max": 0.0
        },
        "BaselineEbsBandwidthMbps": {
            "Min": 0,
            "Max": 0
        },
        "AcceleratorTypes": [
            "gpu"
        ],
        "AcceleratorCount": {
            "Min": 0,
            "Max": 0
        },
        "AcceleratorManufacturers": [
            "nvidia"
        ],
        "AcceleratorNames": [
            "a100"
        ],
        "AcceleratorTotalMemoryMiB": {
            "Min": 0,
            "Max": 0
        },
        "NetworkBandwidthGbps": {
            "Min": 0.0,
            "Max": 0.0
        },
        "AllowedInstanceTypes": [
            ""
        ]
    },
    "MaxResults": 0,
    "NextToken": ""
}

  2. Crie um arquivo de configuração JSON usando a saída da etapa anterior e configure-o da seguinte forma:

    nota

    Você deve fornecer valores para ArchitectureTypes, VirtualizationTypes, VCpuCount e MemoryMiB. É possível omitir os outros atributos; quando omitidos, os valores padrão são usados.

    Para obter uma descrição de cada atributo e seus valores padrão, consulte get-instance-types-from-instance-requirements.

    1. Em ArchitectureTypes, especifique um ou mais tipos de arquitetura de processador.

    2. Em VirtualizationTypes, especifique um ou mais tipos de virtualização.

    3. Em VCpuCount, especifique o número mínimo e máximo de vCPUs. Para não especificar nenhum limite mínimo, em Min, especifique 0. Para não especificar nenhum limite máximo, omita o parâmetro Max.

    4. Em MemoryMiB, especifique a quantidade mínima e máxima de memória em MiB. Para não especificar nenhum limite mínimo, em Min, especifique 0. Para não especificar nenhum limite máximo, omita o parâmetro Max.

    5. Opcionalmente, você pode especificar um ou mais dos outros atributos para restringir ainda mais a lista de tipos de instância retornados.

  3. Para previsualizar os tipos de instância que têm os atributos que você especificou no arquivo JSON, use o comando get-instance-types-from-instance-requirements e especifique o nome e o caminho para seu arquivo JSON usando o parâmetro --cli-input-json. Opcionalmente, você pode formatar a saída para ser exibida em formato de tabela.

    aws ec2 get-instance-types-from-instance-requirements \
    --cli-input-json file://attributes.json \
    --output table

    Exemplo de arquivo attributes.json

    Neste exemplo, os atributos necessários estão incluídos no arquivo JSON. Eles são ArchitectureTypes, VirtualizationTypes, VCpuCount e MemoryMiB. Além disso, o atributo opcional InstanceGenerations também está incluído. Observe que para MemoryMiB, o valor Max pode ser omitido para indicar que não há limite.

    {
    
    "ArchitectureTypes": [
        "x86_64"
    ],
    "VirtualizationTypes": [
        "hvm"
    ],
    "InstanceRequirements": {
        "VCpuCount": {
            "Min": 4,
            "Max": 6
        },
        "MemoryMiB": {
            "Min": 2048
        },
        "InstanceGenerations": [
            "current"
        ]
    }
}

    Exemplo de saída

    ------------------------------------------
|GetInstanceTypesFromInstanceRequirements|
+----------------------------------------+
||             InstanceTypes            ||
|+--------------------------------------+|
||             InstanceType             ||
|+--------------------------------------+|
||  c4.xlarge                           ||
||  c5.xlarge                           ||
||  c5a.xlarge                          ||
||  c5ad.xlarge                         ||
||  c5d.xlarge                          ||
||  c5n.xlarge                          ||
||  d2.xlarge                           ||
...

  4. Após identificar os tipos de instância que atendem às suas necessidades, anote os atributos de instância usados para que poder usá-los ao configurar a solicitação de frota.