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
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
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
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
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.
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!
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
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
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.
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.
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.
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.
> 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.
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
> 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