Importação Automática

Como funciona

A Importação Automática aceita um arquivo JSON no formato gerado pela engine de discovery do TAINUX Automation (playbooks Ansible). O sistema lê o JSON, mapeia os campos para o modelo de Aplicação e cria ou atualiza o registro no banco de dados.

Acessar a importação

Menu lateral → Automation → Import, ou acesse /automation/import. Requer permissão applications.create.

Fluxo de importação

Selecione o arquivo JSON

Arraste e solte o arquivo na área de upload ou clique para selecionar. Apenas arquivos .json são aceitos.
Visualize o preview

O sistema valida o JSON e exibe um preview com os campos que serão importados: nome, hostname, OS, stack, IPs, portas, memória, CPU, disco, entre outros. Também indica se a aplicação já existe no sistema.
Escolha a ação

Se a aplicação já existir, escolha entre Criar nova (duplicar) ou Atualizar existente (sobrescrever metadados).
Confirme a importação

Clique em "Import Application". O sistema cria ou atualiza o registro e redireciona para a página da aplicação.

Estrutura do JSON de discovery

O JSON gerado pelos playbooks Ansible de discovery segue a estrutura abaixo:

{
  "hostname": "app-server-01",
  "fqdn": "app-server-01.empresa.com",
  "os": {
    "family": "RedHat",
    "distribution": "Red Hat Enterprise Linux",
    "version": "9.3",
    "kernel": "5.14.0-362.8.1.el9_3.x86_64",
    "architecture": "x86_64"
  },
  "hardware": {
    "cpu_cores": 8,
    "memory_mb": 16384,
    "disk_gb": 200
  },
  "network": {
    "interfaces": [
      { "name": "eth0", "ip": "10.0.1.50", "mac": "52:54:00:ab:cd:ef" }
    ],
    "listening_ports": [8080, 5432, 6379]
  },
  "software": {
    "language": "Java",
    "framework": "Spring Boot",
    "language_version": "17",
    "database": "PostgreSQL",
    "database_version": "14",
    "web_server": "Embedded Tomcat",
    "cache": "Redis",
    "queue": "RabbitMQ"
  },
  "application": {
    "name": "Serviço de Notificações",
    "description": "Microserviço de envio de notificações push e e-mail",
    "port": 8080,
    "has_dockerfile": false,
    "has_k8s_manifests": false,
    "has_cicd": true,
    "has_health_checks": true,
    "is_stateless": true,
    "externalized_config": true
  },
  "compliance": ["LGPD"],
  "environment": "production"
}

Mapeamento de campos

Campo JSON	Campo no sistema
`application.name`	`name`
`hostname`	`hostname`
`os.distribution` + `os.version`	`os_type`, `os_version`
`os.kernel`	`kernel_version`
`hardware.cpu_cores`	`cpu_cores`
`hardware.memory_mb` ÷ 1024	`memory_gb`
`hardware.disk_gb`	`disk_gb`
`network.interfaces`	`network_interfaces` (JSON)
`network.listening_ports`	`listening_ports` (JSON)
`software.language`	`language`
`software.framework`	`framework`
`software.database`	`database`
`software.cache`	`cache`
`software.queue`	`queue`
`software.web_server`	`web_server`
`application.has_dockerfile`	`has_dockerfile`
`application.has_cicd`	`has_cicd`
`application.is_stateless`	`is_stateless`
`compliance`	`compliance_tags`
`environment`	`environment`

Detecção de duplicados

O sistema detecta se a aplicação já existe usando o campo hostname como chave de matching. Se um registro com o mesmo hostname for encontrado:

O preview mostra o aviso "Application already exists" com o nome do registro existente
O usuário pode escolher criar uma nova ou atualizar a existente

Playbooks Ansible de discovery

Os JSONs de discovery são gerados pelos playbooks disponíveis no repositório TAINUX Automation. Os playbooks coletam as informações do servidor alvo e exportam o JSON no formato esperado pela plataforma.

# Exemplo de execução do playbook de discovery
ansible-playbook discovery.yml \
  -i inventory/production \
  -l app-server-01 \
  --extra-vars "output_dir=/tmp/discovery"

# O JSON é gerado em:
# /tmp/discovery/app-server-01.json

Dica Execute o discovery em lote para todo o inventário de servidores e importe os JSONs um a um na plataforma. Futuramente será suportada a importação em batch de múltiplos JSONs.