CloudGraph é a ferramenta gratuita e de código aberto de API GraphQL universal e Gerenciamento de Postura de Segurança em Nuvem (CSPM) para AWS, Azure, GCP e K8s. Com o CloudGraph você obtém:

Verificações de conformidade gratuitas e sem esforço (ex.: Azure CIS 1.3.1, GCP CIS 1.2, AWS CIS 1.2, AWS CIS 1.3, AWS CIS 1.4, AWS PCI 3.2.1, AWS NIST 800-53 Rev. 4)
Inventários de ativos type-safe para todos os seus recursos em todos os seus ambientes de nuvem
Documentação gerada automaticamente e validação de consultas - saiba se sua consulta é válida antes de enviá-la!
Dados completos dos recursos, incluindo relacionamentos entre recursos para que você entenda o contexto
Instantâneos históricos dos seus dados ao longo do tempo
Um único endpoint para consultar todos os seus dados de nuvem de uma vez (ex.: obter dados AWS + GCP na mesma consulta, ou comparar o stage AWS com o prod AWS)
Dados de faturamento aprimorados (apenas AWS)
Dados CloudWatch aprimorados (apenas AWS EC2)

Cloud Graph permite que você Conheça sua nuvem em 5 minutos. Construído e mantido com carinho pela equipe da ❤️ AutoCloud ❤️

🌐 Site

💻 Documentação

💰 Receba para criar provedores CloudGraph

node-current GitHub commit activity GitHub contributors GitHub issues

Participe da conversa

Empresas incríveis usando CloudGraph**
Por que CloudGraph
Como Funciona
Autenticação e Permissões
Instalação
Início Rápido
Carregando Versões Anteriores
Serviços Suportados
Exemplos de Consultas
Ferramentas de Consulta
Comunidade
Diretrizes de Contribuição
Opções de Implantação
Versão Hospedada
Depuração
Erros Comuns
Comandos

Empresas incríveis usando CloudGraph**

** o uso não implica endosso

Por que CloudGraph

AWS, Azure e GCP fizeram um trabalho maravilhoso construindo soluções que permitem a engenheiros como nós criar sistemas para alimentar nosso mundo cada vez mais interconectado. Nos últimos 15 anos, produtos como EC2, S3, RDS e Lambda mudaram fundamentalmente a forma como pensamos sobre computação, armazenamento e bancos de dados.

Com a proliferação de Kubernetes e Serverless nos últimos 5 anos ou mais, os serviços de nuvem se tornaram cada vez mais abstratos sobre as pilhas de servidores físicos. Para os usuários finais, tudo na nuvem é apenas uma API, então não precisamos necessariamente saber como as Funções Lambda ou EKS funcionam internamente para usá-las na construção de aplicações. Com um pouco de documentação, acesso à API ou console e um tutorial, qualquer um pode criar praticamente qualquer coisa que precisar.

Essas abstrações levaram a melhorias enormes na conveniência geral e na abrangência das ofertas de serviços dos CSPs. O que antes era um processo trabalhoso, demorado e propenso a erros de provisionar novos servidores, bancos de dados ou sistemas de arquivos agora pode ser feito em segundos com apenas um clique de botão ou implantação de IAC. Como tudo é apenas uma abstração de API, quando um CSP está pronto para introduzir um novo "produto", eles simplesmente precisam expor uma nova API - sim, estou simplificando um pouco :)

Qualquer pessoa familiarizada com os CSPs sabe que as APIs de serviço são quase sempre divididas em namespaces modulares que contêm dezenas, senão centenas, de métodos de API separados para recursos individuais. Por exemplo, o serviço AWS EC2 contém mais de 500 métodos de API diferentes, com novos sendo adicionados ocasionalmente. Qualquer empresa construindo sistemas substanciais em um CSP provavelmente está usando muitos, muitos serviços diferentes.

Embora sejam uma obra-prima da arquitetura de datacenter, essa escolha de centenas de serviços e opções de configuração coloca o fardo do conhecimento sobre como usar esses serviços adequadamente diretamente sobre nós, engenheiros. Como resultado, nos vemos obrigados a nos manter constantemente atualizados e aprender sobre todas as ofertas de serviços ou novas mudanças. Isso consome uma quantidade significativa de tempo e energia mental. Como desenvolvedores, pode ser difícil, demorado e frustrante usar a AWS CLI para fazer 5 chamadas de API diferentes para descrever, por exemplo, um cluster AWS ECS, seus serviços, definições de tarefas, tarefas, definições de contêiner, etc. Frequentemente nos perdemos na documentação e precisamos usar meia dúzia de APIs para obter respostas para perguntas como "O que exatamente está sendo executado nesta VPC?"

Isso significa que AWS, Azure e GCP podem rapidamente parecer esmagadores até mesmo para arquitetos de nuvem experientes. Embora os CSPs sejam fantásticos na construção dos serviços reais que impulsionam nossos negócios, pouco progresso foi feito na simplificação da experiência do usuário do dia a dia ao consultar essas centenas de serviços de maneira sensata.

Novas soluções como a API Cloud Control para AWS tentaram criar uma interface padronizada para consultar muitos tipos diferentes de recursos da AWS. Infelizmente, o uso da API Cloud Control é severamente limitado, e os usuários ainda precisam saber como consultar seus dados corretamente. Isso significa mais tempo gasto lendo documentação e entendendo como os serviços funcionam e estão relacionados entre si.

Embora a modularidade das APIs dos CSPs seja um ótimo sistema de organização lógica e faça sentido, ela é um fardo para os usuários finais em termos de sobrecarga cognitiva e curva de aprendizado. Ter que lembrar como centenas de serviços em constante mudança funcionam e estão conectados leva a um vício em cafeína e tempo perdido fazendo investigação.

Não seria ótimo se nós, como engenheiros DevOps/Nuvem, tivéssemos uma maneira mais simples de obter nossos dados da AWS, Azure, GCP e outros? Uma que refletisse nossa necessidade de consultar facilmente qualquer dado sobre qualquer serviço em qualquer conta sem ter que passar horas em documentação ou no stack overflow?

