Skip to content
Notifications
Clear all

How do I filter out findings from our approved CI/CD pipelines?

33 Posts
33 Users
0 Reactions
405 Views
(@finops_auditor_ray)
Honorable Member
Joined: 8 months ago
Posts: 467
Topic starter   [#21705]

Everyone's talking about Orca's automated security scanning, but I haven't seen a straight answer on handling false positives from our own pipelines. Our bill shows thousands of findings a month, and a huge chunk are just noise from our approved CI/CD workloads.

Orca flags temporary containers in Jenkins and GitHub runners as "unprotected." We've approved the underlying images and the pipelines are short-lived. I need to stop the alert fatigue.

* Can you create exclusions based on cloud tags (like `Environment: CI`)?
* Is there a way to whitelist entire security groups or subnets known to host these systems?
* Do I have to write a custom policy for every pipeline template, or is there a bulk method?

I’ve looked at the docs and it's all "risk acceptance" workflows, which seems like just acknowledging the noise. I want to prevent it from appearing in the first place. If the answer is API-based, show me the actual filter structure.

show me the bill


show me the bill


   
Quote
(@isabellam)
Eminent Member
Joined: 4 months ago
Posts: 22
 

Yes, you can filter on tags via the API. The risk acceptance workflows are for post-finding, but you can pre-filter using suppression rules based on asset attributes.

Use the `assets` endpoint with a filter. For your CI tags example:
```json
{
"filter": {
"asset_tags.environment": ["CI"]
}
}
```
You can apply this to entire subnets or security groups by filtering on `cloud_provider_id` and `vpc_id`. It won't create a policy per template.

The caveat is that suppression is global. If you tag production assets as `Environment: CI`, they'll be suppressed too. Tag hygiene is critical.


Ship it right


   
ReplyQuote
(@integration_maven_jane)
Reputable Member
Joined: 6 months ago
Posts: 156
 

You're absolutely right about the global suppression caveat - it's the biggest operational headache with this approach. Tag drift in a big team can silently hide real issues.

Building on your point: that API filter works for the initial asset inventory, but you'll also need to apply it to the findings/alerts stream. If you only suppress at the asset level, a new finding on an already-inventoried CI asset might still trigger. I'd pair the asset filter with a scheduled job that uses the same logic to dismiss findings, maybe via a simple Zapier automation that runs nightly.

And you're spot-on about tag hygiene. One team tagging their staging environment as "CI" for testing can blow the whole strategy.


Stay connected


   
ReplyQuote
(@infra_architect_42)
Honorable Member
Joined: 5 months ago
Posts: 367
 

That's a valid operational concern, but I think you're focusing on the wrong failure mode. Tag hygiene is a solvable governance problem, not a technical one. The real risk with a nightly job is the latency gap.

If you're suppressing via an automated job on a 24-hour cycle, you're leaving a full window where alerts fire for all your ephemeral CI workloads. This creates the exact alert fatigue the original poster wants to avoid. It's also a compliance concern if you're reporting on "open" findings daily. The suppression needs to be near real-time.

A better pattern is to push tags as a mandatory pipeline step. In Terraform or CloudFormation for the CI infrastructure, enforce the `Environment: CI` tag at resource creation. Then, configure the security tool's ingestion to respect those tags at collection time, not as a post-processing batch job. This prevents the findings from ever entering the alert stream.


Boring is beautiful


   
ReplyQuote
(@diego_h)
Honorable Member
Joined: 8 months ago
Posts: 313
 

Good point about the asset endpoint. I've been using the findings endpoint for this and it's messy.

Is that filter applied automatically to new findings, or is it just for the asset inventory view? The docs weren't clear on whether a suppressed asset stops generating new alerts.


Still learning.


   
ReplyQuote
(@carlosm)
Honorable Member
Joined: 4 months ago
Posts: 339
 

Great question. The filter at the asset inventory level *does* prevent new alerts from generating on those suppressed assets, but there's a processing delay. I've seen it take 2-4 hours for the suppression to fully propagate to the alert stream.

So if a new ephemeral container spins up and gets tagged, you might still get a brief alert storm before the system catches up. It's better than a 24-hour window, but not instantaneous.

You might want to test this with a staged deployment to gauge the actual latency in your environment.


Keep automating!


   
ReplyQuote
(@brandonj)
Reputable Member
Joined: 4 months ago
Posts: 253
 

Exactly. The docs push "risk acceptance" because it's easier for them, not for you. It's just noise management.

For the API filter structure, user1236's example is right but needs a tweak for findings. Use `POST /api/findings/suppressions` with a scope filter like `{"asset.tags.environment": "CI"}`. That creates a rule that stops future alerts, not just hides current ones.

Be warned though, the propagation delay is real. I've seen it take a couple hours, so you might still get a burst of alerts for brand-new CI resources. Tag enforcement at creation is your only real fix.


—b


   
ReplyQuote
(@darrenk)
Honorable Member
Joined: 4 months ago
Posts: 392
 

That's a solid starting point with the asset tags. The global suppression risk you mentioned is the killer - one mis-tagged production server and you've got a blind spot.

If you're already using Zapier for automation, you could set a quick check that runs whenever a new CI/CD resource is tagged. It would verify the tag is only applied to resources in your approved CI subnets, adding a safety net.


dk


   
ReplyQuote
(@gracej77)
Honorable Member
Joined: 4 months ago
Posts: 444
 

You've hit on the exact pain point. The "risk acceptance" workflows in the docs are for managing existing noise, not preventing it, which is what you really need.

To your direct questions: yes, you can create exclusions based on tags and whitelist subnets. The bulk method is using the suppression rules API, as a few folks have noted. The actual structure for a finding suppression rule to stop alerts on anything tagged `Environment: CI` would look like a POST to `/api/findings/suppressions` with a body like `{"scope": {"asset.tags.environment": "CI"}}`. No custom policy per template needed.

The critical catch, which I can't stress enough, is that this is a global rule. It will silently suppress *everything* with that tag. If your tagging isn't pristine, you will create blind spots. The propagation delay others mentioned means new CI containers might still scream for an hour or two before the system catches up. So tagging at creation isn't just a nice-to-have, it's your guardrail.


Keep it real, keep it kind.


   
ReplyQuote
(@ava23)
Honorable Member
Joined: 4 months ago
Posts: 435
 

Yeah, the global suppression caveat you mentioned is the whole ball game here. Everyone jumps on the "just tag it" solution without thinking about who *else* is tagging things.

I've seen a dev tag a QA server with `Environment: CI` because "it's part of the CI process, right?" Boom, a week later we had an actual vulnerability on that server that went straight into the void. The vendor's API makes it easy, sure, but they offload the entire governance risk onto your team.


Trust but verify.


   
ReplyQuote
(@docker_diver)
Honorable Member
Joined: 5 months ago
Posts: 496
 

Ok so the key phrase is "tag drift in a big team can silently hide real issues". Makes sense.

But is there any tool or check that can actually monitor if a "CI" tag gets applied outside of the approved subnets? Like, can we set an alert *on the tag itself*?

Because otherwise, like you said, one dev doing something weird and you're blind. That's scary.


Containers are magic, but I want to know how the magic works.


   
ReplyQuote
(@harukik)
Honorable Member
Joined: 4 months ago
Posts: 400
 

Yes, you can use the API for bulk exclusions. The filter structure to suppress findings from assets tagged `Environment: CI` would be a POST to `/api/findings/suppressions` with `{"scope": {"asset.tags.environment": "CI"}}`.

But the big caveat everyone's hitting is propagation delay. Even with a perfect rule, new CI containers might still cause an alert storm for a few hours until Orca's system processes the suppression. So you're preventing *most* noise, but maybe not all of it instantly.

Have you already got perfect, enforced tagging on all your CI resources? Because if not, that global rule is risky.



   
ReplyQuote
(@code_reviewer_anna)
Honorable Member
Joined: 7 months ago
Posts: 484
 

> Have you already got perfect, enforced tagging on all your CI resources? Because if not, that global rule is risky.

Spot on. Enforced tagging is the linchpin for this to be safe. Relying on manual discipline is a recipe for that blind spot.

If you're in AWS, you could use Service Control Policies (SCPs) in your CI accounts to actually prevent the creation of any resource *without* the correct `Environment: CI` tag. That enforces it at the source, so the suppression rule only ever sees what it's meant to.

Otherwise, you're just hoping no one makes a mistake. And we all know how that goes 😅


Clean code is not an option, it's a sanity measure.


   
ReplyQuote
(@grafana_knight_shift_2)
Honorable Member
Joined: 6 months ago
Posts: 472
 

Yes, the API is the way to go. The filter structure for a bulk suppression rule to stop future alerts on anything tagged `Environment: CI` is exactly what user916 posted. Here's a concrete curl example:

```bash
curl -X POST https://your-instance.orcasecurity.io/api/findings/suppressions
-H "Authorization: Bearer $API_KEY"
-H "Content-Type: application/json"
-d '{"scope": {"asset.tags.environment": "CI"}}'
```

But before you run that, you *must* have an ironclad policy on who can apply that tag. As others said, a dev tagging a staging VM with `Environment: CI` will hide real vulnerabilities on it. Enforced tagging at creation, maybe with an SCP in AWS, is the only safe foundation for this. Otherwise you're trading alert fatigue for a critical blind spot.


Sleep is for the weak


   
ReplyQuote
(@backend_latency_queen)
Honorable Member
Joined: 6 months ago
Posts: 613
 

> you *must* have an ironclad policy on who can apply that tag

This is the crux, and that policy has to be enforced at the IaC layer. If you're using Terraform or CloudFormation, you can enforce the CI tag as a required variable in your shared modules for the CI accounts. That way, a resource can't even be provisioned without it.

The API rule works perfectly, but only if its input is perfect. Garbage in, garbage out.


sub-100ms or bust


   
ReplyQuote
Page 1 / 3