Seleção de tipo de instância baseada em atributos para frota spot - Amazon Elastic Compute Cloud
Como funciona a seleção de tipo de instância baseada em atributosProteção de preçoConsideraçõesCriar uma frota spot com seleção de tipo de instância baseada em atributosExemplos de configurações que são válidas e não válidasPrevisualizar os tipos de instância com os atributos especificados

Seleção de tipo de instância baseada em atributos para frota spot

Ao criar uma 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 spot iniciará 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 spot, crie uma substituição de modelo de lançamento 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 dos tipos de instâncias: quando atributos de instância são especificados em vez de tipos de instância, a frota spot pode selecionar entre uma ampla variedade de tipos de instância para iniciar instâncias spot, o que atende à Prática recomendada para instâncias spot: 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 spot iniciará as 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.

  • Desempenho 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 em um ou em 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

  • Na solicitação da 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 lançamento, e referencie o modelo de lançamento 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.

  • Em uma especificação de lançamento

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

A frota spot provisiona uma frota da seguinte maneira:

  • A frota spot identifica os tipos de instância que têm os atributos especificados.

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

  • A frota spot determina os grupos de capacidade que serão considerados ao definir de quais grupos as instâncias serão iniciadas, com base nas regiões ou zonas de disponibilidade da AWS que têm os tipos de instância correspondentes.

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

    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. Pode haver um grande número de tipos de instância com os atributos especificados, e alguns deles podem ser caros.

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

    • Para instâncias spot, a seleção de tipo de instância baseada em atributos oferece suporte às estratégias de alocação de capacityOptimizedPrioritized e capacityOptimized.

    • Para instâncias sob demanda, a seleção de tipo de instância baseada em atributos oferece suporte à estratégia de alocação lowestPrice, que garante que a frota spot iniciará as instâncias sob demanda dos grupos de capacidade menos dispendiosos.

  • 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 sua frota spot use tipos de instância que você consideraria muito caros, mesmo que atendam 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

Para especificar o limite de proteção de preço

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

  • Console

    Para especificar o limite de proteção de preço da instância sob demanda, em Additional instance attribute (Atributo de instância adicional), escolha On-demand price protection (Proteção de preços sob demanda) e Add attribute (Adicionar atributo). Em On-Demand price protection percentage (Porcentagem de proteção de preço sob demanda), 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, em Additional instance attribute (Atributos de instância adicional), escolha Spot price protection (Proteção de preço spot) e Add attribute (Adicionar atributo). Escolha um parâmetro e insira o limite de proteção de preço como uma porcentagem.

  • AWS CLI

    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 obter mais informações sobre a criação de uma frota, consulte Criar uma frota spot com seleção de tipo de instância baseada em atributos.

nota

Ao criar a frota spot, se você definir o tipo Total target capacity (Capacidade total de destino) como vCPUs ou Memory (MiB) (Memória [MiB]) (console) ou TargetCapacityUnitType para vcpu ou memory-mib (AWS CLI), o limite de proteção de preço é aplicado com base no preço por VCPU ou por memória, em vez do preço por instância.

Considerações

  • Você pode especificar tipos de instância ou atributos de instância em uma frota spot, mas não os dois 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.

  • Você pode especificar, no máximo, quatro estruturas de InstanceRequirements em uma configuração de solicitação.

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

Você pode 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 (AWS CLI)

Use o comando request-spot-fleet (AWS CLI) 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 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. Você pode 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

Você pode usar o comando get-instance-types-de-instance-requirements da AWS CLI 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. Você pode 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-de-instance-requirements na Referência da linha de comando do Amazon EC2.

    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                          ||
||  c6a.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.