É por essas razões que construímos o CloudGraph, a API GraphQL para tudo em nuvem. O CloudGraph extrai, normaliza, processa e enriquece seus dados de nuvem, permitindo que você acesse insights profundos em vários provedores sem esforço. Confira nosso post no blog The GraphQL API for everything para saber mais.

Como Funciona

Observe que o CloudGraph requer permissões SOMENTE LEITURA para executar e, como tal, nunca pode alterar sua infraestrutura de nuvem real. Além disso, nenhuma informação do seu ambiente de nuvem é enviada ou compartilhada com CloudGraph, AutoCloud ou qualquer terceiro.

Internamente, o CloudGraph se conecta ao(s) seu(s) provedor(es) de nuvem, absorve todos os dados de configuração, processa e armazena uma cópia desses dados para você no Dgraph. Em seguida, expõe um endpoint em http://localhost:8997 que permite escrever Consultas GraphQL contra seus dados armazenados. Essas consultas não apenas permitem que você faça qualquer coisa que faria com, por exemplo, o AWS SDK/CLI, mas também permitem executar consultas muito mais poderosas. O CloudGraph vem com ferramentas de consulta GraphQL pré-embaladas, incluindo GraphQL Playground e Altair, mas você também pode usar as suas próprias. Também inclui uma ferramenta de visualização de esquema chamada Voyager para que você entenda os relacionamentos entre as entidades.

Autenticação e Permissões

O CloudGraph atualmente suporta AWS, Azure, GCP, K8s e Tencent (vários outros em breve). O CloudGraph precisa de permissões de leitura para ingerir seus dados. Para facilitar, você pode usar as mesmas permissões que usamos internamente quando executamos o CloudGraph para alimentar o AutoCloud. Aqui estão os guias de autenticação e detalhes de como gerar credenciais para cada provedor (sinta-se à vontade para deixar de fora a configuração específica do AutoCloud):

Instalação

Requisitos do sistema

Docker

Existem 2 maneiras de instalar a CLI do CloudGraph

Homebrew (Recomendado)

Você pode instalar o CloudGraph usando homebrew com o seguinte comando: brew install cloudgraphdev/tap/cg

NPM

Requer Node 16+

Use este comando para instalar e atualizar o CloudGraph para a versão mais recente.```bash npm i -g @cloudgraph/cli

<p align="center">
  <a href="https://github.com/cloudgraphdev/cli/raw/main/docs/images/install.gif">
    <img alt="install" src="https://raw.githubusercontent.com/cloudgraphdev/cli/main/docs/images/install.gif" width="95%" style="display: block; margin: auto"/>
  </a>
</p>

<br/>

Você pode então adicionar os provedores que deseja (links para repositórios de provedores: [AWS](https://github.com/cloudgraphdev/cloudgraph-provider-aws), [Azure](https://github.com/cloudgraphdev/cloudgraph-provider-azure), [GCP](https://github.com/cloudgraphdev/cloudgraph-provider-gcp), [K8s](https://github.com/cloudgraphdev/cloudgraph-provider-k8s), [Tencent Docs](https://github.com/cloudgraphdev/cloudgraph-provider-tencent)):```bash
cg init aws
cg init azure
cg init gcp
cg init k8s
cg init tencent

Você também pode adicionar quantos quiser de uma só vez```bash cg init aws azure gcp k8s tencent

E adicione pacotes de política de conformidade para complementar seus dados com insights de segurança instantâneos:```bash
cg policy add gcp-cis-1.2.0
cg policy add azure-cis-1.3.1
cg policy add aws-cis-1.2.0
cg policy add aws-cis-1.3.0
cg policy add aws-cis-1.2.0
cg policy add aws-pci-dss-3.2.1
cg policy add aws-nist-800-53-rev4

Você pode encontrar uma lista de pacotes de política atualmente suportados no Policy Packs repo

Início Rápido

Você pode começar a usar com três comandos simples:

```bash

cg init

1. Isso inicializa a configuração do CloudGraph. Este comando irá fazer uma série de perguntas sobre quais provedores você está usando e como deseja configurar o CloudGraph.

<p align="center">
  <a href="https://github.com/cloudgraphdev/cli/raw/main/docs/images/init.gif">
    <img alt="init" src="https://raw.githubusercontent.com/cloudgraphdev/cli/main/docs/images/init.gif" width="95%" style="display: block; margin: auto"/>
  </a>
</p>

<br/>

---

<br/>```bash
cg launch

Este comando lança uma instância do Dgraph, o graphdb que o CloudGraph usa para armazenar dados internamente. Observe que existem 2 maneiras de lançar uma instância. AMBAS exigem que o Docker esteja instalado e em execução. A solução preferida é usar nosso comando de conveniência cg launch.

Observe que se você não quiser usar este comando, por exemplo, se quiser lançar o contêiner Dgraph em modo interativo, pode usar o comando docker abaixo.```bash docker run -it -p 8995:5080 -p 8996:6080 -p 8997:8080 -p 8998:9080 -p 8999:8000 --label cloudgraph-cli-dgraph-standalone -v ~/dgraph:/dgraph --name dgraph dgraph/standalone:v21.03.1

---

<br/>```bash
cg scan

Escaneie a infraestrutura em nuvem de todos os provedores configurados. Este comando irá acessar e ler todos os metadados da sua infraestrutura em nuvem. Note que é completamente normal ver avisos e erros enquanto o comando cg scan é executado, eles geralmente são causados por problemas de permissão. Dito isso, se você encontrar erros problemáticos ao executar o CloudGraph, você pode prefixar CG_DEBUG=5 no início do seu comando, como em CG_DEBUG=5 cg scan. Isso imprimirá os logs detalhados com mais informações e salvará a saída em cg-debug.log. Por favor, compartilhe seus logs conosco abrindo uma issue no GitHub ou nos informando no nosso Slack Workspace.

