Agregar dados do inventário - AWS Systems Manager
Agregar dados de tipos específicosUsar grupos

Agregar dados do inventário

Depois de configurar os nós gerenciados para o AWS Systems Manager Inventory, você poderá visualizar as contagens agregadas dos dados do inventário. Por exemplo, digamos que você configurou dezenas ou centenas de nós gerenciados para coletar o tipo de inventário da AWS:Application. Usando as informações desta seção, você pode ver uma contagem exata de quantos estão configurados para coletar esses dados.

Você também pode ver detalhes específicos do inventário por meio da agregação por tipo de dados. Por exemplo, o tipo de inventário AWS:InstanceInformation coleta informações da plataforma do sistema operacional com o tipo de dados Platform. Agregando dados pelo tipo de dados da Platform, você pode ver rapidamente quantos nós estão executando o Windows e quantos estão executando o macOS.

Os procedimentos desta seção descrevem como visualizar as contagens agregadas de dados do inventário usando a AWS Command Line Interface (AWS CLI). Você também pode visualizar contagens agregadas pré-configuradas no console do AWS Systems Manager na página Inventory. Esses painéis pré-configurados são chamados de Inventory Insights (Visões do inventário) e oferecem correção com um clique dos problemas de configuração do inventário.

Observe os seguintes detalhes importantes sobre as contagens de agregação de dados do inventário:

  • Se você encerrar um nó gerenciado configurado para coletar dados de inventário, o Systems Manager reterá os dados do inventário por 30 dias e depois os excluirá. Para nós em execução, os dados de inventário com mais de 30 dias são excluídos pelos sistemas. Se você precisar armazenar dados do inventário por mais de 30 dias, você poderá usar o AWS Config para registrar o histórico ou consultar e fazer upload dos dados periodicamente em um bucket do Amazon Simple Storage Service (Amazon S3).

  • Se um nó foi configurado anteriormente para relatar um determinado tipo de dados do inventário, por exemplo, AWS:Network, e você alterar a configuração mais tarde para interromper a coleta desse tipo, as contagens de agregação continuará a mostrar os dados do AWS:Network até que o nó seja encerrado, e 30 dias tenham passado.

Para obter informações sobre como configurar rapidamente e coletar dados do inventário de todos os nós em uma determinada Conta da AWS (e de qualquer nó futuro que possa ser criado nessa conta), consulte Inventário de todos os nós gerenciados na sua Conta da AWS.

Agregar dados do inventário para ver a contagem de nós gerenciados que coletam tipos de dados específicos

Use a ação da API GetInventory do AWS Systems Manager para visualizar as contagens agregadas dos nós que coletam um ou mais tipos de inventário e tipos de dados. Por exemplo, o tipo de inventário AWS:InstanceInformation permite visualizar um agregado de sistemas operacionais usando a operação da API GetInventory com o tipo de dados AWS:InstanceInformation.PlatformType. Este é um exemplo do comando e saída da AWS CLI:

aws ssm get-inventory --aggregators "Expression=AWS:InstanceInformation.PlatformType"

O sistema retorna informações como estas.

{
   "Entities":[
      {
         "Data":{
            "AWS:InstanceInformation":{
               "Content":[
                  {
                     "Count":"7",
                     "PlatformType":"windows"
                  },
                  {
                     "Count":"5",
                     "PlatformType":"linux"
                  }
               ]
            }
         }
      }
   ]
}
Conceitos básicos

Determine os tipos de inventário e os tipos de dados dos quais você deseja visualizar contagens. É possível visualizar uma lista de tipos de inventário e tipos de dados compatíveis com a agregação executando o comando a seguir na AWS CLI.

aws ssm get-inventory-schema --aggregator

O comando retorna uma lista JSON de tipos de inventário e tipos de dados compatíveis com a agregação. O campo TypeName mostra os tipos de inventário compatíveis. E o campo Name (Nome) mostra cada tipo de dados. Por exemplo, na lista a seguir, o tipo de inventário AWS:Application inclui tipos de dados para Name e Version.

