Container Images

The Container Images service collection provides operations for assessing and managing container images in your CrowdStrike Falcon environment. Retrieve assessment history, aggregate image counts by base OS, state, and vulnerability count, retrieve combined image details and export data, manage base images, and review issues and vulnerability summaries per image.

Language	Last Update
Python	v1.4.8
PowerShell	v2.2.9
Go	v0.20.0
TypeScript	v0.6.0
Rust	v0.7.0
Ruby	v1.2.0

Operation	Description
AggregateImageAssessmentHistory `aggregate_assessment_history`	Image assessment history
AggregateImageCountByBaseOS `aggregate_count_by_base_os`	Aggregate count of images grouped by Base OS distribution
AggregateImageCountByState `aggregate_count_by_state`	Aggregate count of images grouped by state
AggregateImageCount `aggregate_count`	Aggregate count of images
CombinedBaseImages `get_combined_base_images`	Retrieve base images identified by the provided filter criteria
GetCombinedImages `get_combined_images`	Get image assessment results by providing an FQL filter and paging details
CombinedImageByVulnerabilityCount `get_combined_images_by_vulnerability_count`	Retrieve top x images with the most vulnerabilities
CombinedImageDetail `get_combined_detail`	Retrieve image entities identified by the provided filter criteria
ReadCombinedImagesExport `read_combined_export`	Retrieve images with an option to expand aggregated vulnerabilities/detections
CombinedImageIssuesSummary `get_combined_issues_summary`	Retrieve image issues summary such as Image detections, Runtime detections, Policies, vulnerabilities
CombinedImageVulnerabilitySummary `get_combined_vulnerabilities_summary`	aggregates information about vulnerabilities for an image
CreateBaseImagesEntities `create_base_images`	Creates base images using the provided details
DeleteBaseImages `delete_base_images`	Delete base images by base image UUID

AggregateImageAssessmentHistory

Image assessment history

GET /container-security/aggregates/images/assessment-history/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 aggregate_assessment_history

Parameters