É isso, você está pronto para começar a fazer consultas! A ferramenta de consulta que você selecionou durante o comando cg init será então aberta no seu navegador preferido para executar consultas, mutações e visualizações em toda a sua infraestrutura em nuvem! Observe que, se você instalou algum pacote de políticas, como AWS CIS 1.2, os dados de insight do pacote de políticas serão adicionados automaticamente aos seus dados de nuvem!

Observe que você também pode usar qualquer ferramenta de consulta GraphQL que desejar, conectando-a a http://localhost:8997/graphql.

Parando a instância do Dgraph

Para parar a instância do Dgraph (parar o contêiner dgraph) execute:

```bash cg teardown

<br />

Além disso, se desejar remover o container após pará-lo, execute:

<br />```bash
cg teardown --delete-image

Carregando Versões Anteriores

O CloudGraph armazena quantas versões anteriores dos seus dados você configurou no comando cg init. Para carregar e consultar uma versão anterior dos seus dados, basta executar o comando cg load e selecionar a versão dos dados que deseja inspecionar, como mostrado abaixo:

Serviços Suportados

Você pode encontrar a lista de serviços atualmente suportados para cada provedor nos repositórios de provedores abaixo:

Repositório do Provedor AWS

Repositório do Provedor Azure

Repositório do Provedor GCP

Repositório do Provedor K8s

Exemplos de Consultas

Link para a documentação completa: https://docs.cloudgraph.dev/overview.

Para usar o CloudGraph, você precisará estar familiarizado com GraphQL. Esta seção contém alguns exemplos de consultas para você começar, mas não é de forma alguma exaustiva. Se você puder imaginar, pode consultar! Note que você pode encontrar centenas de exemplos adicionais de consultas na documentação.

Exemplos de Sintaxe Básica de Consultas:

Nota: esta seção focará na AWS, mas as mesmas ideias se aplicam a outros provedores, como Azure e GCP

Para explicar como o CloudGraph funciona, considere a seguinte consulta que você pode executar para obter o ID e o ARN de uma única instância EC2. Note que, para fins destes exemplos, solicitaremos apenas os IDs e ARNs dos recursos AWS para manter as coisas concisas, mas você pode consultar quaisquer atributos que desejar:

```graphql query { getawsEc2( arn: "arn:aws:ec2:us-east-1:123445678997:instance/i-12345567889012234" ) { id arn } }

<br />

Esta consulta retornará um payload `JSON` que se parece com isto. Todos os exemplos a seguir seguirão o mesmo padrão:

<br />```json
{
  "data": {
    "getawsEc2": {
      "id": "i-12345567889012234",
      "arn": "arn:aws:ec2:us-east-1:123445678997:instance/i-12345567889012234"
    }
  },
  "extensions": {
    "touched_uids": 4
  }
}

Obtenha o ID e ARN de cada EC2 em todas as contas AWS que você analisou:```graphql query { queryawsEc2 { id arn } }

<br />

Obtenha o `ID` e o `ARN` de todas as instâncias `EC2` em **uma** de suas contas AWS filtrando o accountId:```graphql
query {
  queryawsEc2(filter: { accountId: { eq: "123456" } }) {
    id
    arn
  }
}

Obtenha o ID e o ARN de cada EC2 em "us-east-1" usando uma regex para pesquisar o ARN:```graphql query { queryawsEc2(filter: { arn: { regexp: "/.us-east-1./" } }) { id arn } }

<br />

Faça a mesma coisa, mas verificando se a `region` é igual a `"us-east-1"` em vez de usar uma regex:```graphql
query {
  queryawsEc2(filter: { region: { eq: "us-east-1" } }) {
    id
    arn
  }
}

Faça a mesma coisa, mas verificando se a region contém "us-east-1" no nome, em vez de usar eq:```graphql query { queryawsEc2(filter: { region: { in: "us-east-1" } }) { id arn } }

<br />

Obtenha o `ID` e o `ARN` de cada `M5` série `EC2 instance` em `"us-east-1"````graphql
query {
  queryawsEc2(
    filter: { region: { eq: "us-east-1" }, instanceType: { regexp: "/^m5a*/" } }
  ) {
    id
    arn
  }
}

Faça a mesma coisa, mas pule o primeiro resultado encontrado (ou seja, offset: 1) e depois retorne apenas os dois primeiros resultados após isso (ou seja, first: 2) e ordene esses resultados por AZ em ordem crescente (order: { asc: availabilityZone }) para que a(s) instância(s) em "us-east-1a" sejam retornadas no topo da lista.```graphql query { queryawsEc2( filter: { region: { eq: "us-east-1" }, instanceType: { regexp: "/^m5a*/" } } order: { asc: availabilityZone } first: 2 offset: 1 ) { id arn } }

<br />

Faça o mesmo, mas também inclua o `EBS Volume` que é o disco de inicialização para cada `EC2 instance`:```graphql
query {
  queryawsEc2(
    filter: { region: { eq: "us-east-1" }, instanceType: { regexp: "/^m5a*/" } }
    order: { asc: availabilityZone }
    first: 2
    offset: 1
  ) {
    id
    arn
    ebs(filter: { isBootDisk: true }, first: 1) {
      id
      arn
      isBootDisk
    }
  }
}