{
    "Schemas": [
        {
            "TypeName": "AWS:Application",
            "Version": "1.1",
            "DisplayName": "Application",
            "Attributes": [
                {
                    "DataType": "STRING",
                    "Name": "Name"
                },
                {
                    "DataType": "STRING",
                    "Name": "Version"
                }
            ]
        },
        {
            "TypeName": "AWS:InstanceInformation",
            "Version": "1.0",
            "DisplayName": "Platform",
            "Attributes": [
                {
                    "DataType": "STRING",
                    "Name": "PlatformName"
                },
                {
                    "DataType": "STRING",
                    "Name": "PlatformType"
                },
                {
                    "DataType": "STRING",
                    "Name": "PlatformVersion"
                }
            ]
        },
        {
            "TypeName": "AWS:ResourceGroup",
            "Version": "1.0",
            "DisplayName": "ResourceGroup",
            "Attributes": [
                {
                    "DataType": "STRING",
                    "Name": "Name"
                }
            ]
        },
        {
            "TypeName": "AWS:Service",
            "Version": "1.0",
            "DisplayName": "Service",
            "Attributes": [
                {
                    "DataType": "STRING",
                    "Name": "Name"
                },
                {
                    "DataType": "STRING",
                    "Name": "DisplayName"
                },
                {
                    "DataType": "STRING",
                    "Name": "ServiceType"
                },
                {
                    "DataType": "STRING",
                    "Name": "Status"
                },
                {
                    "DataType": "STRING",
                    "Name": "StartType"
                }
            ]
        },
        {
            "TypeName": "AWS:WindowsRole",
            "Version": "1.0",
            "DisplayName": "WindowsRole",
            "Attributes": [
                {
                    "DataType": "STRING",
                    "Name": "Name"
                },
                {
                    "DataType": "STRING",
                    "Name": "DisplayName"
                },
                {
                    "DataType": "STRING",
                    "Name": "FeatureType"
                },
                {
                    "DataType": "STRING",
                    "Name": "Installed"
                }
            ]
        }
    ]
}

Você pode agregar dados para qualquer um dos tipos de inventário listados criando um comando que use a seguinte sintaxe:

aws ssm get-inventory --aggregators "Expression=InventoryType.DataType"

Aqui estão alguns exemplos.

Exemplo 1

Este exemplo agrega uma contagem das funções do Windows usadas por seus nós.

aws ssm get-inventory --aggregators "Expression=AWS:WindowsRole.Name"

Exemplo 2

Este exemplo agrega uma contagem das aplicações instaladas em seus nós.

aws ssm get-inventory --aggregators "Expression=AWS:Application.Name"
Combinar vários agregadores

Também é possível combinar vários tipos de inventário e tipos de dados em um comando para ajudar a entender melhor os dados. Aqui estão alguns exemplos.

Exemplo 1

Este exemplo agrega uma contagem dos tipos de sistema operacional usados pelos nós. Ele também retorna o nome específico dos sistemas operacionais.

aws ssm get-inventory --aggregators '[{"Expression": "AWS:InstanceInformation.PlatformType", "Aggregators":[{"Expression": "AWS:InstanceInformation.PlatformName"}]}]'

Exemplo 2

Este exemplo agrega uma contagem das aplicações em execução em seus nós e a versão específica de cada uma.

aws ssm get-inventory --aggregators '[{"Expression": "AWS:Application.Name", "Aggregators":[{"Expression": "AWS:Application.Version"}]}]'

Se preferir, você pode criar uma expressão de agregação com um ou mais tipos de inventário e tipos de dados em um arquivo JSON e chamar o arquivo na AWS CLI. O JSON no arquivo deve usar a seguinte sintaxe:

[
       {
           "Expression": "string",
           "Aggregators": [
               {
                  "Expression": "string"
               }
           ]
       }
]

Você deve salvar o arquivo com a extensão .json.