Name	Type	Data type	Description
filter	query	string	Filter using a query in Falcon Query Language (FQL). Supported filters: `cid`, `registry`, and `repository`
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.aggregate_assessment_history(filter="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.AggregateImageAssessmentHistory(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("AggregateImageAssessmentHistory",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.ContainerImages.AggregateImageAssessmentHistory(
    &container_images.AggregateImageAssessmentHistoryParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.aggregateImageAssessmentHistory("string");  // filter

console.log(response);

use rusty_falcon::apis::container_images_api::aggregate_image_assessment_history;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = aggregate_image_assessment_history(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.aggregate_image_assessment_history(filter: 'string')

puts response

AggregateImageCountByBaseOS

Aggregate count of images grouped by Base OS distribution

GET /container-security/aggregates/images/count-by-os-distribution/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 aggregate_count_by_base_os

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `arch`, `base_os`, `cid`, `first_seen`, `image_digest`, `image_id`, `index_digest`, `registry`, `repository`, `source`, and `tag`
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.aggregate_count_by_base_os(filter="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.AggregateImageCountByBaseOS(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("AggregateImageCountByBaseOS",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.ContainerImages.AggregateImageCountByBaseOS(
    &container_images.AggregateImageCountByBaseOSParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.aggregateImageCountByBaseOS("string");  // filter

console.log(response);

use rusty_falcon::apis::container_images_api::aggregate_image_count_by_base_os;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = aggregate_image_count_by_base_os(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.aggregate_image_count_by_base_os(filter: 'string')

puts response

AggregateImageCountByState

Aggregate count of images grouped by state

GET /container-security/aggregates/images/count-by-state/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 aggregate_count_by_state

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `arch`, `base_os`, `cid`, `first_seen`, `image_digest`, `image_id`, `index_digest`, `registry`, `repository`, `source`, and `tag`
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.aggregate_count_by_state(filter="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.AggregateImageCountByState(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("AggregateImageCountByState",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.ContainerImages.AggregateImageCountByState(
    &container_images.AggregateImageCountByStateParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.aggregateImageCountByState("string");  // filter

console.log(response);

use rusty_falcon::apis::container_images_api::aggregate_image_count_by_state;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = aggregate_image_count_by_state(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.aggregate_image_count_by_state(filter: 'string')

puts response

AggregateImageCount

Aggregate count of images

GET /container-security/aggregates/images/count/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 aggregate_count

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `ai_related`, `ai_vulnerability_count`, `arch`, `base_os`, `cid`, `container_id`, `container_running_status`, `cps_rating`, `crowdstrike_user`, `cve_id`, `detection_count`, `detection_name`, `detection_severity`, `first_seen`, `image_digest`, `image_id`, `include_base_image_vuln`, `index_digest`, `layer_digest`, `package_name_version`, `registry`, `repository`, `source`, `tag`, `vulnerability_count`, and `vulnerability_severity`
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.aggregate_count(filter="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.AggregateImageCount(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("AggregateImageCount",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.ContainerImages.AggregateImageCount(
    &container_images.AggregateImageCountParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.aggregateImageCount("string");  // filter

console.log(response);

use rusty_falcon::apis::container_images_api::aggregate_image_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = aggregate_image_count(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.aggregate_image_count(filter: 'string')

puts response

CombinedBaseImages

Retrieve base images identified by the provided filter criteria

GET /container-security/combined/base-images/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_base_images

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `image_digest`, `image_id`, `registry`, `repository`, and `tag`

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_base_images(filter="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CombinedBaseImages(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("CombinedBaseImages",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.ContainerImages.CombinedBaseImages(
    &container_images.CombinedBaseImagesParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.combinedBaseImages("string");  // filter

console.log(response);

use rusty_falcon::apis::container_images_api::combined_base_images;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = combined_base_images(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.combined_base_images(filter: 'string')

puts response

GetCombinedImages

Get image assessment results by providing an FQL filter and paging details

GET /container-security/combined/image-assessment/images/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_images

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `ai_related`, `container_id`, `container_running_status`, `cve_id`, `detection_name`, `detection_severity`, `first_seen`, `image_digest`, `image_id`, `index_digest`, `registry`, `repository`, `tag`, and `vulnerability_severity`
limit	query	integer	The upper-bound on the number of records to retrieve [1-100]
offset	query	integer	The offset from where to begin.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.
sort	query	string	The fields to sort the records on. Supported columns: `first_seen`, `highest_detection_severity`, `highest_vulnerability_severity`, `image_digest`, `image_id`, `registry`, `repository`, `source`, and `tag`

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_images(filter="string",
                                      limit=integer,
                                      offset=integer,
                                      sort="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.GetCombinedImages(filter="string",
                                    limit=integer,
                                    offset=integer,
                                    sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetCombinedImages",
                          filter="string",
                          sort="string",
                          limit=integer,
                          offset=integer)
print(response)

Get-FalconContainerAssessment -Filter "string" `
  -Sort "string" `
  -Limit integer `
  -Offset integer

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"
  sort := "string"
  limit := int64(0)
  offset := int64(0)

  response, err := client.ContainerImages.GetCombinedImages(
    &container_images.GetCombinedImagesParams{
      Filter: &filter,
      Sort: &sort,
      Limit: &limit,
      Offset: &offset,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.getCombinedImages(
  "string",  // filter
  "string",  // sort
  integer,  // limit
  integer  // offset
);

console.log(response);

use rusty_falcon::apis::container_images_api::get_combined_images;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_combined_images(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
        Some("string"),  // sort
        Some(integer),  // limit
        Some(integer),  // offset
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.get_combined_images(filter: 'string',
                                   sort: 'string',
                                   limit: integer,
                                   offset: integer)

puts response

CombinedImageByVulnerabilityCount

Retrieve top x images with the most vulnerabilities

GET /container-security/combined/images/by-vulnerability-count/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_images_by_vulnerability_count

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `arch`, `base_os`, `cid`, `first_seen`, `image_digest`, `image_id`, `index_digest`, `registry`, `repository`, `source`, and `tag`
limit	query	integer	The upper-bound on the number of records to retrieve.
offset	query	integer	This is not used in the backend but is added here for compatibility purposes as some clients expects this i.e UI widgets.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_images_by_vulnerability_count(filter="string",
                                                             limit=integer,
                                                             offset="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CombinedImageByVulnerabilityCount(filter="string",
                                                    limit=integer,
                                                    offset="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("CombinedImageByVulnerabilityCount",
                          filter="string",
                          limit=integer,
                          offset=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"
  limit := int64(0)
  offset := int64(0)

  response, err := client.ContainerImages.CombinedImageByVulnerabilityCount(
    &container_images.CombinedImageByVulnerabilityCountParams{
      Filter: &filter,
      Limit: &limit,
      Offset: &offset,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.combinedImageByVulnerabilityCount(
  "string",  // filter
  integer,  // limit
  integer  // offset
);

console.log(response);

use rusty_falcon::apis::container_images_api::combined_image_by_vulnerability_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = combined_image_by_vulnerability_count(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
        Some(integer),  // limit
        Some(integer),  // offset
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.combined_image_by_vulnerability_count(filter: 'string',
                                                     limit: integer,
                                                     offset: integer)

puts response

CombinedImageDetail

Retrieve image entities identified by the provided filter criteria

GET /container-security/combined/images/detail/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_detail

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `arch`, `base_os`, `cid`, `first_seen`, `image_digest`, `image_id`, `index_digest`, `registry`, `repository`, `source`, and `tag`
with_config	query	boolean	(true/false) include image config, default is false
limit	query	integer	The upper-bound on the number of records to retrieve.
offset	query	integer	The offset from where to begin.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.
sort	query	string	The fields to sort the records on.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_detail(filter="string",
                                      with_config=boolean,
                                      limit=integer,
                                      offset=integer,
                                      sort="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CombinedImageDetail(filter="string",
                                      with_config=boolean,
                                      limit=integer,
                                      offset=integer,
                                      sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("CombinedImageDetail",
                          filter="string",
                          with_config=boolean,
                          sort="string",
                          limit=integer,
                          offset=integer)
print(response)

Get-FalconContainerImage -Filter "string" `
  -Sort "string" `
  -Limit integer `
  -WithConfig $boolean `
  -Offset integer

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"
  withConfig := boolean
  sort := "string"
  limit := int64(0)
  offset := int64(0)

  response, err := client.ContainerImages.CombinedImageDetail(
    &container_images.CombinedImageDetailParams{
      Filter: &filter,
      WithConfig: &withConfig,
      Sort: &sort,
      Limit: &limit,
      Offset: &offset,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.combinedImageDetail(
  "string",  // filter
  boolean,  // withConfig
  "string",  // sort
  integer,  // limit
  integer  // offset
);

console.log(response);

use rusty_falcon::apis::container_images_api::combined_image_detail;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = combined_image_detail(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
        Some(boolean),  // with_config
        Some("string"),  // sort
        Some(integer),  // limit
        Some(integer),  // offset
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.combined_image_detail(filter: 'string',
                                     with_config: boolean,
                                     sort: 'string',
                                     limit: integer,
                                     offset: integer)

puts response

ReadCombinedImagesExport

Retrieve images with an option to expand aggregated vulnerabilities/detections

GET /container-security/combined/images/export/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 read_combined_export

Parameters

Name	Type	Data type	Description
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `ai_related`, `ai_vulnerability_count`, `arch`, `base_os`, `cid`, `container_id`, `container_running_status`, `cps_rating`, `crowdstrike_user`, `cve_id`, `detection_count`, `detection_name`, `detection_severity`, `first_seen`, `image_digest`, `image_id`, `include_base_image_vuln`, `index_digest`, `layer_digest`, `package_name_version`, `registry`, `repository`, `source`, `tag`, `vulnerability_count`, `vulnerability_severity`
expand_vulnerabilities	query	boolean	expand vulnerabilities
expand_detections	query	boolean	expand detections
limit	query	integer	The upper-bound on the number of records to retrieve.
offset	query	integer	The offset from where to begin.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.
sort	query	string	The fields to sort the records on. Supported columns: `ai_vulnerabilities`, `base_os`, `cid`, `detections`, `firstScanned`, `first_seen`, `highest_detection_severity`, `highest_cps_current_rating`, `highest_vulnerability_severity`, `image_digest`, `image_id`, `last_seen`, `layers_with_vulnerabilities`, `packages`, `registry`, `repository`, `source`, `tag`, and `vulnerabilities`

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.read_combined_export(filter="string",
                                       expand_vulnerabilities=boolean,
                                       expand_detections=boolean,
                                       limit=integer,
                                       offset=integer,
                                       sort="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.ReadCombinedImagesExport(filter="string",
                                           expand_vulnerabilities=boolean,
                                           expand_detections=boolean,
                                           limit=integer,
                                           offset=integer,
                                           sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ReadCombinedImagesExport",
                          filter="string",
                          expand_vulnerabilities=boolean,
                          expand_detections=boolean,
                          limit=integer,
                          offset=integer,
                          sort="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"
  expandVulnerabilities := boolean
  expandDetections := boolean
  limit := int64(0)
  offset := int64(0)
  sort := "string"

  response, err := client.ContainerImages.ReadCombinedImagesExport(
    &container_images.ReadCombinedImagesExportParams{
      Filter: &filter,
      ExpandVulnerabilities: &expandVulnerabilities,
      ExpandDetections: &expandDetections,
      Limit: &limit,
      Offset: &offset,
      Sort: &sort,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.readCombinedImagesExport(
  "string",  // filter
  boolean,  // expandVulnerabilities
  boolean,  // expandDetections
  integer,  // limit
  integer,  // offset
  "string"  // sort
);

console.log(response);

use rusty_falcon::apis::container_images_api::read_combined_images_export;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = read_combined_images_export(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
        Some(boolean),  // expand_vulnerabilities
        Some(boolean),  // expand_detections
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // sort
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.read_combined_images_export(filter: 'string',
                                           expand_vulnerabilities: boolean,
                                           expand_detections: boolean,
                                           limit: integer,
                                           offset: integer,
                                           sort: 'string')

puts response

CombinedImageIssuesSummary

Retrieve image issues summary such as Image detections, Runtime detections, Policies, vulnerabilities

GET /container-security/combined/images/issues-summary/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_issues_summary

Parameters

Name	Type	Data type	Description
cid	query	string	CID
include_base_image_vuln	query	boolean	Flag indicating if base image vulnerabilities should be included.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.
image_digest	query	string	Image digest ID
registry	query	string	Registry name
repository	query	string	Repository name
tag	query	string	Tag name

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_issues_summary(cid="string",
                                              image_digest="string",
                                              registry="string",
                                              repository="string",
                                              tag="string",
                                              include_base_image_vuln=boolean)
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CombinedImageIssuesSummary(cid="string",
                                             image_digest="string",
                                             registry="string",
                                             repository="string",
                                             tag="string",
                                             include_base_image_vuln=boolean)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("CombinedImageIssuesSummary",
                          cid="string",
                          registry="string",
                          repository="string",
                          tag="string",
                          image_digest="string",
                          include_base_image_vuln=boolean)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  imageDigest := "string"
  includeBaseImageVuln := boolean

  response, err := client.ContainerImages.CombinedImageIssuesSummary(
    &container_images.CombinedImageIssuesSummaryParams{
      Cid: "string",
      Registry: "string",
      Repository: "string",
      Tag: "string",
      ImageDigest: &imageDigest,
      IncludeBaseImageVuln: &includeBaseImageVuln,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.combinedImageIssuesSummary(
  "string",  // cid
  "string",  // registry
  "string",  // repository
  "string",  // tag
  "string",  // imageDigest
  boolean  // includeBaseImageVuln
);

console.log(response);

use rusty_falcon::apis::container_images_api::combined_image_issues_summary;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = combined_image_issues_summary(
        &falcon.cfg,  // configuration
        "string",  // cid
        "string",  // registry
        "string",  // repository
        "string",  // tag
        Some("string"),  // image_digest
        Some(boolean),  // include_base_image_vuln
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.combined_image_issues_summary('string', 'string', 'string', 'string')

puts response

CombinedImageVulnerabilitySummary

aggregates information about vulnerabilities for an image

GET /container-security/combined/images/vulnerabilities-summary/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_vulnerabilities_summary

Parameters

Name	Type	Data type	Description
cid	query	string	CID
include_base_image_vuln	query	boolean	Flag indicating if base image vulnerabilities should be included.
parameters	query	dictionary	Full query string parameters payload in JSON format. Not required if using other keywords.
image_digest	query	string	Image digest ID
registry	query	string	registry name
repository	query	string	repository name
tag	query	string	tag name

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_vulnerabilities_summary(cid="string",
                                                       image_digest="string",
                                                       registry="string",
                                                       repository="string",
                                                       tag="string",
                                                       include_base_image_vuln=boolean)
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CombinedImageVulnerabilitySummary(cid="string",
                                                    image_digest="string",
                                                    registry="string",
                                                    repository="string",
                                                    tag="string",
                                                    include_base_image_vuln=boolean)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("CombinedImageVulnerabilitySummary",
                          cid="string",
                          registry="string",
                          repository="string",
                          tag="string",
                          image_digest="string",
                          include_base_image_vuln=boolean)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  imageDigest := "string"
  includeBaseImageVuln := boolean

  response, err := client.ContainerImages.CombinedImageVulnerabilitySummary(
    &container_images.CombinedImageVulnerabilitySummaryParams{
      Cid: "string",
      Registry: "string",
      Repository: "string",
      Tag: "string",
      ImageDigest: &imageDigest,
      IncludeBaseImageVuln: &includeBaseImageVuln,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.combinedImageVulnerabilitySummary(
  "string",  // cid
  "string",  // registry
  "string",  // repository
  "string",  // tag
  "string",  // imageDigest
  boolean  // includeBaseImageVuln
);

console.log(response);

use rusty_falcon::apis::container_images_api::combined_image_vulnerability_summary;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = combined_image_vulnerability_summary(
        &falcon.cfg,  // configuration
        "string",  // cid
        "string",  // registry
        "string",  // repository
        "string",  // tag
        Some("string"),  // image_digest
        Some(boolean),  // include_base_image_vuln
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.combined_image_vulnerability_summary('string', 'string', 'string', 'string')

puts response

CreateBaseImagesEntities

Creates base images using the provided details

POST /container-security/entities/base-images/v1

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 create_base_images

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
image_digest	body	string	Image digest.
image_id	body	string	Image ID.
registry	body	string	Registry.
repository	body	string	Image repository.
tag	body	string	Image tag.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.create_base_images(image_digest="string",
                                     image_id="string",
                                     registry="string",
                                     repository="string",
                                     tag="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.CreateBaseImagesEntities(image_digest="string",
                                           image_id="string",
                                           registry="string",
                                           repository="string",
                                           tag="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "base_images": [
        {
            "image_digest": "string",
            "image_id": "string",
            "registry": "string",
            "repository": "string",
            "tag": "string"
        }
    ]
}

response = falcon.command("CreateBaseImagesEntities", body=body_payload)
print(response)

New-FalconContainerImage -ImageId "string" `
  -ImageDigest "string" `
  -Registry "string" `
  -Repository "string" `
  -Tag "string"

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  image_digest := "string"
  image_id := "string"
  registry := "string"
  repository := "string"
  tag := "string"

  response, err := client.ContainerImages.CreateBaseImagesEntities(
    &container_images.CreateBaseImagesEntitiesParams{
      Body: &models.ModelsCreateBaseImagesRequest{
        BaseImages: []interface{}{
          {
          ImageDigest: &image_digest,
          ImageID: &image_id,
          Registry: &registry,
          Repository: &repository,
          Tag: &tag,
          },
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.createBaseImagesEntities(
  {
    baseImages: [{
        imageDigest: "string",
        imageId: "string",
        registry: "string",
        repository: "string",
        tag: "string"
      }]
}  // body
);

console.log(response);

use rusty_falcon::apis::container_images_api::create_base_images_entities;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::ModelsCreateBaseImagesRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = ModelsCreateBaseImagesRequest {
        base_images: vec![],
        ..Default::default()
    };

    let response = create_base_images_entities(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

body = Falcon::ModelsCreateBaseImagesRequest.new(
  base_images: [{
      image_digest: 'string',
      image_id: 'string',
      registry: 'string',
      repository: 'string',
      tag: 'string'
    }]
)

response = api.create_base_images_entities(body)

puts response

DeleteBaseImages

Delete base images by base image UUID

DELETE /container-security/entities/base-images/v1

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 delete_base_images

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	Base Image ID(s).
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.delete_base_images(ids=id_list)
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.DeleteBaseImages(ids=id_list)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("DeleteBaseImages",
                          ids=id_list)
print(response)

Remove-FalconContainerImage -Id @("ID1", "ID2")

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.ContainerImages.DeleteBaseImages(
    &container_images.DeleteBaseImagesParams{
      Ids: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.deleteBaseImages(["ID1", "ID2", "ID3"]);  // ids

console.log(response);

use rusty_falcon::apis::container_images_api::delete_base_images;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = delete_base_images(
        &falcon.cfg,  // configuration
        vec!["string".to_string()],  // ids
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.delete_base_images(['ID1', 'ID2', 'ID3'])

puts response

Container Images

Table of Contents

AggregateImageAssessmentHistory

Parameters

Code Examples

AggregateImageCountByBaseOS

Parameters

Code Examples

AggregateImageCountByState

Parameters

Code Examples

AggregateImageCount

Parameters

Code Examples

CombinedBaseImages

Parameters

Code Examples

GetCombinedImages

Parameters

Code Examples

CombinedImageByVulnerabilityCount

Parameters

Code Examples

CombinedImageDetail

Parameters

Code Examples

ReadCombinedImagesExport

Parameters

Code Examples

CombinedImageIssuesSummary

Parameters

Code Examples

CombinedImageVulnerabilitySummary

Parameters

Code Examples

CreateBaseImagesEntities

Parameters

Code Examples

DeleteBaseImages

Parameters

Code Examples