Faça o mesmo, mas também inclua os SGs e ALBs para cada EC2. Para os ALBs, obtenha os EC2s aos quais eles estão conectados, juntamente com o ID e ARN de cada EC2 instance encontrada (ou seja, uma consulta circular).```graphql query { queryawsEc2( filter: { region: { eq: "us-east-1" }, instanceType: { regexp: "/^m5a*/" } } order: { asc: availabilityZone } first: 2 offset: 1 ) { id arn ebs(filter: { isBootDisk: true }, first: 1) { id arn isBootDisk } securityGroups { id arn } alb { id arn ec2Instance { id arn } } } }

<br />

Obtenha cada `VPC`, os `ALBs` e `Lambdas` nessa `VPC`, e também um monte de subdados aninhados. Obtenha também cada `S3 Bucket` em `us-east-1`. Obtenha também a fila `SQS` com um `ARN` de `arn:aws:sqs:us-east-1:8499274828484:autocloud.fifo` e verifique o `approximateNumberOfMessages`. Você entendeu a ideia, CloudGraph é **extremamente** poderoso.```graphql
query {
  queryawsVpc {
    id
    arn
    alb {
      id
      arn
      ec2Instance {
        id
        arn
        ebs(filter: { isBootDisk: true }) {
          id
          arn
        }
      }
    }
    lambda {
      id
      arn
      kms {
        id
        arn
      }
    }
  }
  queryawsS3(filter: { region: { eq: "us-east-1" } }) {
    id
    arn
  }
  getawsSqs(arn: "arn:aws:sqs:us-east-1:8499274828484:autocloud.fifo") {
    approximateNumberOfMessages
  }
}

Exemplos de segurança, conformidade e governança da AWS:

Os CloudGraph Policy Packs garantem a conformidade em toda a infraestrutura existente para um determinado provedor de nuvem. Os pacotes são baseados em conjuntos de regras/benchmarks fornecidos por organizações de segurança como o Center for Internet Security com o objetivo de manter sua infraestrutura atualizada com os padrões de segurança do setor. Depois de adicionar um policy pack usando o comando cg policy add (por exemplo, cg policy add aws-cis-1.2.0), cada vez que você executar uma varredura, o CloudGraph executará automaticamente as políticas configuradas. Esses resultados serão armazenados no Dgraph e vinculados aos seus recursos existentes, facilitando a consulta dos seus resultados de conformidade juntamente com seus recursos.

Para mais informações sobre os policy packs disponíveis atualmente, visite nosso repositório de Policy Packs

Use o CloudGraph Policy Pack para AWS CIS 1.2 para consultar todas as suas descobertas do CIS em todas as suas contas AWS:```graphql query { queryawsCISFindings { id resourceId result rule { id description severity } } }

<br />

Se você quiser consultar várias descobertas de conformidade diferentes para um determinado provedor como AWS de uma vez, pode solicitá-las assim:```graphql
query {
  queryawsFindings {
    CISFindings {
      id
      resourceId
      result
      rule {
        id
        description
        severity
      }
    }
    AutoCloudFindings {
      id
      resourceId
      result
      rule {
        id
        description
        severity
      }
    }
  }
}

Para cada regra CIS, obtenha os recursos associados à regra; neste caso, estamos consultando dados de usuários IAM para ver quais passam e quais falham:```graphql query { queryawsCISFindings { id resourceId result rule { id description severity } iamUser { id arn name } } }

<br />

Se você quisesse entender as regras CIS que se aplicam a um determinado IAM User, você poderia usar a seguinte consulta:```graphql
query {
  getawsIamUser(id: "123456789") {
    name
    CISFindings {
      id
      resourceId
      result
      rule {
        id
        description
        severity
      }
    }
  }
}

Mesmo que você não tenha nenhum pacote de políticas instalado, ainda pode escrever consultas de segurança poderosas como esta para encontrar todos os EBS Volumes não criptografados:```graphql query { queryawsEbs(filter: { encrypted: false }) { id arn availabilityZone encrypted } }

<br />

Encontre todos os `S3 Buckets` públicos:```graphql
query {
  queryawsS3(filter: { access: { eq: "Public" } }) {
    id
    arn
    access
  }
}

Encontre todos os S3 Buckets que são eles próprios públicos ou que podem ter Objetos públicos neles:```graphql query { queryawsS3(filter: { not: { access: { eq: "Private" } } }) { id arn access } }

<br />

Encontre todas as chaves `KMS` em `"us-east-1"`:```graphql
query {
  queryawsKms(filter: { arn: { regexp: "/.*us-east-1.*/" } }) {
    id
    arn
    description
    keyRotationEnabled
    tags {
      key
      value
    }
  }
}

Encontre todas as instâncias burstable da série T:```graphql query { queryawsEc2(filter: { instanceType: { regexp: "/^t.*/" } }) { id arn availabilityZone instanceType } }

<br />

Encontre os `VPCs` padrão:```graphql
query {
  queryawsVpc(filter: { defaultVpc: true }) {
    id
    arn
    defaultVpc
    state
  }
}

Encontre os ALBs públicos:```graphql query { queryawsAlb(filter: { scheme: { eq: "internet-facing" } }) { id arn dnsName createdAt tags { key value } } }

<br />

Encontre todos os `EC2s`, `Lambdas` e `VPCs` que possuem um valor de `Tag` igual a `"Production"`:```graphql
query {
  queryawsTag(filter: { value: { eq: "Production" } }) {
    key
    value
    ec2Instance {
      id
      arn
    }
    lambda {
      id
      arn
    }
    vpc {
      id
      arn
    }
  }
}

Faça a mesma coisa, mas procure por ambos: key e value:```graphql query { queryawsTag( filter: { key: { eq: "Environment" }, value: { eq: "Production" } } ) { key value ec2Instance { id arn } lambda { id arn } vpc { id arn } } }

<br />

Faça a mesma coisa usando `getawsTag` em vez de `queryawsTag`. Note que ao buscar por tags usando `getawsTag` você deve especificar **tanto** a `key` quanto o `value` como `id`, como feito abaixo com `"Environment:Production"`:```graphql
query {
  getawsTag(id: "Environment:Production") {
    key
    value
    ec2Instance {
      id
      arn
    }
    lambda {
      id
      arn
    }
    vpc {
      id
      arn
    }
  }
}

Exemplos de AWS FinOps:

Note que os dados de faturamento estão atualmente disponíveis apenas para AWS. Para ingerir com sucesso dados relacionados a FinOps, você deve ter a API Cost Explorer habilitada em sua conta AWS. Você pode ver como fazer isso aqui