Veja a seguir um exemplo que usa vários tipos de inventário e tipos de dados.

[
       {
           "Expression": "AWS:Application.Name",
           "Aggregators": [
               {
                   "Expression": "AWS:Application.Version",
                   "Aggregators": [
                     {
                     "Expression": "AWS:InstanceInformation.PlatformType"
                     }
                   ]
               }
           ]
       }
]

Use o comando a seguir para chamar o arquivo na AWS CLI. 

aws ssm get-inventory --aggregators file://file_name.json

O comando retorna informações como as seguintes.

{"Entities": 
 [
   {"Data": 
     {"AWS:Application": 
       {"Content": 
         [
           {"Count": "3", 
            "PlatformType": "linux", 
            "Version": "2.6.5", 
            "Name": "audit-libs"}, 
           {"Count": "2", 
            "PlatformType": "windows", 
            "Version": "2.6.5", 
            "Name": "audit-libs"}, 
           {"Count": "4", 
            "PlatformType": "windows", 
            "Version": "6.2.8", 
            "Name": "microsoft office"}, 
           {"Count": "2", 
            "PlatformType": "windows", 
            "Version": "2.6.5", 
            "Name": "chrome"}, 
           {"Count": "1", 
            "PlatformType": "linux", 
            "Version": "2.6.5", 
            "Name": "chrome"}, 
           {"Count": "2", 
            "PlatformType": "linux", 
            "Version": "6.3", 
            "Name": "authconfig"}
         ]
       }
     }, 
    "ResourceType": "ManagedInstance"}
 ]
}

Agregar dados do inventário com grupos para ver quais nós gerenciados estão e quais não estão configurados para coletar um tipo de inventário

Os grupos do Systems Manager Inventory permitem que você veja rapidamente uma contagem de quais nós gerenciados estão e quais não estão configurados para coletar um ou mais tipos de inventário. Com grupos, você especifica um ou mais tipos de inventário e um filtro que usa o operador exists.

Por exemplo, digamos que você tenha quatro nós gerenciados configurados para coletar os seguintes tipos de inventário:

  • Nó 1: AWS:Application

  • Nó 2: AWS:File

  • Nó 3: AWS:Application, AWS:File

  • Nó 4: AWS:Network

Você pode executar o seguinte comando na AWS CLI para ver quantos nós estão configurados para coletar os tipos de inventário AWS:Application e AWS:File inventory. A resposta também retorna uma contagem dos nós que não estão configurados para coletar esses dois tipos de inventário.

aws ssm get-inventory --aggregators 'Groups=[{Name=ApplicationAndFile,Filters=[{Key=TypeName,Values=[AWS:Application],Type=Exists},{Key=TypeName,Values=[AWS:File],Type=Exists}]}]'

A resposta do comando mostra que apenas um nó gerenciado está configurado para coletar os tipos de inventário AWS:Application e AWS:File.

{
   "Entities":[
      {
         "Data":{
            "ApplicationAndFile":{
               "Content":[
                  {
                     "notMatchingCount":"3"
                  },
                  {
                     "matchingCount":"1"
                  }
               ]
            }
         }
      }
   ]
}
nota

Os grupos não retornam contagens de tipo de dados. Além disso, você não pode detalhar os resultados para ver os IDs dos nós gerenciados que estiverem ou não configurados para coletar o tipo de inventário.

Se preferir, crie uma expressão de agregação com um ou mais tipos de inventário em um arquivo JSON e chame o arquivo na AWS CLI. O JSON no arquivo deve usar a seguinte sintaxe:

{
   "Aggregators":[
      {
         "Groups":[
            {
               "Name":"Name",
               "Filters":[
                  {
                     "Key":"TypeName",
                     "Values":[
                        "Inventory_type"
                     ],
                     "Type":"Exists"
                  },
                  {
                     "Key":"TypeName",
                     "Values":[
                        "Inventory_type"
                     ],
                     "Type":"Exists"
                  }
               ]
            }
         ]
      }
   ]
}