Obtenha o custo total da sua conta AWS nos últimos 30 dias, o custo total da sua conta AWS no mês atual, um detalhamento de cada serviço e seu custo nos últimos 30 dias, e um detalhamento de cada serviço e seu custo no mês atual, bem como os custos médios mensais e do mês atual:```graphql query { queryawsBilling { totalCostLast30Days { cost currency formattedCost } totalCostMonthToDate { cost currency formattedCost } monthToDate { name cost currency formattedCost } last30Days { name cost currency formattedCost } monthToDateDailyAverage { name cost currency formattedCost } last30DaysDailyAverage { name cost currency formattedCost } } }

<br />

Esta consulta retornará um payload `JSON` que se parece com isto:```json
{
  "data": {
    "queryawsBilling": [
      {
        "totalCostLast30Days": {
          "cost": 7088.87,
          "currency": "USD",
          "formattedCost": "$7088.87"
        },
        "totalCostMonthToDate": {
          "cost": 7089.28,
          "currency": "USD",
          "formattedCost": "$7089.28"

        },
        "monthToDate": [
          {
            "name": "Amazon Relational Database Service",
            "cost": 548.68,
            "currency": "USD",
            "formattedCost": "$548.68"
          },
          {
            "name": "Amazon Managed Streaming for Apache Kafka",
            "cost": 67.49,
            "currency": "USD",
            "formattedCost": "$67.49"
          },
          {
            "name": "Amazon OpenSearch Service",
            "cost": 1155.04,
            "currency": "USD",
            "formattedCost": "$1155.04"
          }
          ...More Services
        ],
        "last30Days": [
          {
            "name": "AWS Step Functions",
            "cost": 330.20,
            "currency": "USD",
            "formattedCost": "$330.20"
          },
          {
            "name": "Amazon Elastic Container Service for Kubernetes",
            "cost": 194.40,
            "currency": "USD",
            "formattedCost": "$194.40"
          },
          {
            "name": "AmazonCloudWatch",
            "cost": 310.54,
            "currency": "USD",
            "formattedCost": "$310.54"
          }
          ...More Services
        ],
        "monthToDateDailyAverage": [
          {
            "name": "Amazon Relational Database Service",
            "cost": 54.86,
            "currency": "USD",
            "formattedCost": "$54.86"
          },
          {
            "name": "Amazon Managed Streaming for Apache Kafka",
            "cost": 6.74,
            "currency": "USD",
            "formattedCost": "$6.74"
          },
          {
            "name": "Amazon OpenSearch Service",
            "cost": 115.50,
            "currency": "USD",
            "formattedCost": "$115.50"
          }
          ...More Services
        ],
        "last30DaysDailyAverage": [
          {
            "name": "AWS Step Functions",
            "cost": 33.01,
            "currency": "USD",
            "formattedCost": "$33.01"
          },
          {
            "name": "Amazon Elastic Container Service for Kubernetes",
            "cost": 19.44,
            "currency": "USD",
            "formattedCost": "$19.44"
          },
          {
            "name": "AmazonCloudWatch",
            "cost": 31.05,
            "currency": "USD",
            "formattedCost": "$31.05"
          }
          ...More Services
        ],
      }
    ]
  },
  "extensions": {
    "touched_uids": 212
  }
}

Obtenha cada EC2 instance na sua conta AWS junto com seu custo diário:```graphql query { queryawsEc2 { arn dailyCost { cost currency formattedCost } } }

<br />

Esta consulta retornará um payload `JSON` que se parece com isto. Todos os exemplos a seguir seguirão o mesmo padrão:```json
{
{
  "data": {
    "queryawsEc2": [
      {
        "arn": "arn:aws:ec2:us-east-1:12345678910:instance/i-0c8b3vhfgf8df923f",
        "dailyCost": {
          "cost": 2.06,
          "currency": "USD",
          "formattedCost": "$2.06"
        }
      },
      {
        "arn": "arn:aws:ec2:us-east-1:12345678910:instance/i-060b3dsfds7sdf62e3",
        "dailyCost": {
          "cost": 2.06,
          "currency": "USD",
          "formattedCost": "$2.06"
        }
      },
     ...More EC2 Instances
    ]
  },
  "extensions": {
    "touched_uids": 28
  }
}

Obtenha cada NAT Gateway em sua conta AWS junto com seu custo diário:```graphql query { queryawsNatGateway { arn dailyCost { cost currency formattedCost } } }

<br />

## Exemplo do AWS CloudWatch:

O CloudGraph ingere seus dados de métricas do CloudWatch e os armazena junto com serviços selecionados da AWS. Este recurso está atualmente em fase beta e funcionará apenas para EC2:```graphql
query {
  queryawsEc2 {
    arn
    cloudWatchMetricData {
      lastWeek {
        cpuUtilizationAverage
        networkInAverage
        networkOutAverage
        networkPacketsInAverage
        networkPacketsOutAverage
        statusCheckFailedSum
        statusCheckFailedInstanceSum
        statusCheckFailedSystemSum
        diskReadOpsAverage
        diskWriteOpsAverage
        diskReadBytesAverage
        diskWriteBytesAverage
      }

      lastMonth {
        cpuUtilizationAverage
        networkInAverage
        networkOutAverage
        networkPacketsInAverage
        networkPacketsOutAverage
        statusCheckFailedSum
        statusCheckFailedInstanceSum
        statusCheckFailedSystemSum
        diskReadOpsAverage
        diskWriteOpsAverage
        diskReadBytesAverage
        diskWriteBytesAverage
      }
      last6Hours {
        cpuUtilizationAverage
        networkInAverage
        networkOutAverage
        networkPacketsInAverage
        networkPacketsOutAverage
        statusCheckFailedSum
        statusCheckFailedInstanceSum
        statusCheckFailedSystemSum
        diskReadOpsAverage
        diskWriteOpsAverage
        diskReadBytesAverage
        diskWriteBytesAverage
      }
      last24Hours {
        cpuUtilizationAverage
        networkInAverage
        networkOutAverage
        networkPacketsInAverage
        networkPacketsOutAverage
        statusCheckFailedSum
        statusCheckFailedInstanceSum
        statusCheckFailedSystemSum
        diskReadOpsAverage
        diskWriteOpsAverage
        diskReadBytesAverage
        diskWriteBytesAverage
      }
    }
  }
}

Pensando em termos de um grafo:

Quando você pensa, "em termos de um grafo", você pode fazer quase tudo com o CloudGraph. Digamos, por exemplo, que você queira saber quais funções Lamba não pertencem a uma VPC (ou seja, não utilizam a rede da VPC). Como o CloudGraph conecta todos os recursos que têm relacionamentos, como VPCs pais com suas funções Lambda filhas, você pode responder a essa pergunta facilmente. Basta verificar a quais funções lambda a VPC está "conectada" e comparar isso com a lista de todas as funções lambda da seguinte forma:```graphql query { queryawsVpc { id arn lambda { id arn } } queryawsLambda { id arn } }

<br />

## Limitações

<br />

Hoje, a maior limitação do CloudGraph e de nossas capacidades de consulta é que não suportamos filtragem aninhada baseada em atributos filho. Então, por exemplo, por mais legal que fosse fazer o seguinte, ainda não é possível:

<br />

```sql
graphql query
``````graphql
query {
  # This won't work just yet...
  queryawsEc2(filter: { ebs: { isBootDisk: true } }) {
    id
    arn
    ebs {
      id
      arn
    }
  }
  # So you have to do this instead :(
  queryawsEc2 {
    id
    arn
    ebs(filter: { isBootDisk: true }) {
      id
      arn
    }
  }
}

Isto não é realmente uma limitação do CloudGraph, mas sim uma funcionalidade que ainda precisa ser implementada com o Dgraph. Você pode visualizar e comentar no tópico de discussão aqui

Ferramentas de Consulta

O CloudGraph vem com 2 excelentes ferramentas de consulta e um explorador de esquemas GraphQL. Lembre-se, você pode usar QUALQUER ferramenta de consulta GraphQL se preferir outra opção, basta conectá-la ao seu endpoint /graphql exposto!

GraphQL Playground

O GraphQL Playground possui uma UX fluida e envolvente, ótima para consultar um esquema GraphQL de forma rápida e simples. Ele tem documentação gerada automaticamente embutida e autocompletar enquanto você digita. Para acessar o playground, selecione-o como sua ferramenta de consulta preferida no comando init ou visite /playground no servidor que o CG inicia.

Altair

Altair é outra excelente ferramenta de consulta GraphQL que oferece uma tonelada de funcionalidades para usuários avançados. Faça coisas como autocompletar consultas, adicionar fragmentos dinamicamente e exportar/importar coleções de consultas. Para acessar o Altair, selecione-o como sua ferramenta de consulta preferida no comando init ou visite /altair no servidor que o CG inicia.

Voyager

GraphQL Voyager é uma maneira incrível de explorar o(s) esquema(s) dos seus provedores CG. Ele oferece um ótimo gráfico bidirecional contendo todos os seus tipos e consultas. Você pode clicar em entidades ou setas para descobrir conexões, pesquisar algo específico e obter uma compreensão mais profunda do seu esquema. Para acessar o voyager, visite /voyager no servidor que o CG inicia.

Comunidade

Comentários, perguntas ou feedback? Por favor, Junte-se ao Nosso Espaço no Slack adoraríamos ouvir de você.

Diretrizes de Contribuição

Se você está interessado em contribuir com o CloudGraph, confira nossas Diretrizes de Contribuição.

Opções de Implantação

Você pode executar o CloudGraph localmente ou implantá-lo no provedor de nuvem de sua escolha. Módulos Terraform e guias para implantações em nuvem estão chegando em breve!

Versão Hospedada

Interessado em uma versão SaaS totalmente gerenciada / auto-hospedada do CloudGraph que possui capacidades de visualização 3D integradas, varreduras automatizadas e centenas de verificações de conformidade adicionais? Confira AutoCloud para mais detalhes.

Depuração

Se você encontrar algum erro ao executar o CloudGraph, pode adicionar CG_DEBUG=5 no início do seu comando, como em CG_DEBUG=5 cg scan. Isso imprimirá os logs detalhados com mais informações que você pode usar para abrir um issue no GitHub ou nos avisar em nosso Espaço no Slack.

Erros Comuns

Existem alguns erros comuns que você pode ver ao executar o CloudGraph, geralmente relacionados a problemas de permissão ou conexão.

⚠️ impossível fazer algumas conexões - Este aviso no relatório de varredura aparece quando o CG tenta fazer uma conexão entre dois recursos e não consegue. Se você vir isso usando um dos provedores oficialmente suportados pelo CG, por favor crie um novo issue para que possamos resolver. A causa mais comum desse erro é um bug na lógica de conexão de recursos do provedor subjacente.
🚫 impossível armazenar dados no Dgraph - Este erro no relatório de varredura aparece quando o CG tenta inserir alguns dados do provedor de nuvem no banco de dados gráfico e falha. Quaisquer serviços com este erro não poderão ser consultados na ferramenta de consulta GraphQL. Isso geralmente acontece quando o CG não consegue obter os dados necessários (como um arn) para um recurso devido a um erro ao chamar o SDK do provedor, geralmente por falta de autorização.
Provider {name}@${version} requires cli version {version} but cli version is ${version} - Este aviso significa que você tem versões incompatíveis do CG e do provedor que está tentando usar. Tente atualizar o CG com npm install -g @cloudgraphdev/cli e o módulo do provedor com cg provider update para que ambos estejam na versão mais recente. Você também pode verificar o pacakge.json do proivder para ver quais versões do CG o suportam.
Manager failed to install plugin for {provider} - Este erro ocorre quando o gerenciador de plugins do CG não consegue encontrar o módulo do provedor que você deseja usar. O gerenciador pesquisa no registro público do NPM pelo módulo do provedor. Para provedores oficialmente suportados, basta passar o nome do provedor CG init aws. Para provedores suportados pela comunidade, você deve passar também o namespace CG init @{providerNamespace}/{provider}

Comandos

cg help [COMMAND]
cg init [PROVIDER]
cg launch [PROVIDER]
cg load [PROVIDER]
cg policy [PROVIDER]
cg policy add [PROVIDER]
cg policy install [PROVIDER]
cg policy list [PROVIDER]
cg policy remove [PROVIDER]
cg policy update [PROVIDER]
cg provider [PROVIDER]

`cg help [COMMAND]`

Exibe ajuda para cg.``` USAGE $ cg help [COMMAND] [-n]

ARGUMENTS COMMAND Command to show help for.

FLAGS -n, --nested-commands Include all nested commands in the output.

DESCRIPTION Display help for cg.

_Veja o código: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v5.1.12/src/commands/help.ts)_

## `cg init [PROVIDER]`

Define a configuração inicial para provedores```
USAGE
  $ cg init [PROVIDER] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p <value>]
    [-q playground|altair] [-l <value>] [--use-roles] [-P <value>] [-r]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -r, --resources
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Set initial configuration for providers