Você deve salvar o arquivo com a extensão .json.

Use o comando a seguir para chamar o arquivo na AWS CLI. 

aws ssm get-inventory --cli-input-json file://file_name.json
Exemplos adicionais

Os exemplos a seguir mostram como agregar dados de inventário para ver quais nós gerenciados estão e não estão configurados para coletar os tipos de inventário especificados. Estes exemplos usam a AWS CLI. Cada exemplo inclui um comando completo com filtros que você pode executar na linha de comando e um arquivo input.json de exemplo se você preferir inserir as informações em um arquivo.

Exemplo 1

Este exemplo agrega uma contagem de nós que estão e que não estão configurados para coletar os tipos de inventário AWS:Application ou AWS:File.

Execute o seguinte comando na AWS CLI.

aws ssm get-inventory --aggregators 'Groups=[{Name=ApplicationORFile,Filters=[{Key=TypeName,Values=[AWS:Application, AWS:File],Type=Exists}]}]'

Se preferir usar um arquivo, copie e cole o seguinte exemplo em um arquivo e salve-o como input.json.

{
   "Aggregators":[
      {
         "Groups":[
            {
               "Name":"ApplicationORFile",
               "Filters":[
                  {
                     "Key":"TypeName",
                     "Values":[
                        "AWS:Application",
                        "AWS:File"
                     ],
                     "Type":"Exists"
                  }
               ]
            }
         ]
      }
   ]
}

Execute o seguinte comando na AWS CLI.

aws ssm get-inventory --cli-input-json file://input.json

O comando retorna informações como as seguintes.

{
   "Entities":[
      {
         "Data":{
            "ApplicationORFile":{
               "Content":[
                  {
                     "notMatchingCount":"1"
                  },
                  {
                     "matchingCount":"3"
                  }
               ]
            }
         }
      }
   ]
}

Exemplo 2

Este exemplo agrega uma contagem de nós que estão e que não estão configurados para coletar os tipos de inventário AWS:Application, AWS:File e AWS:Network.

Execute o seguinte comando na AWS CLI.

aws ssm get-inventory --aggregators 'Groups=[{Name=Application,Filters=[{Key=TypeName,Values=[AWS:Application],Type=Exists}]}, {Name=File,Filters=[{Key=TypeName,Values=[AWS:File],Type=Exists}]}, {Name=Network,Filters=[{Key=TypeName,Values=[AWS:Network],Type=Exists}]}]'

Se preferir usar um arquivo, copie e cole o seguinte exemplo em um arquivo e salve-o como input.json.

{
   "Aggregators":[
      {
         "Groups":[
            {
               "Name":"Application",
               "Filters":[
                  {
                     "Key":"TypeName",
                     "Values":[
                        "AWS:Application"
                     ],
                     "Type":"Exists"
                  }
               ]
            },
            {
               "Name":"File",
               "Filters":[
                  {
                     "Key":"TypeName",
                     "Values":[
                        "AWS:File"
                     ],
                     "Type":"Exists"
                  }
               ]
            },
            {
               "Name":"Network",
               "Filters":[
                  {
                     "Key":"TypeName",
                     "Values":[
                        "AWS:Network"
                     ],
                     "Type":"Exists"
                  }
               ]
            }
         ]
      }
   ]
}

Execute o seguinte comando na AWS CLI.

aws ssm get-inventory --cli-input-json file://input.json

O comando retorna informações como as seguintes.

{
   "Entities":[
      {
         "Data":{
            "Application":{
               "Content":[
                  {
                     "notMatchingCount":"2"
                  },
                  {
                     "matchingCount":"2"
                  }
               ]
            },
            "File":{
               "Content":[
                  {
                     "notMatchingCount":"2"
                  },
                  {
                     "matchingCount":"2"
                  }
               ]
            },
            "Network":{
               "Content":[
                  {
                     "notMatchingCount":"3"
                  },
                  {
                     "matchingCount":"1"
                  }
               ]
            }
         }
      }
   ]
}