EXAMPLES
  $ cg init

  $ cg init aws [Initialize AWS provider]

  $ cg init aws -r [Specify resources to crawl]

See code: src/commands/init.ts

`cg launch [PROVIDER]`

Inicie uma instância do Dgraph para armazenar dados``` USAGE $ cg launch [PROVIDER] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

FLAGS -P, --policies= Policy Packs to execute during scan -d, --dgraph= Set where dgraph is running (default localhost:8997) -l, --version-limit= Limit the amount of version folders stored on the filesystem (default 10) -p, --port= Set port to serve query engine -q, --query-engine= Query engine to launch <options: playground|altair> -s, --storage= Select a storage engine to use. Currently only supports Dgraph <options: dgraph> --dev Turn on developer mode --directory= Set the folder where CloudGraph will store data. (default cg) --no-serve Set to not serve a query engine --use-roles Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION Launch an instance of Dgraph to store data

EXAMPLES $ cg launch

_Veja o código: [src/commands/launch.ts](https://github.com/cloudgraphdev/cli/blob/v0.25.1/src/commands/launch.ts)_

## `cg load [PROVIDER]`

Carregue uma versão específica dos seus dados do CloudGraph```
USAGE
  $ cg load [PROVIDER] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p <value>]
    [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Load a specific version of your CloudGraph data

EXAMPLES
  $ cg load [Load data for all providers configured]

  $ cg load aws [Load data for AWS]

Veja o código: src/commands/load.ts

`cg policy [PROVIDER]`

Comandos para gerenciar módulos de pacotes de políticas, execute $ cg policy para mais informações.``` USAGE $ cg policy [PROVIDER] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

DESCRIPTION Commands to manage policy pack modules, run $ cg policy for more info.

_Ver código: [src/commands/policy/index.ts](https://github.com/cloudgraphdev/cli/blob/v0.25.1/src/commands/policy/index.ts)_

## `cg policy add [PROVIDER]`

Adicionar novos pacotes de política```
USAGE
  $ cg policy add [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Add new policy packs

ALIASES
  $ cg add policy

EXAMPLES
  $ cg policy add aws-cis-1.2.0

  $ cg policy add [email protected]

`cg policy install [PROVIDER]`

Instalar pacotes de política com base no arquivo de lock``` USAGE $ cg policy install [PROVIDER] [--no-save] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

FLAGS -P, --policies= Policy Packs to execute during scan -d, --dgraph= Set where dgraph is running (default localhost:8997) -l, --version-limit= Limit the amount of version folders stored on the filesystem (default 10) -p, --port= Set port to serve query engine -q, --query-engine= Query engine to launch <options: playground|altair> -s, --storage= Select a storage engine to use. Currently only supports Dgraph <options: dgraph> --dev Turn on developer mode --directory= Set the folder where CloudGraph will store data. (default cg) --no-save Set to not alter lock file, just delete plugin --no-serve Set to not serve a query engine --use-roles Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION Install policy packs based on the lock file

ALIASES $ cg install policy

EXAMPLES $ cg policy install

## `cg policy list [PROVIDER]`

Listar pacotes de políticas atualmente instalados e versões```
USAGE
  $ cg policy list [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  List currently installed policy packs and versions

ALIASES
  $ cg ls policy
  $ cg list policy

EXAMPLES
  $ cg policy list

  $ cg policy list aws

`cg policy remove [PROVIDER]`

Remover o pacote de política atualmente instalado``` USAGE $ cg policy remove [PROVIDER] [--no-save] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

FLAGS -P, --policies= Policy Packs to execute during scan -d, --dgraph= Set where dgraph is running (default localhost:8997) -l, --version-limit= Limit the amount of version folders stored on the filesystem (default 10) -p, --port= Set port to serve query engine -q, --query-engine= Query engine to launch <options: playground|altair> -s, --storage= Select a storage engine to use. Currently only supports Dgraph <options: dgraph> --dev Turn on developer mode --directory= Set the folder where CloudGraph will store data. (default cg) --no-save Set to not alter lock file, just delete plugin --no-serve Set to not serve a query engine --use-roles Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION Remove currently installed policy pack

ALIASES $ cg remove policy $ cg policy remove $ cg policy rm $ cg del policy $ cg rm policy

EXAMPLES $ cg policy remove

$ cg policy remove aws-cis-1.2.0

$ cg policy remove aws-cis-1.2.0 --no-save

## `cg policy update [PROVIDER]`

Atualiza os pacotes de política atualmente instalados```
USAGE
  $ cg policy update [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Update currently installed policy packs

EXAMPLES
  $ cg policy update

  $ cg policy update aws-cis-1.2.0

  $ cg policy update [email protected]

`cg provider [PROVIDER]`

Comandos para gerenciar módulos de provedor, execute $ cg provider para mais informações.``` USAGE $ cg provider [PROVIDER] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

DESCRIPTION Commands to manage provider modules, run $ cg provider for more info.

_Veja o código: [src/commands/provider/index.ts](https://github.com/cloudgraphdev/cli/blob/v0.25.1/src/commands/provider/index.ts)_

## `cg provider add [PROVIDER]`

Adicionar novos provedores```
USAGE
  $ cg provider add [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Add new providers

ALIASES
  $ cg add provider

EXAMPLES
  $ cg provider add aws

  $ cg provider add [email protected]

`cg provider install [PROVIDER]`

Instalar provedores com base no arquivo de lock``` USAGE $ cg provider install [PROVIDER] [--no-save] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

FLAGS -P, --policies= Policy Packs to execute during scan -d, --dgraph= Set where dgraph is running (default localhost:8997) -l, --version-limit= Limit the amount of version folders stored on the filesystem (default 10) -p, --port= Set port to serve query engine -q, --query-engine= Query engine to launch <options: playground|altair> -s, --storage= Select a storage engine to use. Currently only supports Dgraph <options: dgraph> --dev Turn on developer mode --directory= Set the folder where CloudGraph will store data. (default cg) --no-save Set to not alter lock file, just delete plugin --no-serve Set to not serve a query engine --use-roles Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION Install providers based on the lock file

ALIASES $ cg install provider

EXAMPLES $ cg provider install

## `cg provider list [PROVIDER]`

Lista os provedores atualmente instalados e versões```
USAGE
  $ cg provider list [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  List currently installed providers and versions

ALIASES
  $ cg ls provider
  $ cg list provider

EXAMPLES
  $ cg provider list

  $ cg provider list aws

`cg provider remove [PROVIDER]`

Remove o provedor atualmente instalado``` USAGE $ cg provider remove [PROVIDER] [--no-save] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

FLAGS -P, --policies= Policy Packs to execute during scan -d, --dgraph= Set where dgraph is running (default localhost:8997) -l, --version-limit= Limit the amount of version folders stored on the filesystem (default 10) -p, --port= Set port to serve query engine -q, --query-engine= Query engine to launch <options: playground|altair> -s, --storage= Select a storage engine to use. Currently only supports Dgraph <options: dgraph> --dev Turn on developer mode --directory= Set the folder where CloudGraph will store data. (default cg) --no-save Set to not alter lock file, just delete plugin --no-serve Set to not serve a query engine --use-roles Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION Remove currently installed provider

ALIASES $ cg remove provider $ cg provider remove $ cg provider rm $ cg del provider $ cg rm provider

EXAMPLES $ cg provider remove

$ cg provider remove aws

$ cg provider remove aws --no-save

## `cg provider update [PROVIDER]`

Atualizar provedores atualmente instalados```
USAGE
  $ cg provider update [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Update currently installed providers

EXAMPLES
  $ cg provider update

  $ cg provider update aws

  $ cg provider update [email protected]

`cg scan [PROVIDER]`

Digitalizar dados de um ou vários provedores para serem consultados através do Dgraph``` USAGE $ cg scan [PROVIDER] [--dev] [-d ] [-s dgraph] [--directory ] [--no-serve] [-p ] [-q playground|altair] [-l ] [--use-roles] [-P ]

DESCRIPTION Scan one or multiple providers data to be queried through Dgraph

EXAMPLES $ cg scan

$ cg scan aws

$ cg scan aws --dgraph http://localhost:1000 [Save data in dgraph running on port 1000]

$ cg scan aws --no-serve [Do not start the query engine]

_See code: [src/commands/scan.ts](https://github.com/cloudgraphdev/cli/blob/v0.25.1/src/commands/scan.ts)_

## `cg serve [PROVIDER]`

Sirva uma ferramenta de consulta GraphQL para consultar seus dados do CloudGraph.```
USAGE
  $ cg serve [PROVIDER] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p <value>]
    [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Serve a GraphQL query tool to query your CloudGraph data.

EXAMPLES
  $ cg serve

See code: src/commands/serve.ts

`cg teardown [PROVIDER]`

Para o contêiner Docker do Dgraph.``` USAGE $ cg teardown [PROVIDER] [--delete-image]

FLAGS --delete-image Remove dgraph docker image after stopping it

DESCRIPTION Stops the Dgraph Docker container.

EXAMPLES $ cg teardown

$ cg teardown --delete-image

_Ver código: [src/commands/teardown.ts](https://github.com/cloudgraphdev/cli/blob/v0.25.1/src/commands/teardown.ts)_

## `cg update [PROVIDER]`

Atualiza os plugins atualmente instalados.```
USAGE
  $ cg update [PROVIDER] [--no-save] [--dev] [-d <value>] [-s dgraph] [--directory <value>] [--no-serve] [-p
    <value>] [-q playground|altair] [-l <value>] [--use-roles] [-P <value>]

FLAGS
  -P, --policies=<value>       Policy Packs to execute during scan
  -d, --dgraph=<value>         Set where dgraph is running (default localhost:8997)
  -l, --version-limit=<value>  Limit the amount of version folders stored on the filesystem (default 10)
  -p, --port=<value>           Set port to serve query engine
  -q, --query-engine=<option>  Query engine to launch
                               <options: playground|altair>
  -s, --storage=<option>       Select a storage engine to use. Currently only supports Dgraph
                               <options: dgraph>
  --dev                        Turn on developer mode
  --directory=<value>          Set the folder where CloudGraph will store data. (default cg)
  --no-save                    Set to not alter lock file, just delete plugin
  --no-serve                   Set to not serve a query engine
  --use-roles                  Set to true to use roleARNs instead of profiles for AWS credentials

DESCRIPTION
  Upgrade currently installed plugins.

ALIASES
  $ cg update

EXAMPLES
  $ cg update

Veja o código: src/commands/update.ts

cli

Mais Populares