1(self.webpackChunkopa_website=self.webpackChunkopa_website||[]).push([[31824],{405:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-dotnet-asp-core-af6e6a1b7ad8672fab95a8bfb8b9a869.png"},409:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-csharp-247cc5d32b9861cfbfe3fb30eaffae47.png"},627:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/ceph-cfaa8121552dcd86281d121e590de578.png"},1780:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/oidc-7d6327a2c14cc030e944f8e88c76f629.png"},4592:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kubescape-91e0b6c73cf2068bf18e40493c18c883.png"},4607:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/php-authorization-94f32b84a9f994419e9ed0863de003a8.png"},4621:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/springsecurity-api-d60a6d0be9c3ea0f628e4e9577fd2482.png"},5767:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMjAwIiBoZWlnaHQ9IjIwMCIgdmlld0JveD0iMCAwIDIwMCAyMDAiPgogIDxkZWZzPgogICAgPGxpbmVhckdyYWRpZW50IGlkPSJsaW5lYXItZ3JhZGllbnQiIHgxPSIwLjUiIHgyPSIwLjUiIHkyPSIxIiBncmFkaWVudFVuaXRzPSJvYmplY3RCb3VuZGluZ0JveCI+CiAgICAgIDxzdG9wIG9mZnNldD0iMCIgc3RvcC1jb2xvcj0iIzcwZDBkMyIvPgogICAgICA8c3RvcCBvZmZzZXQ9IjEiIHN0b3AtY29sb3I9IiMwNTdiODAiLz4KICAgIDwvbGluZWFyR3JhZGllbnQ+CiAgICA8Y2xpcFBhdGggaWQ9ImNsaXAtTG90dGllLTIwMCI+CiAgICAgIDxyZWN0IHdpZHRoPSIyMDAiIGhlaWdodD0iMjAwIi8+CiAgICA8L2NsaXBQYXRoPgogIDwvZGVmcz4KICA8ZyBpZD0iTG90dGllLTIwMCIgY2xpcC1wYXRoPSJ1cmwoI2NsaXAtTG90dGllLTIwMCkiPgogICAgPHJlY3Qgd2lkdGg9IjIwMCIgaGVpZ2h0PSIyMDAiIGZpbGw9InJnYmEoMTgsMTgsMTgsMCkiLz4KICAgIDxnIGlkPSJMb3R0aWUtMjAweDIwMCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMCAwLjA4NikiPgogICAgICA8cGF0aCBpZD0iUGF0aF84IiBkYXRhLW5hbWU9IlBh
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
1dGggMTUiIGQ9Ik01OS4yNjYsMTI0LjE3MmM2LjUyNSwyLjc3OSwxNC45MzktMS41MSwxOC40My04LjkzNnMxLjUxLTE0Ljk3MS00LjEzLTE3LjM4MmMtMi44OTUtMS4xMTYtMTguMzY0LTYuMjM5LTMxLjktMTMuOTY5QzI3LjgyOCw3Ni43MzMsMTUuOTIzLDY2Ljk3NCwxMyw2OS45MDcsMTAuMDgsNzIuNiwxNy4xNSw4OC41MzUsMjguODg3LDEwMC45LDQwLjEyNSwxMTMuNzYzLDU2LjAzLDEyMy4wNTcsNTkuMjY2LDEyNC4xNzJaIiBmaWxsPSIjMjc3ZjgyIi8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzE2IiBkYXRhLW5hbWU9IlBhdGggMTYiIGQ9Ik0zMC40LDg3LjY1OGMuNzI3LDIuMDU5LDEuNTQ3LDQuMTI2LDIuNDY1LDYuMTYxLDYuMzcsMTUuODUyLDE4LjMyNSwyOS44NjcsMjEuMDEzLDMxLjk4Nyw1LjI0NSw0Ljc3NCwxNC42LDMuNSwyMC4zNDUtMi4zNjRzNi4zNTktMTMuNjM4LDEuODI4LTE3Ljc3M0M3NS42LDEwNS4yODgsMzIuOCw4OC44MjEsMzAuNCw4Ny42NThaIiBmaWxsPSIjMmY5ODljIi8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzE3IiBkYXRhLW5hbWU9IlBhdGggMTciIGQ9Ik02NC40MzYsMTM2LjQ5MWM3LjA5MS0uMTA5LDEzLjA0LTcuNDQ0LDEzLjIxNy0xNS42NDcuMTgtOC4yMjEtNC43LTE0LjI5NS0xMC44My0xNC4yMS0zLjEuMTU1LTE5LjMxNiwxLjc1Mi0zNC44Mi4xOC0xNS41NTQtLjkxOS0zMC4zOTQtNS4wMDYtMzEuODczLTEuMTQtMS41NzksMy42NDcsMTEuMzUsMTUuMzQyLDI3LjA5MywyMS44NzVDNDIuNzE4LDEzNC43NDcsNjEuMDI2LDEzNi43ODUsNjQuNDM2LDEzNi40OTFaIiBmaWxsPSIjMzZiMWI1Ii8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzE4IiBkYXRhLW5hbWU9IlBh
1dGggMTgiIGQ9Ik0xNDkuODc2LDEyNi42MzNjMCwyNy41NDYtMjIuMzMsMzEuMTk1LTQ5Ljg3NiwzMS4xOTVzLTQ5Ljg3Ni0zLjY0OS00OS44NzYtMzEuMTk1LDIyLjMzLTUzLjQsNDkuODc2LTUzLjRTMTQ5Ljg3Niw5OS4wODgsMTQ5Ljg3NiwxMjYuNjMzWiIgZmlsbD0idXJsKCNsaW5lYXItZ3JhZGllbnQpIi8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzE5IiBkYXRhLW5hbWU9IlBhdGggMTkiIGQ9Ik05MC40NjEsODYuNjQ5YTI5LjU0MywyOS41NDMsMCwwLDAtMTEuMSw2Ljc3NywzLjA2MSwzLjA2MSwwLDAsMS00LjI3NC00LjM4NCwzNS42MzMsMzUuNjMzLDAsMCwxLDEzLjM4MS04LjE4MSwzLjA1OSwzLjA1OSwwLDAsMSwzLjg5MiwxLjlDOTMuMSw4NC45MDgsOTAuOSw4Ni41LDkwLjQ2MSw4Ni42NDlaIiBmaWxsPSIjYWFmOWZjIi8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzIwIiBkYXRhLW5hbWU9IlBhdGggMjAiIGQ9Ik02OC45NzksMTIwLjI3OWE1LjYzOSw1LjYzOSwwLDEsMC01LjYzOS01LjYzOUE1LjYzOSw1LjYzOSwwLDAsMCw2OC45NzksMTIwLjI3OVoiIGZpbGw9IiMxMjEyMTIiLz4KICAgICAgPHBhdGggaWQ9IlBhdGhfMjEiIGRhdGEtbmFtZT0iUGF0aCAyMSIgZD0iTTEzMS43MjIsMTIwLjI3OWE1LjYzOSw1LjYzOSwwLDEsMC01LjYzOS01LjYzOUE1LjYzOSw1LjYzOSwwLDAsMCwxMzEuNzIyLDEyMC4yNzlaIiBmaWxsPSIjMTIxMjEyIi8+CiAgICAgIDxwYXRoIGlkPSJQYXRoXzIyIiBkYXRhLW5hbWU9IlBhdGggMjIiIGQ9Ik05OS40NDksMTM3LjcyM2EzMi45NjEsMzIuOTYxLDAsMCwwLDEwLjY1Ny0xLjY2NCwzMS4wNjEsMzEuMDYxLDAsMCwwLDkuMDgzLTQuOWwyLjAyNCwyLjk2OGEzNC44NSwzNC44NSwwLDAsMS05Ljg0OCw1LjYyMUEzMi40ODUsMzIuNDg1LDAsMCwxLDk5LjQ0OSwxNDEuOWEzMi44NDIsMzIuODQyLDAsMCwxLTExLjk2MS0yLjE1OCwzNS4wMDgsMzUuMDA4LDAsMCwxLTkuOC01LjYyMWwyLjAyMy0yLjk2OGEzMS4wNjcsMzEuMDY3LDAsMCwwLDkuMDgzLDQuOUEzMi45NjQsMzIuOTY0LDAsMCwwLDk5LjQ0OSwxMzcuNzIzWiIgZmlsbD0iIzEyMTIxMiIvPgogICAgPC9nPgogIDwvZz4KPC9zdmc+Cg=="},5946:e=>{"use strict";e.exports=JSON.parse('{"tool":{"title":"Tool Integrations","description":"OPA plays nice with a range of existing tools too via some bespoke\\nintegrations.\\n","content":"","filePath":"/opt/build/repo/docs/src/data/ecosystem/feature-categories/tool.md","id":"tool"},"rego":{"title":"Rego Language","description":"Rego is the policy language used by OPA and there are various integrations\\nthat make working with the language easier.\\n","content":"","filePath":"/opt/build/repo/docs/src/data/ecosystem/feature-categories/rego.md","id":"rego"},"production":{"title":"OPA at Scale","description":"OPA has a number of features that are most useful when running OPA in\\nproduction. These integrations make use of those features, and make it\\neasier to use OPA at scale.\\n","content":"","filePath":"/opt/build/repo/docs/src/data/ecosystem/feature-categories/production.md","id":"production"},"createwithopa":{"title":"Created with OPA","description":"OPA\'s SDKs and APIs offer a solid foundation for all kinds of projects. See\\nthe integrations below for inspiration.\\n","content":"","filePath":"/opt/build/repo/docs/src/data/ecosystem/feature-categories/createwithopa.md","id":"createwithopa"}}')},7016:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kong-authorization-789c0c4d7d9183cb12fca4ed5077a60a.png"},7113:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,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
11NTEzMTMxIDEyLjQ0Nyw2NCAxMyw2NCBMMzgsNjQgQzM4LjU1Miw2NCAzOSw2My41NTEzMTMxIDM5LDYyLjk5ODQ2NjggTDM5LDQyLjk2NzgwMzQgTDM3LDQyLjk2NzgwMzQgTDM3LDYxLjk5NjkzMzcgWiBNNjgsMzYuOTU4NjA0NCBDNjgsNDMuNDMwNTExNyA2Mi4xNzMsNDUuNjgxOTU4MyA1OS4wOTIsNDUuOTY4Mzk2OCBMNDMsNDUuOTcyNDAyOSBMNDMsNDMuOTY5MzM2NiBMNTksNDMuOTY5MzM2NiBDNTkuMTk1LDQzLjk0NjMwMTMgNjYsNDMuMjEyMTc3NSA2NiwzNi45NTg2MDQ0IEM2NiwzMS4yNjM4ODY3IDYwLjg2MywzMC4xMDgxMTc1IDU5LjgzNCwyOS45MzM4NTA3IEM1OS4zMjEsMjkuODQ2NzE3MyA1OC45NiwyOS4zODIwMDU5IDU5LjAwNCwyOC44NjMyMTE3IEM1OS4wMDUsMjguODQ0MTgyNiA1OS4wMDcsMjguODI2MTU1IDU5LjAwOSwyOC44MDgxMjc0IEM1OC45NTQsMjUuNTkwMjAxMyA1Ni45ODEsMjQuNTg0NjYyIDU2LjEyNiwyNC4zMDAyMjY2IEM1NC41MywyMy43Njk0MTQgNTIuNzUxLDI0LjI3NzE5MTMgNTEuODEsMjUuNTM5MTIzMSBDNTEuNTkxLDI1LjgzNTU3NjkgNTEuMjI5LDI1Ljk4NjgwODUgNTAuODYxLDI1LjkzMDcyMjYgQzUwLjQ5NywyNS44NzU2MzgzIDUwLjE5MiwyNS42MjUyNTUgNTAuMDY4LDI1LjI3NjcyMTQgQzQ5LjQ0NywyMy41MzYwNTY4IDQ4LjU0NiwyMi40MDgzMzA0IDQ3LjI5MywyMS4xNTM0MDk0IEM0NC4xNTksMTguMDM4NjQxMiAzOS45MDUsMTcuMTc4MzI0MiAzNS45MjUsMTguODUyODg3NyBDMzMuODM3LDE5LjczMzIzNTMgMzIuMDEyLDIxLjcyODI4OTQgMzAuOTIyLDI0LjMyNzI2OCBMMjkuMDc4LDIzLjU1MDA3ODIgQzMwLjM3LDIwLjQ3NDM2OTkgMzIuNTg0LDE4LjA4ODcxNzkgMzUuMTUsMTcuMDA3MDYyIEMzOS45MDUsMTUuMDA0OTk3MiA0NC45NzEsMTYuMDI1NTU5NSA0OC43MDQsMTkuNzM0MjM2OSBDNDkuNzc0LDIwLjgwNjg3ODkgNTAuNjYsMjEuODUxNDc4IDUxLjM1LDIzLjIwMzU0NzggQzUyLjg0MywyMi4wOTc4NTUxIDU0Ljg1NywyMS43NjczNDkyIDU2Ljc1NywyMi4zOTkzMTY2IEM1OS4xODksMjMuMjA4NTU1NCA2MC43MjcsMjUuMzIwNzg4OSA2MC45NzUsMjguMTI5MDg3OSBDNjQuMzgxLDI4Ljk4ODQwMzQgNjgsMzEuNzExNTcyMSA2OCwzNi45NTg2MDQ0IEw2OCwzNi45NTg2MDQ0IFoiIGlkPSJBV1MtQ2xvdWRGb3JtYXRpb25fSWNvbl82NF9TcXVpZCIgZmlsbD0iI0ZGRkZGRiI+PC9wYXRoPgogICAgPC9nPgo8L3N2Zz4="},8042:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/gcp-forseti-c8fc57b4b0777fa9e50f00f818baa8a9.png"},8158:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/permit-edd367ad78a114c187595ed69be4e230.png"},8395:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kubestellar-console-6f19bcc5d7fdd005ddc68e71bb5c5d05.svg"},8548:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,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
1LjY5LDk3LjY5LDAsMCwxLTE0LjE2LDEuNTdjLjUsMS42MS45LDMuMjUsMS4yNSw0LjlhNTMuMjcsNTMuMjcsMCwwLDEsMS4xNCwxMlYyMTdoLjA1YTg0LjQxLDg0LjQxLDAsMCwwLDI1LjM1LTUuNTUsODEsODEsMCwwLDAsMjYuMzktMTYuODJjLjgtLjc3LDEuNS0xLjU2LDIuMjYtMi4zNGE4Mi4wOCw4Mi4wOCwwLDAsMCw3LjkzLTkuMzhBNjMuNzYsNjMuNzYsMCwwLDAsMzMzLDE3Mi4xN2E0OC41NSw0OC41NSwwLDAsMCw0LjMyLTE2LjQ1Yy4wOS0xLjIzLjItMi40Ny4xOS0zLjdWMTUwcS0xLjA4LDEuNTQtMi4yNSwzLjA5QTk2LjczLDk2LjczLDAsMCwxLDMyNywxNjIuNDVabTAsNzcuOTJjLS42OS43LTEuMzEsMS40MS0yLDIuMWE5NC4yLDk0LjIsMCwwLDEtNjAuMiwyNS44NmgwbDAsMjYuNjdoMGE4MS42LDgxLjYsMCwwLDAsNTEuNzQtMjIuMzdBNzMuNTEsNzMuNTEsMCwwLDAsMzMzLDI1MC4xM2E0OC41Niw0OC41NiwwLDAsMCw0LjMyLTE2LjQ0Yy4wOS0xLjI0LjItMi40Ny4xOS0zLjcxdi0yLjE5Yy0uNzQsMS4wNy0xLjQ2LDIuMTUtMi4yNywzLjIxQTk1LjY4LDk1LjY4LDAsMCwxLDMyNywyNDAuMzdabTAtMzljLS42OS43LTEuMzEsMS40MS0yLDIuMWE5My4xOCw5My4xOCwwLDAsMS0xMC42Myw4LjY1LDkxLjYzLDkxLjYzLDAsMCwxLTExLjYzLDcsOTUuNDcsOTUuNDcsMCwwLDEtMzcuOTQsMTAuMThoMFYyNTZoMGE4MS42NSw4MS42NSwwLDAsMCw1MS43NC0yMi4zN2MuOC0uNzcsMS41LTEuNTYsMi4yNi0yLjM0YTgyLjA4LDgyLjA4LDAsMCwwLDcuOTMtOS4zOEE2My43Niw2My43NiwwLDAsMCwzMzMsMjExLjE1YTQ4LjU2LDQ4LjU2LDAsMCwwLDQuMzItMTYuNDRjLjA5LTEuMjQuMi0yLjQ4LjE5LTMuNzF2LTIuMmMtLjc0LDEuMDgtMS40NiwyLjE2LTIuMjcsMy4yMkE5NS42OCw5NS42OCwwLDAsMSwzMjcsMjAxLjM5WiIgY2xhc3M9ImNscy0xIi8+PC9zdmc+"},9595:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/circleci-35c51fd4ee4ce879b3125282feced539.png"},9606:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/rego-cheat-sheet-92a1aebfb4ea664b7d9c550b29f450a5.png"},11213:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/graphene-graphql-fc6b9451733c620ceb86a49ca3953d65.png"},11505:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/fig-7072d6bb0ae1724bf28c2d202f54bf04.png"},12217:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kafka-authorization-b9a03e6b1310027e272741b9cfbfbf8c.png"},12753:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,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"},14075:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/cloudflare-worker-717bcdbf16d21bc8b527007daab5b21c.png"},15364:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/linux-pam-ab6aa055a2cc6f28d0cedd15b689d28f.png"},15558:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE2LjAuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8IURPQ1RZUEUgc3ZnIFBVQkxJQyAiLS8vVzNDLy9EVEQgU1ZHIDEuMS8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9HcmFwaGljcy9TVkcvMS4xL0RURC9zdmcxMS5kdGQiPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB3aWR0aD0iNjMwcHgiIGhlaWdodD0iNjMwcHgiIHZpZXdCb3g9Ii0xNS43NTcgLTE1LjA4IDYzMCA2MzAiIGVuYWJsZS1iYWNrZ3JvdW5kPSJuZXcgLTE1Ljc1NyAtMTUuMDggNjMwIDYzMCIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI+CjxwYXRoIGZpbGw9IiNGRkZGRkYiIGQ9Ik0yODAuMDA5LDM0LjYyMUMzOTguNSwyNi40MDUsNDc3LjA2NSw4NC4zODksNTIxLjk4NywxNTUuMDM3YzIyLjUyNSwzNS40MjIsNDQuNjI1LDg5LjIyMiw0NC43MjcsMTQ0LjUgIGMwLjEwOSw2MC4wNi0xOS4zNDgsMTEyLjA3MS00NC43MjcsMTUwLjIzM2MtMjYuMDgyLD
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"},17697:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});
1const o=i.p+"assets/images/kubernetes-validating-admission-ce1f338cb33ce19111406f1a144dce2e.png"},18109:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/torque-298e5892352a6580e7073d4f07f43286.png"},19714:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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"},23831:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-java-wasm-247cc5d32b9861cfbfe3fb30eaffae47.png"},23936:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/gradle-plugin-5e505f4bc16813ca856549a19be38cf6.png"},25516:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/legitify-673d46cb72ba61d53539fca2b8d07c6e.png"},25635:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG4AAABuCAYAAADGWyb7AAAfoklEQVR4nO19B3Qb953mB4C99yqKTRIpUpSsLtFUL7ZcKJfIlvslzm3WbePcbd5tskn2eXcve7t7uY2f7SR21pvIstwo2TKlxLLVZYlW7xRJib03kRQ7SJR73x8zwKCQIkiAFGN+7w0xMxgQmPnm/+v/36gwCmTnbokBsAHAagAZAGYACAWgGc3/+xZBD6AdQDmAqwCOAthfkJ/X4OwlGDFx2blbeGwugBcBrAegtjtoCqOBAcABAL8BkF+Qn2d0GXHZuVvWAvgPAHPt3pSgUavh7e1tt38KFmi1WugNhuGuyBUArxbk5x2ye8cGwxKXnbslAMBbAJ5V7lepVJibnoZ5mbORnpqM+JgY+Pv52n1+Cvbo6e1DXWMjSsorcPFqES4Xl8BotBtk7wF4qSA/r9vuH8gc2O2xkEa9tRdAmrzP18cH96xagfvXrUZocJDdZ6bgPNpvdeJPB4/gq2PH0dvXp/x8CYAHCvLzSh39U4fEZeduyQJwEECkvG/F0kV47juPICQo0O74KYwdHZ1deG/nZzh26ozyf7UAWFeQn3fltsRJI61AJs3L0xMvPvcUchYvnKJnHHDizDm8tW0HBgYH5S8jedm2I8+KOEmnnZXFY4C/H3768guYlZL0F3NhJgOul1fil2/+Ft09vfKvpdhcpNR5tib9WzJpHGlTpE0MeM157cmBhDSJGzPMDnN27hb6Zr+St//me89i/pyMv/yrdIciPDQEMZEROHn+ovwD5yWkZZ6oKblG59004iTn+tfyESuXLsbdUzptwkEOyIUCv5a4MovKzQAyueLn64vntjz87bxSdyDIBTmRkClFr8zEvSi/c8+qHAQHTrzJ36/Voqi0zG7/tw3kgpwo8BJXVdm5W2IB1JkCIiq886//PGHO9c32Duz/+gQKzp5HQ3OL2LfjjV8plfS3EnTS/+p//UyOsPBPvAcHmewWzJ2dNq6k8YeUV9fgi8PHcOFqIW512Ud4Tl24hBVLFtnt/zaBnJCbS9eKIXF1D4lbIV+DuzJnu/1yDOp0OH+lUIR4ikvLoR0YsHo/LDgYaSlJaGhpQWVtPQ58feJbTxwkbiTiiBUkLkveSktJtvuAK9DV04MjBadw9NQZVNfVw6CIkPP2mRYbg/SUZKSnJiEyLEzsv1RcIoi7XlEpRibF+GSCVjuArt4e+Hr7uCQAb8PNHBKXIm8xyu8q1Dc2Yd+Rr3H60mW0trVb/VdPDw+kJiZgdkoyZiUnOTyxWUmJgqzBQZ0wUjJmzrA7ZjzAaH53b4+IYpgWab3XtN0ltpX7etDV0wu9Xi9+3QvPPIF1Odlj/qXxMdHKzRQPKXMNtVrt8AKOFBxFhddvCLKuFF+3jXQj0N9PkDQ7N
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
1Q+Ik8hi02wbgIeX+2FlzkJ6zTrxOjcCxgdYiQ3jFxw+KVxuwNdNzBfl5nY6+ZEjiYCJPJcUxfylnEGQw5xY7MxMRiakibsltZrinMDQGpCw5fbPW6jIRYOa2Dbjjp4xHFuTnDZnjGZY4BYHxknJ82lYvTsFlYBb3fQB/X5Cfd9t2u05NWcnO3cJ2438lETgx4fS/PLD2YweAdwry80ZcHz/quUbZuVs4/5dNkPlKi4U60WXRW5VarVGrNR7iVSNePeRtrqvUGg+1WqVRqUzrKpVqwiWBkalena5PN6DtHtT2d+u0/T1G6+wvU+3UWcxJMbF4tCA/z3FCbjgA+P+wE17qoB8hjgAAAABJRU5ErkJggg=="},25722:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/i2scim-5117224b1b7cb4cec8dbb0baf5f05a64.png"},27312:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/rekor-01c8c6305326797870c91adc31164459.svg"},27685:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,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
11MTZBOS44MzgsOS44MzgsMCwwLDEsMjI3LjI0OC0uNDIsMTIuNjg1LDEyLjY4NSwwLDAsMSwyMjEuOTI4LjcyOFoiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDMxLjU4OCAyNjYpIiBmaWxsPSIjMmY1NGViIi8+CiAgPC9nPgo8L3N2Zz4K"},30017:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-wasm-dotnet-af6e6a1b7ad8672fab95a8bfb8b9a869.png"},30608:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/scanara-74eb19c0c921368f10ea73b9b24f8820.png"},30660:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/pomerium-authz-a9856d87e6d86bf00d4b5bc90549421a.png"},31311:(e,t,i)=>{"use strict";function o(e){var t=i(77327),o=t.keys(),a="./"+e+".",s="./default.png",n=o.find((function(e){return e.startsWith(a)})),r=null;if(n?r=n:("default"!==e&&o.includes(s)||"default"===e&&o.includes(s))&&(r=s),!r)return console.warn("Logo key '"+e+"' not found, and default.png is also missing or not in context."),null;try{var c=t(r);return c.default||c}catch(g){if(console.error("Error loading logo asset '"+r+"':",g),r!==s&&o.includes(s))try{var A=t(s);return A.default||A}catch(l){return console.error("Error loading fallback default logo '"+s+"':",l),null}return null}}i.d(t,{A:()=>o})},31580:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/clair-datasource-66c36c1191c197b4f7ad2e062d75721c.png"},32509:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,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
1NCAzNzQuMTY0IDEyNC45MjZDMzczLjcxMyAxMTkuNzQ4IDM3MS40NTEgMTE0Ljg5NCAzNjcuNzc1IDExMS4yMThDMzY0LjA5OSAxMDcuNTQyIDM1OS4yNDUgMTA1LjI4IDM1NC4wNjYgMTA0LjgyOUMzNTMuNjUzIDEwNC43NzEgMzUzLjM0NyAxMDQuNDE2IDM1My4zNDkgMTAzLjk5OUMzNTMuMzUxIDEwMy41ODIgMzUzLjY2IDEwMy4yMyAzNTQuMDc0IDEwMy4xNzZDMzU5LjI1MSAxMDIuNzI1IDM2NC4xMDMgMTAwLjQ2NCAzNjcuNzc3IDk2Ljc4OTdDMzcxLjQ1MiA5My4xMTU1IDM3My43MTMgODguMjYyOCAzNzQuMTY0IDgzLjA4NkMzNzQuMjE4IDgyLjY3MjQgMzc0LjU3IDgyLjM2MjkgMzc0Ljk4NyA4Mi4zNjA5QzM3NS40MDQgODIuMzU5IDM3NS43NTkgODIuNjY1NSAzNzUuODE3IDgzLjA3ODdDMzc2LjI2OCA4OC4yNTc0IDM3OC41MzEgOTMuMTExMyAzODIuMjA2IDk2Ljc4NjdDMzg1Ljg4MiAxMDAuNDYyIDM5MC43MzUgMTAyLjcyNSAzOTUuOTE0IDEwMy4xNzZMMzk1LjkxNCAxMDMuMTc2WiIgZmlsbD0iIzRBOTJGRiIgLz4KICA8ZGVmcz4KICAgIDxsaW5lYXJHcmFkaWVudCBpZD0icGFpbnQwX2xpbmVhcl8wXzEiIHgxPSIyMzIuNjQxIiB5MT0iMjQ5LjE5NiIgeDI9IjIzMi42NDEiIHkyPSI0NDYiIGdyYWRpZW50VW5pdHM9InVzZXJTcGFjZU9uVXNlIj4KICAgICAgPHN0b3Agc3RvcC1jb2xvcj0iIzg2QkFFQiIgLz4KICAgICAgPHN0b3Agb2Zmc2V0PSIxIiBzdG9wLWNvbG9yPSIjMDA1Q0IzIiAvPgogICAgPC9saW5lYXJHcmFkaWVudD4KICA8L2RlZnM+Cjwvc3ZnPgo="},32631:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/principled-evolution-42b792ecf6e05c3bcc0e3e25b9f9707f.svg"},32670:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/scalr-iacp-718cbd4da74e1c671160b96bba74a1e9.png"},33244:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/graphql-fc6b9451733c620ceb86a49ca3953d65.png"},33599:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/terraform-bd24e438b686b0d145607687550462b6.png"},33671:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/alfred-4a9277f7b9762a25a4ed3354f7243822.png"},35323:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/open-service-mesh-8feec84163a6ac26b4036dc604c99861.png"},35379:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/swift-opa-b9243846be025ad0c89d459bde0d339f.png"},35558:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-golang-92a1aebfb4ea664b7d9c550b29f450a5.png"},35635:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kubernetes-authorization-ce1f338cb33ce19111406f1a144dce2e.png"},36471:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>d});var o=i(51107),a=i(50420),s=(i(96540),i(87331)),n=i(56062),r=i(90866),c=i(31311),A=i(55239),g=i(79493),l=(i(5946),i(42468),i(82790)),u=i(74848);const d=function(e){var t=e.route.customData.language,i={};for(var d in g){var p=g[d],M=p.for_language;M&&(i[M]||(i[M]=[]),i[M].push(p))}var w=i[t]||[],y=(0,A.A)(w),h=l[t].title,I=l[t].content;return(0,u.jsx)(a.A,{title:h,children:(0,u.jsxs)("div",{className:"container margin-vert--lg",children:[(0,u.jsxs)(o.A,{as:"h1",style:{margin:0},children:[h," OPA Ecosystem Projects"]}),I&&(0,u.jsx)("div",{style:{marginTop:"1rem"},children:(0,u.jsx)("div",{style:{marginTop:"0.5rem"},children:(0,u.jsx)(s.oz,{children:I})})}),(0,u.jsx)(r.A,{children:y.map((function(e){var t=w[e],i={title:t.title,note:t.subtitle,icon:(0,c.A)(t.id),link:"/ecosystem/entry/"+t.id,link_text:"View Details"};return(0,u.jsx)(n.A,{item:i})}))})]})})}},37166:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAABYlAAAWJQFJUiTwAAAAB3RJTUUH5gURCRsXCbiYZwAAGl9JREFUeNrtnXmU5FZ97z/3SrX0Mt09PTMez4wXbDdmcRKPeWBXzJKEJISXOBg4acMJDoWJCRAIOWZ5Ab+kHds5SYgTCORhHAjYhZuT4LIJJjjEPN5h8ZLCgdhjwPE+Hs/WMz3d0z291iL93h9SVUkqVXf1UlLNpL991FJJV/dKv9/v/jZdXcEGNrCBDWxgAxvYwAY2sIENbGADG/jvAhX3Baw3spn8ecAXgfuBv8kVhifXUBeAzhWG7bjvq104pQQgm8mfDvw78AJ31wTwh8CXc4XhVusAuAS4ErgMKAEX5QrD83HfXzug476A9UI2kzeBu6gzH2ALcDvw6Wwmr5c5n2wmfxnwA6AAvN+t63zgQ3HfX7twyggA8L+BS0P2K+APgFvc3t2AbCb/AuBe4OvAxSFFPpjN5PvivsF24JQQgGwmPwR8bJli7wI+EHLuG4FHgNfR3CQOAG+P+z7bgVNCAIA/BVItlPtL10kEIJvJvx/HbPS3cO47mmmQkxknvQBkM/kzgStaLN6FIyxkM/mrgU+vgAYvA86N+37XG2bcF7AOeDuQCO5Mpbvo7u4lne4mmUyTMBNow0Qp9ZZP7D50wdzczM+Uy0VVKi2yuLjA/NwMxeLCUu0o4PXAzXHf8HriVBCANwEYhsnA5q30DwzS17sZI2GCgDj/gNp2QuCi3t4+d1/9X7lc4sSJ40wdH2d2djqsrdewIQCdg6tfffdAd3fvRdtO20n/wBaUUn5mtwynrJlIMji4ncHB01hcXGB8/BDHJ4/WjgOviPue1xsnZSLo5msmNSJvFZFrgQuqvVjq3K/1/Pq6dsDt8OLr/d5t72axuMChg3uZnZ0CsID+XGF4Lm4arBdOOifws9dM/gLwn8CXUeqCmgyrFqS5RaXgkQNSqTQvOOfF7Nx1LkppAzgnbhqsJ04aE3DLB49vEvgkIlcREFxFy7x1IN7Szbad3+K2MDi4na6uXo6M7bsU+Enc9FgvnBQm4JYPTV2IyJ0CQ+FqX
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
1a5NUVeplINvAwnwoFLqVq3Nr9z64JtnW76AdUJs3eQdP3/Xy0Xsb9NB4wWD08b5ETaj6KpgAz8E9VWt9R1R9vbQe46z8asuvesM25Z3grwRuJAOe1y8ThAcT/47KPUtrY1v3vrAmw7HfVFVdIyhfOcr/3mbbVuvEpEMznuEu2kIF08KWMBTwEOgHtRa39/Vtemxm//fr7Yv5bkGdIwABPGeX/o3SqWFnbZtXSDCS0DOx/nU6nnAmTgfYI4TFs7sHk8Dj4P6sVLqUcMw93zh/stjmfd3NehYAVgK7/7FfzXK5eIO27bPFJEzgB0gpwFbgc1AN6gUiIEjKCkc82K6i+H+ruCo6CKObS4B8zhf+JoDZoBpUMeBSeCoUuqIUuqgaSYPfv77lxXjpsUGNrCBDWxgAxvYwAY2sIENbGADG9hAq/j/hwhNJ43KBMoAAAAldEVYdGRhdGU6Y3JlYXRlADIwMjItMDUtMTdUMDk6Mjc6MjIrMDA6MDCOhq/6AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDIyLTA1LTE3VDA5OjI3OjIyKzAwOjAw/9sXRgAAAABJRU5ErkJggg=="},37215:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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"},38273:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/atmos-3a25959d03902e3bb97f5335556f193a.png"},38706:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAAAAABVicqIAAANBGlDQ1BrQ0dDb2xvclNwYWNlR2VuZXJpY0dyYXlHYW1tYTJfMgAAWIWlVwdck9cWv9/IAJKwp4ywkWVAgQAyIjOA7CG4iEkggRBiBgLiQooVrFscOCoqilpcFYE6UYtW6satD2qpoNRiLS6svpsEEKvte+/3vvzud//fPefcc8495557A4DuRo5EIkIBAHliuTQikZU+KT2DTroHyMAYaAN3oM3hyiSs+PgYyALE+WI++OR5cQMgyv6am3KuT+n/+BB4fBkX9idhK+LJuHkAIOMBIJtxJVI5ABqT4LjtLLlEiUsgNshNTgyBeDnkoQzKKh+rCL6YLxVy6RFSThE9gpOXx6F7unvS46X5WULRZ6z+f588kWJYN2wUWW5SNOzdof1lPE6oEvtBfJDLCUuCmAlxb4EwNRbiYABQO4l8QiLEURDzFLkpLIhdIa7PkoanQBwI8R2BIlKJxwGAmRQLktMgNoM4Jjc/WilrA3GWeEZsnFoX9iVXFpIBsRPELQI+WxkzO4gfS/MTlTzOAOA0Hj80DGJoB84UytnJg7hcVpAUprYTv14sCIlV6yJQcjhR8RA7QOzAF0UkquchxEjk8co54TehQCyKjVH7RTjHl6n8hd9EslyQHAmxJ8TJcmlyotoeYnmWMJwNcTjEuwXSyES1v8Q+iUiVZ3BNSO4caViEek1IhVJFYoraR9J2vjhFOT/MEdIDkIpwAB/kgxnwzQVi0A
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"},38831:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/iptables-ab6aa055a2cc6f28d0cedd15b689d28f.png"},39750:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});
1const o=i.p+"assets/images/sql-datafiltering-b47f0de47453fac070bcafa33e06ea47.png"},39801:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opal-e2b8066b1fb681a95f380d739f5c8c9a.png"},41579:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-springboot-247cc5d32b9861cfbfe3fb30eaffae47.png"},42413:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/alluxio-4f5cca900ac3ff7cef3549ebd5717d91.png"},42468:e=>{"use strict";e.exports=JSON.parse('{"wasm-integration":{"title":"Wasm Integrations","description":"Projects using the Wasm functionality of OPA.","category":"createwithopa","content":"\\nOPA\u2019s [Wasm Functionality](/docs/wasm) has been used to build the following projects.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/wasm-integration.md","id":"wasm-integration"},"terraform":{"title":"Terraform","description":"Integrate OPA with Terraform","category":"tool","content":"\\nThese projects from the OPA ecosystem integrate OPA with either Terraform source code in HCL or Terraform plans in JSON.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/terraform.md","id":"terraform"},"status-api":{"title":"Status API","description":"Gather runtime information from OPA instances","category":"production","content":"\\nThese projects from the OPA ecosystem support gathering runtime information from OPA instances.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/status-api.md","id":"status-api"},"rest-api-integration":{"title":"REST API Integrations","description":"Examples of projects which integrate with the OPA REST API.","category":"createwithopa","content":"\\nOPA\u2019s [REST API](/docs/rest-api) is the foundation for many integrations. Public examples are listed below.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/rest-api-integration.md","id":"rest-api-integration"},"policy-testing":{"title":"Policy Testing","description":"Test and validate Rego policies","category":"rego","content":"\\nThese projects from the OPA ecosystem help with or support running of\\ntests on [Rego](../../policy-language) code.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/policy-testing.md","id":"policy-testing"},"opa-bundles":{"title":"Bundles","description":"Distribute policy and data to OPA instances","category":"production","content":"\\nThese projects from the OPA ecosystem make use of OPA Bundles.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/opa-bundles.md","id":"opa-bundles"},"opa-bundles-discovery":{"title":"Discovery Bundles","description":"Distribute flexible configuration to OPA instances","category":"production","content":"\\nThese projects from the OPA ecosystem support distributing Discovery Bundles.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/opa-bundles-discovery.md","id":"opa-bundles-discovery"},"learning-rego":{"title":"Learning Rego","description":"Learn and write Rego","category":"rego","content":"\\nLearn and write [Rego](/docs/policy-language) with these tools from the OPA Ecosystem.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/learning-rego.md","id":"learning-rego"},"kubernetes":{"title":"Kubernetes","description":"Integrate OPA with Kubernetes","category":"tool","content":"\\nThese projects from the OPA ecosystem make it easier to use OPA in Kubernetes use cases.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/kubernetes.md","id":"kubernetes"},"go-integration":{"title":"Go Integrations","description":"Projects using OPA as a Go module","category":"createwithopa","content":"\\nProjects using OPA as a Go module to implement policy-based functionality.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/go-integration.md","id":"go-integration"},"external-data":{"title":"External Data","description":"Manage and update external data loaded into OPA","category":"production","content":"\\nThese projects make use of OPA APIs to manage and update external data.\\nSee [External Data](/docs/external-data) for more information about this\\nfunctionality.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/external-data.md","id":"external-data"},"external-data-runtime":{"title":"External Data: Runtime","description":"Load in on demand at runtime","category":"production","content":"\\nThese projects extend OPA to supp
1ort the\\n[pulling of data at evaluation time](/docs/external-data/#option-5-pull-data-during-evaluation).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/external-data-runtime.md","id":"external-data-runtime"},"external-data-realtime-push":{"title":"External Data: Push","description":"Manage and update external data loaded into OPA","category":"production","content":"\\nThese projects make use of OPA APIs to manage and update data in realtime.\\nSee [External Data: Push Data](/docs/external-data/#option-4-push-data) for more information\\nabout this functionality.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/external-data-realtime-push.md","id":"external-data-realtime-push"},"envoy":{"title":"Envoy","description":"Integrate with the Envoy proxy","category":"tool","content":"\\nThese projects integrate OPA and Envoy or make using both together easier.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/envoy.md","id":"envoy"},"editors":{"title":"Code Editors","description":"Use OPA and Rego in your editor","category":"tool","content":"\\nThis page lists OPA integrations in various editors. These integrations\\nmake it easier to write Rego in your editor of choice.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/editors.md","id":"editors"},"debugging-rego":{"title":"Debugging Rego","description":"Work out what\'s going on with your Rego policies","category":"rego","content":"\\nDebugging Rego policies can be tricky. These projects and tools can help you\\nwork out what\'s going on.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/features/debugging-rego.md","id":"debugging-rego"}}')},42497:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/spinnaker-pipeline-5fb2cb50efb5b918684953e4bf2bbd95.png"},43071:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/pre-commit-hooks-0585cce9767692e858c929b20632b083.png"},43120:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/env0-ceac9bc0256d42cbe953cf531ecdd286.png"},43284:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/vscode-opa-92a1aebfb4ea664b7d9c550b29f450a5.png"},43980:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1MTIiIGhlaWdodD0iNTEyIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiI+CiAgPHJlY3Qgd2lkdGg9IjUxMiIgaGVpZ2h0PSI1MTIiIHJ4PSI5NiIgZmlsbD0iIzBmMTcyYSIvPgogIDxyZWN0IHg9IjU2IiB5PSI1NiIgd2lkdGg9IjQwMCIgaGVpZ2h0PSI0MDAiIHJ4PSI3MiIgZmlsbD0iIzExMTgyNyIgc3Ryb2tlPSIjMjJjNTVlIiBzdHJva2Utd2lkdGg9IjEyIi8+CiAgPHBhdGggZD0iTTE2MCAxNzZoNTZsNDAgNjQgNDAtNjRoNTZsLTY4IDEwNCA3MiAxMTJoLTU2bC00NC03MC00NCA3MGgtNTZsNzItMTEyeiIgZmlsbD0iI2U1ZTdlYiIvPgogIDx0ZXh0IHg9IjI1NiIgeT0iNDQ0IiB0ZXh0LWFuY2hvcj0ibWlkZGxlIiBmb250LWZhbWlseT0iQXJpYWwsIHNhbnMtc2VyaWYiIGZvbnQtc2l6ZT0iNDIiIGZpbGw9IiMyMmM1NWUiPktPUEE8L3RleHQ+Cjwvc3ZnPgo="},44040:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/apache-apisix-d5805fcedbff01725f3c04f3adcd8a20.png"},46001:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/enterprise-contract-27b184c577d5de158ca2f94e8023af4c.svg"},46171:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/styra-academy-247cc5d32b9861cfbfe3fb30eaffae47.png"},47254:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/envoy-authorization-29d773e285c1cf4f1538dd8871488e4a.png"},48059:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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"},48498:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/regal-c9d780e2b3f9cc36b9e5619e1588057b.png"},49002:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/aws-api-gateway-b320e55e598e3ba3b0ba6e6ede3b1bfd.png"},50253:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/conftest-92a1aebfb4ea664b7d9c550b29f450a5.png"},50730:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-python-82efb64f8698a267f8bfd3b57ceab88a.png"},54032:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/default-92a1aebfb4ea664b7d9c550b29f450a5.png"},54153:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/expressing-or-247cc5d32b9861cfbfe3fb30eaffae47.png"},54811:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/clojure-2f435fa11b53598021f19212163f4ebe.png"},54934:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-mcp-efd2083114784c3fb14c716296f52610.png"},55239:(e,t,i)=>{"use strict";function o(e){var t=[];return Object.keys(e).forEach((function(i){var o=e[i],a=0;if(Array.isArray(o.tutorials)){var s=o.tutorials.map((function(e){try{return new URL(e).host}catch(t){return null}}
1)).filter(Boolean);a=new Set(s).size}var n=0;Array.isArray(o.videos)&&(n=o.videos.length);var r=0;if(Array.isArray(o.blogs)){var c=o.blogs.map((function(e){try{return new URL(e).host}catch(t){return null}})).filter(Boolean);r=new Set(c).size}var A=0;Array.isArray(o.code)&&(A=o.code.length);var g=a+n+r+A;t.push({id:i,rank:g})})),t.sort((function(e,t){return t.rank-e.rank})),t.map((function(e){return e.id}))}i.d(t,{A:()=>o})},55370:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/google-kubernetes-engine-fe6d9978a4bd9b9e96faf11a266388c5.png"},55506:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/spacelift-0960880aaff335b7fc8a3e11d05bb836.png"},55590:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/gluu-gateway-authz-c1286b25a17a40ddbd10413d90a144eb.png"},55773:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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"},56062:(e,t,i)=>{"use strict";i.d(t,{A:()=>r});i(96540);var o=i(87331),a=i(28774);const s={card:"card_tSoT",header:"header_F_Jh",icon:"icon_VP0I",title:"title_aezp",note:"note_L3e1",link:"link_N59J",dateAdded:"dateAdded_Xndt"};var n=i(74848);function r(e){var t=e.item;return(0,n.jsxs)("div",{className:s.card,children:[(0,n.jsxs)("div",{className:s.header,children:[t.icon&&(0,n.jsx)("img",{src:t.icon,alt:"",className:s.icon}),(0,n.jsx)("h3",{className:s.title,children:t.title})]}),t.note&&(0,n.jsx)("div",{className:s.note,children:(0,n.jsx)(o.oz,{children:t.note})}),t.link&&(0,n.jsx)(a.A,{to:t.link,className:s.link,children:t.link_text||"Learn more"}),t.dateAdded&&(0,n.jsxs)("div",{className:s.dateAdded,children:["Added ",t.dateAdded]})]})}},56743:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABLAAAAFiCAYAAADm7yFMAAAACXBIWXMAABYlAAAWJQFJUiTwAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAA34SURBVHgB7dxBbhvXAcbxN2M1bdpFWQXdZGPqBj6CfYK2J4h7A3VhO8qm9iKwiyzsG8Q9gXOD5AjuCSgdIAa7KAo3taaUgwBBYDd6I/Lx08zvt6HWoh75vT9BlQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAdd4UoOT06HMlGvHi93/vexeLBa9n23KtN0uvkdHpUdW9xf/bEM5XT9xdHLwlZN/O9z9s7L8Gj9+OhhYeum/N7IdJ33HyzXn398Vvbgo09Xd4eu+7IwSZsXxJfDv4c762dH68LWeK+ZLhuN9+kLcK3d6MuiP+i+vogtBbi0vnR/XZysHhYA2KHNJ8K3ug83W+14tSjAz7LReB8BC6Zh0fciFtQykABoQcSCOjYa7yJgwXQsRSyoZyAB0IKIBXVsNH5KwIJpEbFgBAMJgBYuIlb/6+5pAS7FRuPHBCyYHhELRjCQAGhiKHcPPzv1T/vhkmw0fiBgwTSJWDCCgQRAEyIWVLHRuC
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"},57576:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});
1const o=i.p+"assets/images/opa-nats-e2b8066b1fb681a95f380d739f5c8c9a.png"},57715:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/nginx-6deb4c193ef741ce1c394984e7173ffd.png"},57773:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/kubernetes-provisioning-ce1f338cb33ce19111406f1a144dce2e.png"},58595:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/terraform-cloud-bd24e438b686b0d145607687550462b6.png"},59593:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-typescript-247cc5d32b9861cfbfe3fb30eaffae47.png"},60715:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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"},61445:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDAgMTAwIj4KICA8Y2lyY2xlIGN4PSI1MCIgY3k9IjUwIiByPSI1MCIgZmlsbD0iIzE2YTM0YSIvPgogIDxzdmcgeD0iMTgiIHk9IjE4IiB3aWR0aD0iNjQiIGhlaWdodD0iNjQiIHZpZXdCb3g9Ii0xLjUgLTEuNSAyNyAyNyIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmZmZmIiBzdHJva2Utd2lkdGg9IjIuNSIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBwcmVzZXJ2ZUFzcGVjdFJhdGlvPSJ4TWlkWU1pZCBtZWV0Ij4KICAgIDxsaW5lIHgxPSI2IiB5MT0iMyIgeDI9IjYiIHkyPSIyMSIvPgogICAgPGxpbmUgeDE9IjYiIHkxPSIxMiIgeDI9IjE4IiB5Mj0iNCIvPgogICAgPGxpbmUgeDE9IjYiIHkxPSIxMiIgeDI9IjE4IiB5Mj0iMjAiLz4KICAgIDxjaXJjbGUgY3g9IjYiIGN5PSIzIiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSI2IiBjeT0iMTIiIHI9IjIiLz4KICAgIDxjaXJjbGUgY3g9IjYiIGN5PSIyMSIgcj0iMiIvPgogICAgPGNpcmNsZSBjeD0iMTgiIGN5PSI0IiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSIxOCIgY3k9IjIwIiByPSIyIi8+CiAgPC9zdmc+Cjwvc3ZnPgo="},63424:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/flipt-39c97ddab08b696d6c211803c3b6b042.png"},63965:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/boomerang-bosun-cd50744e45a39ed2379972d46f241172.png"},65328:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-java-247cc5d32b9861cfbfe3fb30eaffae47.png"},65614:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/eopa-247cc5d32b9861cfbfe3fb30eaffae47.png"},66266:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/coredns-authz-f876d87af36125a9bfb44e4e949a5f29.png"},66417:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/sphinx-rego-633193e48f886acb76010c7ad24d6a35.png"},66438:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/spire-2961c60dce327b676306d41b752df856.png"},67544:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAW8AAAEOCAMAAABxSmbZAAAAOVBMVEVHcEwMIJIAII8cLpn///8NIJIMIJEMIJIMIJINIZQWKZYMIZBJV64III8NIZMMIJFJW7ANIZIgMpsYmx7XAAAAEXRSTlMAWhD+E+mZf8BAujBOINHPKi29CccAAAhfSURBVHja7d1dg5sqEIBh8SxfWvW4///Hnoump0lXZYCBTZp3Lnq1dvQJEiIjDANBEP3ih5sEEapiMjj/ivVTEP/slQH4LeZPUdR6e6R/Rvzs0r7xxhtvvPHGG2+88cabwBtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cYbb7zxxhtvvPHGG2+88cb7fI8Ed3zAxw/RhgGquLlh49N6n590OD7g38/Pp/fe9+Wv8fYv4e3x7hoO764R8MYbb7zxxhtvvPHGG2+8+X2JN89P7mJ+Ce/5r/H+MM/vbZ93NiLf++PjR27EvvG0jbvQOzuYZcQbb7yJJ/Eec/4haN944w0O3ngTeONN4I033gTeeBN4403gjTfeBN54E3jjjTfeqhG9C9tPwC04H8cG3mP0LtjbUcH5LqsFROPCLakNzpsnKL2Y3XbA6GdV78Mkk2+6YMBoJvsl5+ZMi1xL9N774Lz3l///6O2Z5HbXGOq8F3eaJP
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"},67697:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/fiber-a9bfc6d0d26422777859de89367b1108.png"},68383:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/flask-opa-69910ea536ce5a258e77e5b379d53ac8.png"},68719:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-wasm-java-f5dd86c3ef6ef3f85acf14f07bf0daa8.png"},69286:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/gloo-api-gateway-644174134f9c7bc8d7375fd7f54501e9.png"},69517:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/trino-165953016d653cdea0df649083cee8ce.png"},70018:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/asp-dotnet-core-af6e6a1b7ad8672fab95a8bfb8b9a869.png"},70245:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/dependency-management-data-8bae3cdc76ec6120ca7f705499b34d33.png"},71252:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/zed-rego-92a1aebfb4ea664b7d9c550b29f450a5.png"},71579:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAIAAAAiOjnJAAAS3ElEQVR4nOydWVAb2XrHW7vQLoEEEpJAIMS+ecE2Zt+MbTYbsD32zHiuxzMpTyY3N095zVue85hUpfKQSvKS3JqqW8nNS6buZJZ4xttggw2GwSsGIXYENovUOS3NeDC2sZbuPovOr7qmRiqs/tT913e+7/T5viOv+6v/YCgUvpFrNmWwbaAQiBS2AUhgMapgm0AaVFgc5zp8KgW9FHxCryaHx2E4fjQXthVEQYX1Mz2NHplUAtsKcqDC4pBImGyrrvlANmxDyIEKKwrnqz49XaZLU8C2hBCosDiiQ6BRp+qqz4VrCTFQYUX4Jbg6UZdL00NeoBeR42XQnmnR9DXnwzSFFKiwdnOuw2fQKmFbgT1UWBEkv040aNTyjsNuiLaQARUWx675q8E2rzZNDscUUqDCivCqskx61ce9pZBMIQQqLI7XZ9zbD7nAmAjBFFKgwnozSoXsbEcBbCswhgqLQyJ5w1PCnoY8p00nvjFkQIX1VsBQeL7TB9sKXKHC2ovaCrvVrIZtBZZQYXG8aSTkSFPL3+soZFlxrSECKqx3cLwu15djgm0FflBhceyxwE8qYdpqnCz1WnFChRXhbWNhhK46T45dL5otZECFxbH3kmS5XPrJqTK6bDkuqLAivEs1NaWZnmyDKKYQAhUWRyze6L1jdE4rDqiwYqWuKruQpocxQ4XF8cZHOruQSpnfnquk6WGMUGHFgddl8rmp04oJKqz4+OQUXacVE1RYHDGMhD9T6bPWVzuEtIUQqLCixDFLNdDqpXHWO6HC4ohr8tPnNh8qsQllCilQYUWIR1kgPbzYXayQ0Uu3F/TqcMT7uAakh/XVdkFMIQUqrATpaqBtj/aCCosj9qzwJaV56U207dHbocJKnIsnizUqWiL2ZqiwoiQyqGWma/YVW3k3hQyosDgSGAqjfHqqTEnbHr0JelGSAjitrnoPbCtQhAqLI5ns7oMThTQ9fB0qrAhJCEOjVhw74qaraXZBhcUhScpnMRe7inW07dGrUGHxgEmv6m3Kg20FWlBhRUg6Ruo8kkPTw53Qa8GRfOwN0sMLnYV04fJLqLAi8JHVdTd4rOY0Hj6ICKiwOJIM3qNo00B6mEN9VhQqLD7pafDQrQ+jUGFxJPxIZxcgPaSRVhQqLJ7prM3JttIGk1RYfKOQSzu4ifhUd1pUWBx8DYVRBlq97qxUb3tEhRWFT2UBp3Uu5TuIUGFx8L44ob7KkWFK6a64VFgR+FaWSin7uLcklSMtKiwOIZZTNe53FuaYBfhgPKDCEgqZVNLfmp+yPosKiyOW/lgJcLTS4crUCvHJ6EOFJSAgPfyLc5WwrYADFZawVPqsFQXpsK2AABUWhzAjYeSTGaavKS8F00PyhZVuVMHdHe5IuX1fUcrVtZIvrL6mfJ1GsfffCOexGK7tkeRSb4mAJ0ASwoVlNqi6G2IpKBW2MNDnNpd4UmtOi3BhgTEoLYa+HSLUm37YVcwwKRRpkSwskO
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"},72e3:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/moat-1e74c82f919bcf2de8833b0e605f8405.png"},72671:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/github-action-opa-rego-test-5331c5a9f38fef183fafac30fdb000af.png"},75103:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/optoggles-9d6a1440d7a0bc5a7491afc3b79a5bb8.png"},75677:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-errors-247cc5d32b9861cfbfe3fb30eaffae47.png"},76119:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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
1BVhouOxG8nPcRRBesJ3Czvwf8VVVXN7ed/wcZkZiSPaZt2gAAAABJRU5ErkJggg=="},77327:(e,t,i)=>{var o={"./alfred.png":33671,"./alluxio.png":42413,"./antlr.png":85042,"./apache-apisix.png":44040,"./aserto.png":78993,"./asp-dotnet-core.png":70018,"./atmos.png":38273,"./aws-api-gateway.png":49002,"./aws-cloudformation-hook.svg":7113,"./backstage.svg":8548,"./big-acl.png":38706,"./boomerang-bosun.png":63965,"./bottle.png":76119,"./carbonetes.png":85735,"./ceph.png":627,"./circleci.png":9595,"./clair-datasource.png":31580,"./clojure.png":54811,"./cloudflare-worker.png":14075,"./conftest.png":50253,"./coredns-authz.png":66266,"./cosign.png":81274,"./dapr.png":67544,"./dart-authorization.png":48059,"./default.png":54032,"./dependency-management-data.png":70245,"./digger.png":55773,"./docker-machine.png":89071,"./easegress.svg":27685,"./elasticsearch-datafiltering.png":88259,"./emissary-ingress.png":78520,"./enterprise-contract.svg":46001,"./env0.png":43120,"./envoy-authorization.png":47254,"./eopa.png":65614,"./evolith.png":88746,"./expressing-or.png":54153,"./fiber.png":67697,"./fig.png":11505,"./flask-opa.png":68383,"./flipt.png":63424,"./gcp-forseti.png":8042,"./github-action-opa-rego-test.png":72671,"./gloo-api-gateway.png":69286,"./gluu-gateway-authz.png":55590,"./google-calendar.png":37215,"./google-kubernetes-engine.png":55370,"./gradle-plugin.png":23936,"./graphene-graphql.png":11213,"./graphql.png":33244,"./i2scim.png":25722,"./iptables.png":38831,"./istio-authorization-mixer.png":71579,"./jenkins-job-authorization.png":84587,"./kafka-authorization.png":12217,"./kong-authorization.png":7016,"./kopa.svg":43980,"./kubernetes-authorization.png":35635,"./kubernetes-provisioning.png":57773,"./kubernetes-validating-admission.png":17697,"./kubescape.png":4592,"./kubeshield.png":88687,"./kubestellar-console.svg":8395,"./legitify.png":25516,"./linux-pam.png":15364,"./lula.svg":92587,"./magda.png":56743,"./minio.png":92295,"./moat.png":72e3,"./nacp.png":84385,"./nginx.png":57715,"./nodejs-express.png":93637,"./oauth2.svg":15558,"./ocpr.svg":5767,"./oidc.png":1780,"./opa-aspnetcore.png":80696,"./opa-csharp.png":409,"./opa-dotnet-asp-core.png":405,"./opa-dotnet.png":87502,"./opa-errors.png":75677,"./opa-golang.png":35558,"./opa-java-client.png":91210,"./opa-java-wasm.png":23831,"./opa-java.png":65328,"./opa-mcp.png":54934,"./opa-nats.png":57576,"./opa-playground.png":95243,"./opa-python.png":50730,"./opa-springboot.png":41579,"./opa-typescript.png":59593,"./opa-wasm-dotnet.png":30017,"./opa-wasm-java.png":68719,"./opa-wasm-js.png":81002,"./opa-wasm-rust.png":94341,"./opa-wasm-zig.svg":12753,"./opal.png":39801,"./open-service-mesh.png":35323,"./openfaas-function-authorization.png":25635,"./optoggles.png":75103,"./ossrisk.svg":61445,"./permit.png":8158,"./php-authorization.png":4607,"./pomerium-authz.png":30660,"./pre-commit-hooks.png":43071,"./principled-evolution.svg":32631,"./pulumi.png":80853,"./raygun.png":99901,"./regal.png":48498,"./rego-cheat-sheet.png":9606,"./rego-test-assertions.png":93135,"./regocpp.svg":82549,"./rekor.svg":27312,"./reposaur.png":37166,"./rond.png":81428,"./scalr-iacp.png":32670,"./scanara.png":30608,"./spacelift.png":55506,"./sphinx-rego.png":66417,"./spinnaker-pipeline.png":42497,"./spire.png":66438,"./springsecurity-api.png":4621,"./sql-datafiltering.png":39750,"./strimzi.png":60715,"./styra-academy.png":46171,"./swift-opa.png":35379,"./sysdig-image-scanner.png":95143,"./tavoai.png":80897,"./terraform-cloud.png":58595,"./terraform.png":33599,"./topaz.svg":32509,"./torque.png":18109,"./traefik-api-gateway.png":86535,"./trino.png":69517,"./vscode-opa.png":43284,"./vulnetix.png":19714,"./waltid.png":85092,"./zed-rego.png":71252};function a(e){var t=s(e);return i(t)}function s(e){if(!i.o(o,e)){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}return o[e]}a.keys=function(){return Object.keys(o)},a.resolve=s,e.exports=a,a.id=77327},78520:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/emissary-ingress-99a20b58bf1471ef996f3d1785c12ed2.png"},78993:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/aserto-539140b878430df17586ed60ce5f90eb.png"},79493:e=>{"use strict";e.exports=JSON.parse('{"zed-rego":{"title":"Zed Extension","subtitle":"OPA Integration for the Zed editor","labels":{"category":"tooling","layer":"editor"},"inventors":["styra"],"code":["https://github.com/StyraInc/zed-rego"],"software":["editors"],"docs_features":{"editors":{"note":"The Zed editor extension for Rego and OPA has support for\\nsyntax highlighting, running of OPA tests, completions, linting\\nvia the [Regal Language Server](/integrations/regal/).\\n"}},"content":"\\nThe [zed-rego extension](https://github.com/StyraInc/zed-rego)\\nis an extension for the [Zed editor](https://zed.dev/) that provides\\nsupport for the Rego language and OPA functionality. The extension\\nalso includes support for the [Regal Language Server](/integrations/regal/).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/zed-rego.md","id":"zed-rego"},"wirelesssecuritylab":{"title":"ccbr","subtitle":"CIS Benchmark for Kubernetes with Rego","labels":{"category":"network","layer":"application"},"software":["ccbr"],"code":["https://github.com/wirelesssecuritylab/ccbr"],"inventors":["wirelesssecuritylab"],"docs_features":{"kubernetes":{"note":"Implements the CIS benchmark using Rego for Kubernetes workloads."}},"allow_missing_image":true,"content":"\\nCCBR is a policy management system project. It uses the policy language\\nRego to implement the CIS benchmark test of cloud native Kubernetes.\\nIn addition, it integrates gatekeeper, manages its constraint templates,\\nconstraints and policies, and supports policy deployment and audit inspection.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/wirelesssecuritylab.md","id":"wirelesssecuritylab"},"waltid":{"title":"walt.id SSI Kit","subtitle":"Self-Sovereign Identity toolkit with OPA policy supp
1ort","labels":{"category":"authorization","layer":"application","type":"poweredbyopa"},"inventors":["waltid","blockchainlabum","netis"],"software":["ssikit"],"code":["https://github.com/walt-id/waltid-identity"],"tutorials":["https://docs.walt.id/community-stack/verifier/credential-verification/policies/dynamic-verification-policies"],"videos":[{"title":"Verifying W3C Verifiable Credentials with the SSI Kit using OPA (Open Policy Agent)","speakers":[{"name":"Severin Stampler","organization":"waltid"}],"link":"https://youtu.be/mue4UjzOZ3Q"}],"docs_features":{"rest-api-integration":{"note":"SSI Kit\'s CLI exposes policy management commands which update a local\\nOPA instance. The feature is\\n[documented in the walt.id docs](https://docs.walt.id/community-stack/verifier/credential-verification/policies/dynamic-verification-policies).\\n"}},"content":"\\nVerifying W3C Verifiable Credentials for building SSI (Self-Sovereign Identity) use cases.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/waltid.md","id":"waltid"},"vulnetix":{"title":"Vulnetix","subtitle":"Unified CLI security scanner powered by Rego policies","labels":{"category":"security","layer":"application","type":"poweredbyopa"},"software":["github","kubernetes","docker","terraform"],"inventors":["vulnetix"],"code":["https://github.com/vulnetix/cli"],"tutorials":["https://www.vulnetix.com/features/code-scanner","https://docs.cli.vulnetix.com/docs/getting-started/"],"docs_features":{"policy-testing":{"note":"Vulnetix ships with 250+ built-in Rego rules spanning SCA, IaC, container,\\nsecrets, SAST, license and SBOM checks, and lets teams extend coverage\\nwith their own policy-as-code rule repositories via the `--rule` flag.\\nSee the\\n[Code Scanner docs](https://docs.cli.vulnetix.com/docs/sast-rules/custom-rules/)\\nfor details.\\n"}},"content":"\\nVulnetix is a unified CLI security scanner that uses Rego to evaluate findings\\nacross Software Composition Analysis (SCA), Infrastructure as Code (IaC),\\ncontainers, secrets, Static Application Security Testing (SAST), license\\ncompliance, and SBOM generation for 35+ ecosystems.\\n\\nPolicy-as-code is a first-class concern: detections, severity thresholds, and\\nsupply-chain controls (such as `--block-malware`, `--block-unpinned`,\\n`--version-lag`, and `--cooldown`) are expressed as Rego rules, so organizations\\ncan tune or replace the built-in rule set to match their own security posture.\\nResults can be emitted as SARIF, CycloneDX, SPDX, VEX, or token-efficient plain\\ntext for [use in CI](https://www.vulnetix.com/integrations) quality gates and\\n[AI coding agents](https://ai-docs.vulnetix.com/docs/getting-started/installation/).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/vulnetix.md","id":"vulnetix"},"vscode-opa":{"title":"VS Code Extension","subtitle":"OPA Integration for the VS Code editor","labels":{"category":"tooling","layer":"editor"},"code":["https://github.com/open-policy-agent/vscode-opa"],"videos":["https://www.youtube.com/watch?v=BpMttxuPv6Y"],"tutorials":["https://www.openpolicyagent.org/projects/regal/editor-support#visual-studio-code"],"software":["editors"],"inventors":["styra"],"docs_features":{"editors":{"note":"This is the official VS Code extension for Rego and OPA. The\\nextension brings a number of features that make writing Rego easier\\nsuch as syntax highlighting, running of OPA tests as well as\\ncompletions, linting and more from the\\n[Regal Language Server](/integrations/regal/).\\n"},"debugging-rego":{"note":"The extension provides support for debugging Rego policies using the\\nnative VS Code debugging interface. This is based on Regal\'s Debug\\nAdapter, see the\\n[VS Code documentation](/projects/regal/editor-support#visual-studio-code)\\nto get started.\\n"}},"content":"\\nThe [vscode-opa extension](https://marketplace.visualstudio.com/items?itemName=tsandall.opa)\\nis a Visual Studio Code extension that provides support for the Rego language\\nand OPA functionality. The extension includes syntax highlighting, and first\\nclass support for the Regal\\n[Language Server](/projects/regal/language-server) and\\n[Debug Adapter](/projects/regal/debug-adapter).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/vscode-opa.md","id":"vscode-opa"},"trino":{"title":"Trino","software":["trino"],"tutorials":["https://trino.io/ecosystem/add-on#open-policy-agent","https://trino.io/docs/current/security/opa-access-control.html","https://trinodb.github.io/presentations/presentations/what-is-trino/index.html"],"code":["https://github.com/trinodb/trino/tree/master/plugin/trino-opa"],"blogs":["https://trino.io/blog/2024/02/06/opa-arrived"],"videos":[{"title":"Trino OPA Authorizer - Stackable and Bloomberg at Trino Summit 2023","link":"https://www.youtube.com/watch?v=fbqqapQbAv0"},{"title":"Avoiding pitfalls with query federation in data lakehouses - Raft at Trino Summit 2023","link":"https://www.youtube.com/watch?v=6KspMwCbOfI&t=1279s"}],"content":"\\nTrino is a ludicrously fast, open source, SQL query engine designed to query\\nlarge data sets from one or more disparate data sources.\\n\\nThe OPA Trino plugin enables the use of Open Policy Agent (OPA) as authorization\\nengine for access control to catalogs, schemas, tables, and other objects in\\nTrino. Policies are defined in OPA, and Trino checks access control privileges\\nin OPA.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/trino.md","id":"trino"},"traefik-api-gateway":{"title":"Traefik API Gateway","labels":{"category":"servicemesh","layer":"gateway"},"tutorials":["https://plugins.traefik.io/plugins/659e6aaf0f0494247310c69a/jwt-and-opa-access-management"],"code":["https://github.com/traefik-plugins/traefik-jwt-plugin","https://github.com/unsoon/traefik-open-policy-agent"],"content":"\\nThe Traefik API Gateway is open-source software that controls API traffic into your application.\\nOPA can be configured as a plugin to implement authorization policies for those APIs.\\n\\n[`traefik-jwt-plugin`](https://github.com/traefik-plugins/traefik-jwt-plugin)\\nis a Traefik plugin which checks JWT tokens for required fields.\\n\\n[`traefik-open-policy-agent`](https://github.com/unsoon/traefik-open-policy-agent)\\nis another plugin available for use cases where more than JWT validation is needed.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/traefik-api-gateway.md","id":"traefik-api-gateway"},"torque":{"title":"Torque","labels":{"category":"Environments as a Service","layer":"Infrastru
1cture","type":"poweredbyopa"},"software":["terraform","helm","cloudformation","kubernetes","ansible","aws","gcp","azure"],"tutorials":["https://docs.qtorque.io/governance/policies"],"code":["https://github.com/QualiTorque/opa"],"inventors":["quali"],"blogs":["https://www.quali.com/blog/enforcing-open-policy-agent-guardrails-across-your-cloud-configurations/"],"docs_features":{"cli-integration":{"note":"Torque policy evaluation is done using the OPA CLI. See an\\n[example command](https://github.com/QualiTorque/opa#perform-policy-evaluation)\\nin the documentation.\\n"},"terraform":{"note":"Torque supports Terraform policy enforcement and defines some\\n[sample policies here](https://github.com/QualiTorque/opa).\\n"}},"content":"\\nTorque by Quali is a cloud-based platform that provides infrastructure automation and orchestration solutions for digital transformation and DevOps initiatives. Troque utilizes Open Policy Agent (OPA) to enforce policy-as-code, enabling users to define and automate their own security, compliance, and governance policies across their infrastructure.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/torque.md","id":"torque"},"topaz":{"title":"Topaz","labels":{"category":"authorization","layer":"application","type":"poweredbyopa"},"inventors":["aserto"],"software":["topaz"],"code":["https://github.com/aserto-dev/topaz"],"tutorials":["https://www.topaz.sh","https://github.com/aserto-dev/topaz#quickstart"],"blogs":["https://www.aserto.com/blog/topaz-oss-cloud-native-authorization-combines-opa-zanzibar"],"docs_features":{"go-integration":{"note":"Topaz\'s Authorizer component makes use of the Rego API to evaluate\\npolicies to make authorization decisions for connected applications.\\n"}},"content":"\\nTopaz is an open source authorization service providing fine grained, real-time, policy based access control for applications and APIs.\\nTopaz uses OPA as its decision engine, and includes an embedded database that stores subjects, relations, and objects, inspired by the Google Zanzibar data model.\\nTopaz can be deployed as a sidecar or microservice in your cloud.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/topaz.md","id":"topaz"},"terraform":{"title":"Terraform Policy","subtitle":"Check resources are compliant before they\'re deployed.","software":["terraform","aws","gcp","azure"],"labels":{"category":"publiccloud","layer":"orchestration"},"tutorials":["https://www.openpolicyagent.org/docs/terraform.html","https://github.com/open-policy-agent/conftest/blob/master/README.md"],"code":["https://github.com/open-policy-agent/conftest","https://github.com/fugue/regula","https://github.com/tenable/terrascan","https://github.com/Checkmarx/kics","https://github.com/open-policy-agent/library/tree/master/terraform","https://github.com/tenable/terrascan/tree/master/pkg/policies/opa/rego","https://github.com/Checkmarx/kics/tree/master/assets/queries/terraform"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/policy-based-infrastructure-guardrails-with-terraform-and-opa/"],"inventors":["fugue","accurics","checkmarx","medallia","styra","docker","snyk"],"content":"\\nTerraform lets you describe the infrastructure you want and automatically\\ncreates, deletes, and modifies your existing infrastructure to match. OPA makes\\nit possible to write policies that test the changes Terraform is about to make\\nbefore it makes them.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/terraform.md","id":"terraform"},"terraform-cloud":{"title":"Terraform Cloud","software":["terraform","terraform-cloud","aws","gcp","azure"],"labels":{"category":"publiccloud","layer":"orchestration"},"tutorials":["https://developer.hashicorp.com/terraform/cloud-docs/workspaces/policy-enforcement/define-policies/opa","https://developer.hashicorp.com/terraform/tutorials/cloud/drift-and-policy","https://developer.hashicorp.com/terraform/cloud-docs/workspaces/policy-enforcement/manage-policy-sets/opa-vcs"],"videos":[{"title":"Terraform Cloud Learn Lab: Validate Infrastructure and Enforce OPA Policies","speakers":[{"name":"Rita Sokolova","organization":"HashiCorp"},{"name":"Cole Morrison","organization":"HashiCorp"}],"venue":"HashiConf Europe 2022","link":"https://www.youtube.com/watch?v=jO2CiYMPxFE"}],"inventors":["hashicorp"],"docs_features":{"terraform":{"note":"Terraform cloud has native support for enforcing Rego policy on plans.\\nThe feature is [documented here](https://developer.hashicorp.com/terraform/cloud-docs/workspaces
1/policy-enforcement/define-policies/opa).\\n"}},"content":"\\nPolicies are rules that Terraform Cloud enforces on runs. You use the Rego\\npolicy language to write policies for the Open Policy Agent (OPA) framework.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/terraform-cloud.md","id":"terraform-cloud"},"tavoai":{"title":"TavoAI","software":["tavo"],"inventors":["tavoai"],"code":["https://github.com/TavoAI/tavo-sdk","https://github.com/TavoAI/tavo-cli"],"content":"\\nTavo leverages OPA for proactive AI risk management by enforcing risk controls. Risk controls are translated to Rego code and allow developers to implement the controls seamlessly by integrating with Tavo SDK.\\nTavo uses OPA as the decision engine for control enforcement.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/tavoai.md","id":"tavoai"},"sysdig-image-scanner":{"title":"Sysdig Image Scanner Admission Controller","software":["kubernetes","sysdigsecure"],"labels":{"category":"containers","layer":"orchestration"},"code":["https://github.com/sysdiglabs/opa-image-scanner"],"inventors":["sysdig"],"docs_feature":{"kubernetes":{"note":"Integrates image scanning results with Kubernetes admission checks\\nusing Rego to make pod admission decisions. See the\\n[README](https://github.com/sysdiglabs/opa-image-scanner#overview)\\nfor more details.\\n"}},"content":"\\nSysdig\u2019s OPA Image Scanner combines Sysdig Secure image scanner with OPA policy-based rego language to evaluate the scan results and the admission context, providing great flexibility on the admission decision.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/sysdig-image-scanner.md","id":"sysdig-image-scanner"},"swift-opa":{"title":"Swift-OPA","subtitle":"Swift package for evaluating OPA IR Plans","for_language":"swift","labels":{"category":"sdk","layer":"application"},"inventors":["Apple"],"blogs":["https://openpolicyagent.org/blog/introducing-swift-opa-native-policy-evaluation-for-swift-d5136c8a662e"],"code":["https://github.com/open-policy-agent/swift-opa"],"tutorials":["https://github.com/open-policy-agent/swift-opa?tab=readme-ov-file#usage"],"content":"\\nSwift-OPA is a Swift package for evaluating\\n[OPA IR Plans](https://www.openpolicyagent.org/docs/ir) compiled from\\n[Rego](https://www.openpolicyagent.org/docs/latest/policy-language/#what-is-rego)\\ndeclarative policy.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/swift-opa.md","id":"swift-opa"},"strimzi":{"title":"Strimzi (Apache Kafka on Kubernetes)","software":["kafka","strimzi"],"labels":{"category":"streaming","layer":"data"},"blogs":["https://strimzi.io/blog/2020/08/05/using-open-policy-agent-with-strimzi-and-apache-kafka/","https://strimzi.io/blog/2020/09/01/enforce-custom-resource-policies-with-opa-gatekeeper/"],"code":["https://github.com/strimzi/strimzi-kafka-operator","https://github.com/scholzj/demo-opa-kafka-authorization","https://github.com/StyraOSS/opa-kafka-plugin"],"inventors":["redhat"],"docs_features":{"rest-api-integration":{"note":"Strimzi can be configured to use OPA via the REST API as the Kafka\\nauthorizer using [this project](https://github.com/scholzj/demo-opa-kafka-authorization).\\n"}},"content":"\\nStrimzi provides a way to run an Apache Kafka cluster on Kubernetes in various deployment configurations. Strimzi ships with the OPA authorizer plugin right out of the box, and supports OPA as an option for Kafka authorization.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/strimzi.md","id":"strimzi"},"sql-datafiltering":{"title":"SQL Database Data Filtering","labels":{"layer":"data","category":"filtering"},"software":["sqlite"],"code":["https://github.com/open-policy-agent/contrib/tree/main/data_filter_example"],"blogs":["https://openpolicyagent.org/blog/write-policy-in-opa-enforce-policy-in-sql-d9d24db93bf4"],"inventors":["styra"],"content":"\\nThis integration enables the client of a SQL database to enhance a SQL query so that the results obey an OPA-defined policy.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/sql-datafilter
1ing.md","id":"sql-datafiltering"},"springsecurity-api":{"title":"Spring Security Authorization","subtitle":"Use OPA to make authorization decisions in Spring applications","for_language":"java","labels":{"layer":"network","category":"application"},"software":["java"],"code":["https://github.com/open-policy-agent/contrib/tree/main/spring_authz","https://github.com/Bisnode/opa-spring-security","https://github.com/massenz/jwt-opa","https://github.com/eugenp/tutorials/tree/master/spring-security-modules/spring-security-opa","https://github.com/big-acl/authz-spring-boot-starter"],"tutorials":["https://github.com/open-policy-agent/contrib/blob/main/spring_authz/README.md","https://github.com/massenz/jwt-opa#web-server-demo-app","https://www.baeldung.com/spring-security-authorization-opa"],"inventors":["styra","build-security","bisnode","alertavert","big-acl"],"docs_features":{"rest-api-integration":{"note":"OPA Spring Security uses the REST API to query OPA about authz decisions.\\nSee an example application in OPA\'s\\n[contrib repo](https://github.com/open-policy-agent/contrib/tree/main/spring_authz).\\n"}},"content":"\\nSpring Security provides a framework for securing Java applications. These integrations provide simple implementations for Spring Security that use OPA for making API authorization decisions. They provide support for both traditional Spring Security (MVC), as well as an implementation for Spring Reactive (Web Flux).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/springsecurity-api.md","id":"springsecurity-api"},"spire":{"title":"SPIRE","labels":{"layer":"network","category":"application"},"software":["spiffe","spire"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/zero-trust-with-envoy-spire-and-open-policy-agent-opa/"],"code":["https://github.com/spiffe/spire/blob/v1.0.2/doc/authorization_policy_engine.md"],"tutorials":["https://spiffe.io/docs/latest/microservices/envoy-opa/readme/","https://spiffe.io/docs/latest/microservices/envoy-jwt-opa/readme/"],"docs_features":{"envoy":{"note":"SPIRE can be used to integrate with Envoy and OPA. See a\\n[blog here](https://web.archive.org/web/https://www.styra.com/blog/zero-trust-with-envoy-spire-and-open-policy-agent-opa/)\\nto learn more.\\n"},"rest-api-integration":{"note":"SPIRE can work in tandem with the Envoy proxy to integrate with the OPA\\nREST API. See the\\n[tutorial here](https://spiffe.io/docs/latest/microservices/envoy-jwt-opa/readme/).\\n"}},"content":"\\nSPIRE is a production-ready implementation of the SPIFFE APIs that performs node and workload attestation in order to securely issue SPIFFE Verifiable Identity Documents (SVIDs) to workloads, and verify the SVIDs of other workloads, based on a predefined set of conditions.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/spire.md","id":"spire"},"spinnaker-pipeline":{"title":"Armory Policy Engine for Spinnaker","labels":{"layer":"cicd"},"software":["spinnaker"],"blogs":null,"tutorials":["https://docs.armory.io/plugins/policy-engine/"],"inventors":["armory"],"content":"\\nSpinnaker is a Continuous Delivery and Deployment tool started by Netflix.\\nThe [Armory Policy Engine](https://spinnaker.armory.io/products/policy-engine/)\\nlets you configure policies that dictate what kinds of Spinnaker pipelines\\ndevelopers can create.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/spinnaker-pipeline.md","id":"spinnaker-pipeline"},"sphinx-rego":{"title":"Automatically document Rego policies","software":["sphinx-doc"],"code":["https://github.com/zenitysec/sphinx-rego"],"inventors":["zenity"],"labels":{"category":"tooling","layer":"cicd"},"content":"\\nSphinx extension that automatically documents Open Policy Agent Rego policies using meta properties.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/sphinx-rego.md","id":"sphinx-rego"},"spacelift":{"title":"Spacelift","labels":{"category":"Infrastructure as Code","layer":"cicd"},"software":["terraform","pulumi","cloudformation","kubernetes","ansible","aws","gcp","azure"],"tutorials":["https://docs.spacelift.io/concepts/policy"],"code":["https://github.com/spacelift-io/sp
1acelift-policies-example-library"],"inventors":["spacelift"],"blogs":["https://spacelift.io/blog/what-is-open-policy-agent-and-how-it-works"],"docs_features":{"rego-language-embedding":{"note":"Spacelift supports Rego as a language to describe policies for IaC\\nresources. View the docs on\\n[creating Rego policies](https://docs.spacelift.io/concepts/policy).\\n"},"terraform":{"note":"Spacelift supports Rego as a language to describe policies for Terraform\\nJSON plans.\\n[This blog](https://spacelift.io/blog/what-is-open-policy-agent-and-how-it-works)\\noutlines how the integration works.\\n"},"kubernetes":{"note":"Spacelift supports Rego as a language to describe policies for various\\nresource types, including Kubernetes. View the\\n[policy documentation](https://docs.spacelift.io/concepts/policy) for\\nmore information.\\n"}},"content":"\\nSpacelift is a sophisticated CI/CD platform for Infrastructure as Code including Terraform, Pulumi, CloudFormation, Kubernetes, and Ansible. Spacelift utilizes Open Policy Agent to support a variety of policy types within the platform and Policy as Code for secure and compliance Infrastructure as Code.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/spacelift.md","id":"spacelift"},"scanara":{"title":"Scanara EU AI Act Compliance Scanning","labels":{"category":"compliance"},"tutorials":["https://scanara.io/en/methodology/"],"inventors":["scanara"],"content":"\\nScanara is an automated EU AI Act conformity platform for AI system providers and deployers. This integration uses OPA/Rego to evaluate uploaded technical documentation for EU AI Act compliance, turning document-level regulatory obligations into executable policy checks alongside Scanara\'s source-code scanning.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/scanara.md","id":"scanara"},"scalr-iacp":{"title":"Scalr","subtitle":"Policy enforcement for Terraform","labels":{"category":"Infrastructure as Code","layer":"cicd"},"software":["terraform"],"tutorials":["https://docs.scalr.io/docs/policy-as-code"],"code":["https://github.com/Scalr/sample-tf-opa-policies"],"inventors":["scalr"],"blogs":["https://scalr.com/blog/opa-is-to-policy-automation-as-terraform-is-to-iac"],"docs_features":{"cli-integration":{"note":"These policies can be run using OPA at the command line against a\\nTerraform plan JSON. See\\n[the example](https://github.com/Scalr/sample-tf-opa-policies#policy-evaluation)\\nin the README.\\n"},"terraform":{"note":"These policies can be run using OPA at the command line against a\\nTerraform plan JSON. See\\n[the example](https://github.com/Scalr/sample-tf-opa-policies#policy-evaluation)\\nin the README.\\n"}},"content":"\\nScalr allows teams to easily collaborate on Terraform through its pipeline that runs all Terraform operations, policy checks, and stores state. Scalr uses OPA to check the auto-generated Terraform JSON plan to ensure that it meets your organization standards prior to an apply.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/scalr-iacp.md","id":"scalr-iacp"},"sansshell":{"title":"Sansshell","software":["sansshell"],"labels":{"category":"management","layer":"server","type":"poweredbyopa"},"code":["https://github.com/Snowflake-Labs/sansshell"],"inventors":["snowflake"],"allow_missing_image":true,"content":"\\nA non-interactive daemon for host management\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/sansshell.md","id":"sansshell"},"rond":{"title":"R\xf6nd","software":["rond"],"labels":{"category":"authorization","layer":"application"},"code":["https://github.com/rond-authz/rond"],"tutorials":["https://github.com/rond-authz/example"],"videos":[{"title":"R\xf6nd - The Open Source K8s sidecar that defines security policies over your APIs","speakers":[{"name":"Federico Maggi","organization":"mia-platform"}],"link":"https://youtu.be/ubT31NtHV8w"}],"inventors":["mia-platform"],"blogs":["https://mia-platform.eu/blog/rond-open-source-api-enforcement/","https://mia-platform.eu/blog/role-based-access-control-rbac/","https://mia-platform.eu/library/rbac-implementation-platform-engineering/"],"docs_features":{"go-integration":{"note":"The R\xf6nd sidecar uses the OPA Rego API to make API-access\\nauthorization decisions. See the\\n[OPA evaluator](https://github.com/rond-authz/rond/blob/4c27fa6a127f68b8670a39c792b0e40dac52dafa/core/opaevaluator.go#L173)\\ncode.\\n"}},"content":"\\nR\xf6nd is a lightweight container that distributes security policy enforcement throughout your application.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/rond.md","id":"rond"},"reposaur":{"title":"Reposaur","software":["github"],"labels":{"category":"security","type":"poweredbyopa"},"tutorials":["https://docs.reposaur.com/guides/writing-your-first-policy"],"code":["https://github.com/reposaur/reposaur"],"inventors":["reposaur"],"content":"\\nAudit, verify and report on development platforms (GitHub and others) easily with pre-defined and/or custom policies.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/reposaur.md","id":"reposaur"},"rekor":{"title":"Rekor transparency log monitoring and alerting","labels":{"category":"security","layer":"application"},"software":["rekor"],"inventors":["sigstore"],"code":["https://github.com/nsmith5/rekor-sidekick"],"videos":["https://www.youtube.com/watch?v=lHSLPIo1pz8"],"content":"\\nRekor Sidekick monitors a Rekor signature transparency log and forwards events of interest where ever you like.\\nAlert policies written in Rego determine if an event is of interest.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/rekor.md","id":"rekor"},"regoround":{"title":"Regoround","subtitle":"Self hosted OPA playground with bundles","labels":{"category":"application"},"software":["regoround"],"inventors":["John Hooks"],"code":["https://gitlab.com/sencillodev/regoround"],"content":"\\nThis is a rego playground that you can run locally and requires no other dependencies. It also allows you to load a custom bundle into the playground. URLs are safe to share, the URL parameters are built from the code itself and so cannot be guessed. A [live version](https://regoround.fly.dev) is running with the example bundle from the repo.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/regoround.md","id":"regoround"},"regocpp":{"title":"regocpp","software":["regopy","regorust"],"inventors":["microsoft"],"tutorials":["https://microsoft.github.io/rego-cpp/"],"code":["https://github.com/microsoft/rego-cpp"],"content":"\\nThe rego-cpp project is a Rego compiler and runtime implemented in cross-platform C++. As such, it provides the ability to integrate Rego natively into a wider range of languages on most platforms. In addition to CMake FetchContent support for C and C++, the project also distributes a Rust crate and a Python wheel. The integration is regularly updated to support Rego as of the latest OPA release.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/regocpp.md","id":"regocpp"},"rego-test-assertions":{"title":"rego-test-assertions","subtitle":"Helper functions for unit testing Rego","labels":{"category":"library"},"inventors":["anderseknert"],"code":["https://github.com/anderseknert/rego-test-assertions"],"tutorials":["https://github.com/anderseknert/rego-test-assertions/blob/main/README.md"],"docs_features":{"policy-testing":{"note":"The [rego-test-assertions](https://github.com/anderseknert/rego-test-assertions)\\nlibrary contains various assertion functions, which will print the\\nexpected result vs. the outcome to the console on failure.\\n"},"debugging-rego":{"note":"The [rego-test-assertions](https://github.com/anderseknert/rego-test-assertions)\\nlibrary is designed to make debugging Rego tests easier.\\n"}},"content":"\\nA Rego library providing helper functions for unit testing. The library\\nprimarily contains various assertion functions, which will print the expected\\nresult vs. the outcome to the console on failure. This allows you to quickly\\ngrasp what went wrong in your unit tests, resulting in a faster test iteration\\nprocess!\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/rego-test-assertions.md","id":"rego-test-assertions"},"rego-cheat-sheet":{"title":"Rego Cheat Sheet","subtitle":"Quick reference for learning Rego","labels":{"category":"learning"},"code":["https://github.com/open-policy-agent/rego-cheat-sheet"],"tutorials":["https://www.openpolicyagent.org/docs/cheatsheet"],"docs_features":{"learning-rego":{"note":"The [Rego Cheat Sheet](https://www.openpolicyagent.org/docs/cheatsheet)\\nwas designed as a language reference, featuring common contact points,\\nwith Rego learners in mind.\\n"}},"content":"\\nThe [Rego Cheat Sheet](https://www.openpolicyagent.org/docs/cheatsheet) has been\\ndesigned to be a reference for Rego learners and users documenting the common\\ncontact points with the language. There is also a\\n[PDF version](https://www.openpolicyagent.org/cheatsheet.pdf) for those looking for\\na printable reference.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/rego-cheat-sheet.md","id":"rego-cheat-sheet"}
1,"regal":{"title":"Regal","subtitle":"The Linter of Rego Language","labels":{"category":"tooling","layer":"shell"},"inventors":["styra"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/guarding-the-guardrails-introducing-regal-the-rego-linter/","https://thenewstack.io/scaling-open-source-community-by-getting-closer-to-users/"],"code":["https://github.com/open-policy-agent/regal"],"videos":["https://www.youtube.com/live/Xx8npd2TQJ0?feature=share&t=2567","https://youtu.be/XtA-NKoJDaI?feature=shared&t=934"],"tutorials":["https://www.openpolicyagent.org/projects/regal#try-it-out"],"docs_features":{"learning-rego":{"note":"Regal can automatically check for common Rego mistakes as you code.\\nEach violation is accompanied by a detailed explanation which can be a\\ngreat learning tool for new Rego users. See the\\n[Supported Rules](https://www.openpolicyagent.org/projects/regal/rules).\\n"},"go-integration":{"note":"Regal is built using the Go Rego API. Regal evaluates linting rules\\ndefined in Rego against the Rego AST of policy files. The\\n[linter package](https://github.com/open-policy-agent/regal/blob/main/pkg/linter/linter.go)\\nis a good place to see how OPA is used in the project.\\n"},"policy-testing":{"note":"Regal is a useful step to use when testing Rego policies to ensure\\ncode is correct and free of common errors. See\\n[the README](https://www.openpolicyagent.org/projects/regal#try-it-out)\\nto get started.\\n"},"debugging-rego":{"note":"Regal can be used to debug Rego policies by identifying common mistakes.\\nSee [Bugs](https://www.openpolicyagent.org/projects/regal/rules/bugs) for\\nsome example issues it can identify automatically.\\n\\nRegal also implements a\\n[language server](https://www.openpolicyagent.org/projects/regal/language-server) and\\n[debug adapter](https://www.openpolicyagent.org/projects/regal/debug-adapter) for Rego to\\nallow clients to debug Rego code as users type.\\n"}},"content":"\\nRegal is the official linter for Rego, with the goal of making your Rego\\nmagnificent!\\n\\nRegal can:\\n\\n- Identify common mistakes, bugs and inefficiencies in Rego policies, and\\n suggest better approaches\\n- Provide advice on best practices, coding style, and tooling\\n- Allow users, teams and organizations to enforce custom rules on their policy\\n code\\n\\nRegal also implements a\\n[language server](https://www.openpolicyagent.org/projects/regal/language-server) and\\n[debug adapter](https://www.openpolicyagent.org/projects/regal/debug-adapter) for Rego to\\nallow clients to debug Rego code as users type.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/regal.md","id":"regal"},"raygun":{"title":"raygun","subtitle":"Black-box Automated Testing for Rego","labels":{"category":"tooling","layer":"shell"},"inventors":["paclabsnet"],"code":["https://github.com/paclabsnet/raygun"],"tutorials":["https://github.com/paclabsnet/raygun/blob/main/README.md"],"blogs":["https://paclabs.substack.com/p/raygun-automated-testing-for-rego"],"docs_features":{"policy-testing":{"note":"[Raygun](https://github.com/paclabsnet/raygun)\\nmakes it easier to test Rego code in a \\"real-world\\" facsimile.\\n"}},"content":"\\nA command-line tool for \\"black-box\\" automated testing of Rego. Raygun uses\\nOPA as a client, instead of as the test driver. You create YAML\\ntest suites that specify the location of the bundle, the policy path,\\nthe input JSON and the expected response, and Raygun starts up an OPA\\nprocess with that bundle, POSTs the input JSON to OPA, checks substrings\\nof the response against your expectations and reports on the results.\\nEasy to integrate into existing build chains. Keeps the tests separate from\\nthe policy source code.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/raygun.md","id":"raygun"},"pulumi":{"title":"Pulumi","software":["pulumi","aws","gcp","azure"],"labels":{"category":"publiccloud","layer":"orchestration"},"code":["https://github.com/pulumi/pulumi-policy-opa"],"blogs":["https://www.pulumi.com/blog/opa-support-for-crossguard/"],"videos":[{"title":"Testing Configuration with Open Policy Agent","speakers":[{"name":"Gareth Rushgrove","organization":"snyk"}],"venue":"Cloud Engineering Summit 2020","link":"https://www.pulumi.com/resources/testing-configuration-with-open-policy-agent/"}],"inventors":["pulumi"],"docs_features":{"go-integration":{"note":"The Pulumi OPA bridge uses the Rego API to evaluate policies in a\\npolicy pack. View the [docs and code](https://github.com/pulumi/pulumi-policy-opa).\\n"}}
1,"content":"\\nBuild infrastructure as code in familiar languages. CrossGuard is Pulumi\'s policy as code offering, providing OPA as one of the options to use for defining policy.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/pulumi.md","id":"pulumi"},"principled-evolution":{"title":"Principled Evolution (GOPAL & AICertify)","software":["gopal","aicertify"],"inventors":["principled-evolution-ltd"],"code":["https://github.com/principled-evolution/gopal","https://github.com/principled-evolution/aicertify"],"content":"\\nGOPAL is a library of Rego policies that encode AI-governance regulations as executable allow/deny checks. It covers the EU AI Act, the UK pro-innovation principles together with the automated decision-making regime in UK GDPR Articles 22A to 22D, the NIST AI Risk Management Framework, ICAO, FAA and EASA aviation standards, PRA SS1/23 and the FCA Consumer Duty in financial services, FERPA and COPPA in education, and professional-conduct rules for AI use in legal practice.\\n\\nThe project publishes per-article coverage matrices stating which obligations are implemented and which are not, and every obligation in those matrices is currently implemented. Each framework is versioned under `v1/` with semver guarantees, so an amended regulation ships as `v2/` alongside the old reading rather than breaking a pinned deployment. Every policy carries allow/deny tests, and `opa check`, Regal and `opa test` run in CI.\\n\\nThe policies are plain Rego with no wrapper on top, so they load into any OPA deployment: `opa eval` in a CI job, Conftest, or a running OPA server queried on the request path. Organizations can keep proprietary rules in a git-ignored `custom/` tree that evaluates alongside the public set, which lets internal AI use-case policy sit next to the regulatory baseline without forking.\\n\\nAICertify is the companion Python framework. It captures the input context for an AI application, evaluates it against GOPAL policies through OPA, and produces audit-ready PDF, Markdown, and JSON reports. In both paths OPA is the decision engine, which brings the policy-as-code workflow the OPA community already uses for Kubernetes admission and cloud authorization to AI compliance.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/principled-evolution.md","id":"principled-evolution"},"pre-commit-hooks":{"title":"Pre-commit hooks","labels":{"category":"tooling","layer":"cicd"},"software":["git","pre-commit"],"code":["https://github.com/anderseknert/pre-commit-opa"],"blogs":["https://www.eknert.com/tech/2020/08/31/pre-commit-hooks-for-opa"],"inventors":["independent"],"content":"\\nPre-commit git hooks for OPA and Rego development\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/pre-commit-hooks.md","id":"pre-commit-hooks"},"pomerium-authz":{"title":"Pomerium Access Proxy","labels":{"layer":"network","category":"proxy"},"software":["pomerium"],"blogs":["https://github.com/pomerium/pomerium/releases/tag/v0.7.0"],"tutorials":["https://www.pomerium.com/docs/capabilities/authorization#rego-policies"],"code":["https://github.com/pomerium/pomerium"],"content":"\\nPomerium is an identity-aware proxy that enables secure access to internal applications. OPA implements authorization under the hood.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/pomerium-authz.md","id":"pomerium-authz"},"php-authorization":{"title":"PHP OPA Library","for_language":"php","labels":{"layer":"network","category":"application"},"software":["php"],"tutorials":["https://coil.com/p/segra/OPA-for-API-Authorization-with-Slim-PHP/H-7YsQL2m"],"code":["https://github.com/segrax/opa-php-examples","https://github.com/segrax/openpolicyagent","https://github.com/mdragun/opa-symfony-middleware-fork/"],"inventors":["build-security"],"docs_features":{"rest-api-integration":{"note":"This library provides a PHP wrapper around the OPA REST API. It can\\nupdate policies and query for decisions. See the\\n[project README](https://github.com/segrax/openpolicyagent)\\nfor various examples.\\n"}},"content":"\\nThese integrations demonstrate using OPA to perform API authorization in PSR-15 and Symfony compliant frameworks.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/php-authorization.md","id":"php-authorization"},"permit":{"title":"Permit.io","labels":{"category":"authorization","layer":"application"},"inventors":["permitio"],"code":["https://github.com/permitio"],"tutorials":["https://docs.permit.io/"],"blogs":["https://www.permit.io/blog/introduction-to-opa","https://www.permit.io/blog/implement-abac-using-opa","https://www.permit.io/blog/implement-rbac-using-opa"],"content":"\\nPermit.io empowers developers to bake in permissions and access-control into any product in minutes and takes away the pain of constantly rebuilding them.\\nPermit is based on OPA.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/permit.md","id":"permit"},"ossrisk":{"title":"ossrisk","subtitle":"Dependency supply-chain risk scanner with Rego policy gates","labels":{"category":"security","layer":"cicd","type":"poweredbyopa"},"inventors":["depkeep"],"code":["https://github.com/depkeep/ossrisk"],"tutorials":["https://github.com/depkeep/ossrisk#policy-as-code-opa"],"software":["npm","pypi","github-actions"],"content":"\\nossrisk scans npm and PyPI dependency trees for supply-chain and long-term\\nviability risk: known CVEs (via OSV.dev), end-of-life versions, abandonment\\nsignals, typosquatting, license compliance, maintainer-takeover patterns, and\\ninstall scripts.\\n\\nBeyond a simple `--fail-on <severity>` threshold, ossrisk delegates gating\\ndecisions to OPA. The scan result is passed to `opa eval` as `input`;
1 policies\\nlive in `package ossrisk` and add human-readable messages to a `deny` set, and\\nany violation fails the scan. This enables cross-signal rules a severity\\nthreshold cannot express - for example \\"no strong-copyleft licenses in direct\\ndependencies\\" or \\"block packages that add install scripts under a brand-new\\npublisher\\" (the event-stream takeover pattern).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/ossrisk.md","id":"ossrisk"},"optoggles":{"title":"OPToggles (Open Policy Toggles)","labels":{"category":"updates","layer":"application"},"inventors":["permitio"],"code":["https://github.com/permitio/OPToggles"],"tutorials":["https://optoggles.opal.ac/tutorials/demo/"],"content":"\\nOPToggles uses OPA and OPAL to sync open-policy to your frontend with the help of feature flag solutions.\\nOPToggles creates user-targeted feature flags based on the policy rules you defined in OPA and keeps the users updated in real-time with OPAL\'s real-time policy and policy-data change detection.\\nOPToggles already supports launchdarkly.com and a generic REST API.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/optoggles.md","id":"optoggles"},"openfaas-function-authorization":{"title":"OpenFaaS Serverless Function Authorization","labels":{"layer":"application","category":"serverless"},"software":["openfaas"],"code":["https://github.com/adaptant-labs/openfaas-function-auth-opa"],"tutorials":["https://github.com/adaptant-labs/openfaas-function-auth-opa/blob/master/README.md"],"inventors":["adaptant"],"content":"\\nOpenFaaS is a serverless function framework that runs on Docker Swarm and Kubernetes. OPA makes it possible to provide fine-grained context-aware authorization on a per-function basis.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/openfaas-function-authorization.md","id":"openfaas-function-authorization"},"open-service-mesh":{"title":"Open Service Mesh (OSM)","software":["osm"],"labels":{"category":"servicemesh","layer":"network"},"tutorials":["https://release-v1-2.docs.openservicemesh.io/docs/guides/integrations/external_auth_opa/"],"docs_features":{"envoy":{"note":"External Authorization supports OPA and is documented\\n[here](https://release-v1-2.docs.openservicemesh.io/docs/guides/integrations/external_auth_opa/)\\n"}},"content":"\\nOpen Service Mesh is a lightweight and extensible cloud native service mesh.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/open-service-mesh.md","id":"open-service-mesh"},"opal":{"title":"OPAL","subtitle":"Open Policy Administration Layer","labels":{"category":"updates","layer":"application"},"inventors":["permitio"],"software":["opal"],"code":["https://github.com/permitio/opal"],"tutorials":["https://github.com/permitio/opal/tree/master/documentation/docs/tutorials"],"videos":["https://www.youtube.com/watch?v=K1Zm2FPfrh8"],"docs_features":{"rest-api-integration":{"note":"OPAL uses the OPA REST API to update the policy and data pushed down\\nfrom the OPAL server.\\nSee [how this works](https://docs.opal.ac/overview/architecture/).\\n"},"external-data":{"note":"The OPAL Client uses the OPA REST API to update the state pushed down\\nfrom the OPAL server.\\nSee [how this works](https://docs.opal.ac/overview/architecture/).\\n"},"external-data-realtime-push":{"note":"OPAL is able to deliver real-time data updates to OPA instances.\\nSee\\n[how this works](https://docs.opal.ac/getting-started/quickstart/opal-playground/publishing-data-update/)\\nin the OPAL docs.\\n"}},"content":"\\nOPAL is an administration layer for Open Policy Agent (OPA), detecting changes in realtime to both policy and policy data and pushing live updates to your agents.\\nOPAL brings open-policy up to the speed needed by live applications. As your application state changes (whether it\'s via your APIs, DBs, git, S3 or 3rd-party SaaS services), OPAL will make sure your services are always in sync with the authorization data and policy they need (and only those they need).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opal.md","id":"opal"},"opa-wasm-zig":{"title":"OPA Wasm Zig Library","for_language":"zig","software":["zig"],"inventors":["burdzwastaken"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://github.com/burdzwastaken/zig-opa-wasm/blob/master/README.md"],"code":["https://github.com/burdzwastaken/zig-opa-wasm/"],"docs_features":{"wasm-integration":{"note":"This project implements the OPA Wasm module interface in Zig.\\n"}},"content":"\\nA Zig library to use OPA policies compiled to Wasm.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-wasm-zig.md","id":"opa-wasm-zig"},"opa-wasm-rust":{"title":"OPA Wasm Rust Crate","for_language":"rust","software":["rust"],"inventors":["matrix"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://github.com/matrix-org/rust-opa-wasm#try-it-out","https://docs.rs/opa/latest/opa/wasm/index.html"],"code":["https://github.com/matrix-org/rust-opa-wasm"],"docs_features":{"wasm-integration":{"note":"This project implements the OPA Wasm module interface in Rust.\\n"}},"content":"\\nA crate to use OPA policies compiled to Wasm.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-wasm-rust.md","id":"opa-wasm-rust"},"opa-wasm-js":{"title":"OPA Wasm Javascript Module","for_language":"javascript","software":["javascript"],"inventors":["styra"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://github.com/open-policy-agent/npm-opa-wasm/blob/main/README.md"],"code":["https://github.com/open-policy-agent/npm-opa-wasm/","https://www.npmjs.com/package/@open-policy-agent/opa-wasm?activeTab=readme"],"videos":[{"title":"Scratching an Itch: Running Policy in Hard to Reach Places with Wasm & OPA","speakers":[{"name":"Charlie Egan","organization":"styra"}],"link":"https://www.youtube.com/watch?v=BdeBhukLwt4"}],"docs_features":{"wasm-integration":{"note":"This project implements the OPA Wasm module interface in JavaScript.\\n"}},"content":"\\nA small SDK for using WebAssembly (Wasm) compiled Rego policies\\
1n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-wasm-js.md","id":"opa-wasm-js"},"opa-wasm-java":{"title":"Wasm Java Gradle SDK (sangkeon)","for_language":"java","software":["java"],"inventors":["sangkeon"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://github.com/sangkeon/java-opa-wasm#usage"],"code":["https://github.com/sangkeon/java-opa-wasm"],"docs_features":{"wasm-integration":{"note":"This project implements the OPA Wasm module interface in Java.\\n"}},"content":"\\nSDK to illustrate how to use Wasm compiled Rego policies from a Java application\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-wasm-java.md","id":"opa-wasm-java"},"opa-wasm-dotnet":{"title":"Wasm .NET Package (christophwille)","for_language":"csharp","software":["csharp"],"inventors":["christophwille"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://github.com/christophwille/dotnet-opa-wasm"],"code":["https://github.com/christophwille/dotnet-opa-wasm","https://www.nuget.org/packages/Opa.Wasm/"],"docs_features":{"wasm-integration":{"note":"This project implements the OPA Wasm module interface in C#.\\n"}},"content":"\\nCall Rego policies in Wasm from C# .NET Core\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-wasm-dotnet.md","id":"opa-wasm-dotnet"},"opa-typescript":{"title":"Typescript OPA SDK (Styra)","for_language":"javascript","software":["javascript","typescript"],"inventors":["styra"],"labels":{"layer":"network","category":"application"},"tutorials":["https://open-policy-agent.github.io/opa-typescript/"],"code":["https://github.com/open-policy-agent/opa-typescript","https://www.npmjs.com/package/@open-policy-agent/opa"],"content":"\\nThe driver to connect to Open Policy Agent (OPA) deployments\\nfrom Typescript applications.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-typescript.md","id":"opa-typescript"},"opa-springboot":{"title":"OPA Spring Boot SDK (Styra)","for_language":"java","labels":{"layer":"network","category":"application"},"software":["java"],"code":["https://github.com/open-policy-agent/opa-springboot","https://central.sonatype.com/artifact/com.styra.opa/springboot"],"inventors":["styra"],"content":"\\nThe OPA Spring Boot SDK enables seamless integration of Open\\nPolicy Agent deployments with Spring Boot applications\\nthrough an `AuthorizationManager` implementation. The SDK\u2019s installation and\\nusage details are provided on\\n[Maven Central](https://central.sonatype.com/artifact/com.styra.opa/springboot).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-springboot.md","id":"opa-springboot"},"opa-python":{"title":"Python Client (Turall)","labels":{"layer":"network","category":"application"},"software":["python"],"code":["https://github.com/Turall/OPA-python-client"],"inventors":["turall"],"content":"\\nPython client for integrating with the OPA REST API.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-python.md","id":"opa-python"},"opa-playground":{"title":"OPA Playground","subtitle":"Online Rego Playground","software":[],"inventors":["styra"],"labels":{"category":"tooling","layer":"rego"},"code":["https://play.openpolicyagent.org/"],"blogs":["https://openpolicyagent.org/blog/the-rego-playground-977566855cec","https://openpolicyagent.org/blog/rego-playground-new-features-ec0345a73b9e"],"docs_features":{"learning-rego":{"note":"Sometimes if you\'re working on a Rego policy in an integrated system\\nit can help to debug it in isolation first. The playground is a great\\nplace to do that. Get started with a [hello world example](https://play.openpolicyagent.org/).\\n"},"language-tooling":{"note":"The playground is a great place to get started with writing and testing\\nyour first policies. You can also share links if you\'re asking for\\nhelp in the community Slack. Get started with a simple\\n[RBAC example](https://play.openpolicyagent.org/?example-group=access-control).\\n"},"debugging-rego":{"note":"The playground is a great place to debug Rego policies as you can\\nquickly iterate on the policy and data at the same time before sharing\\nlinks to collaborate on a fix with others.\\n"}},"content":"\\nInteractive online Rego playground for writing and sharing policies\\
1n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-playground.md","id":"opa-playground"},"opa-nats":{"title":"NATS Plugin for OPA","subtitle":"An LRU cache backed by NATS Key-Value store for OPA","labels":{"layer":"data","category":"data"},"inventors":["permitio"],"software":["nats"],"code":["https://github.com/permitio/opa-nats"],"docs_features":{"go-integration":{"note":"opa-nats is written in Go and ships a custom OPA binary with the\\nplugin pre-registered, as well as a library for embedding the plugin\\nin other Go-based OPA builds.\\n"},"external-data":{"note":"opa-nats overrides the OPA runtime store for specific paths, backing\\nthem with an LRU cache populated from a NATS Key-Value store.\\n"}},"content":"\\nopa-nats is a Go plugin that backs OPA\'s runtime store with a [NATS Key-Value store](https://docs.nats.io/nats-concepts/jetstream/key-value-store), letting policies read externally managed data through an LRU cache kept in sync with NATS.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-nats.md","id":"opa-nats"},"opa-mcp":{"title":"OPA MCP","subtitle":"Model Context Protocol server for authoring and debugging Rego","labels":{"category":"tooling","layer":"editor"},"inventors":["independent"],"code":["https://github.com/OrygnsCode/opa-mcp-server","https://www.npmjs.com/package/@orygn/opa-mcp","https://hub.docker.com/r/orygn/opa-mcp","https://smithery.ai/server/@orygn/opa-mcp"],"videos":["https://youtu.be/ByHocQDkB8M"],"blogs":["https://www.linkedin.com/pulse/llms-bad-writing-rego-policies-heres-why-what-i-built-daniel-okwor-fjnzc/"],"docs_features":{"learning-rego":{"note":"OPA MCP exposes higher-level helpers (rego_describe_policy,\\nrego_suggest_fix, rego_explain_decision) that compose opa fmt,\\nopa parse, and opa eval into AI-friendly tools. Agents in any MCP\\nclient (Claude Desktop, Cursor, VS Code, Zed) can author, format,\\nand review Rego with structured output instead of free-form CLI text.\\n"},"policy-testing":{"note":"The rego_test tool runs opa test over a directory and returns\\npass/fail per test with optional coverage. rego_generate_test_skeleton\\nproduces a _test.rego scaffold covering each rule in a policy.\\n"},"debugging-rego":{"note":"rego_explain_decision wraps opa eval --explain=full and returns a\\nstructured trace, letting agents answer \\"why was this rejected\\"\\nwithout reading raw traces. rego_eval_with_profile and\\nrego_eval_with_coverage surface hot rules and per-line coverage.\\n"},"editors":{"note":"OPA MCP is a stdio MCP server that plugs into any MCP-compatible\\nclient. One-line Smithery install for Claude Desktop, drop-in\\nconfigs for Cursor, VS Code, Zed, and Windsurf. Multi-arch Docker\\nimage and a signed .mcpb bundle are also published.\\n"}},"content":"\\nOPA MCP is a Model Context Protocol server that gives MCP-compatible\\nclients a structured interface to Rego. It wraps the OPA CLI (opa fmt,\\nopa check, opa eval, opa test, opa build, opa sign), the OPA REST API,\\nthe Regal linter, and Conftest, exposing 50+ tools with stable error codes\\nand schema-validated input/output.\\n\\nHigher-level helpers (rego_explain_decision, rego_describe_policy,\\nrego_generate_test_skeleton, rego_suggest_fix) compose the primitives\\ninto the tasks agents typically perform. A curated resource set exposes\\nthe OPA built-in function catalog, the Rego style guide, and a pattern\\nlibrary covering RBAC, ABAC, Kubernetes admission, IaC gates, API\\nauthorization, and rate limiting.\\n\\nDistributed via npm (@orygn/opa-mcp), Docker Hub (orygn/opa-mcp), and a\\nsigned .mcpb bundle.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-mcp.md","id":"opa-mcp"},"opa-java":{"title":"Java OPA SDK (Styra)","for_language":"java","labels":{"layer":"network","category":"application"},"software":["java"],"code":["https://github.com/open-policy-agent/opa-java","https://central.sonatype.com/artifact/com.styra/opa"],"tutorials":["https://open-policy-agent.github.io/opa-java/javadoc/"],"inventors":["styra"],"content":"\\nThe Styra-supported driver to connect to Open Policy Agent (OPA) and Enterprise\\nOPA deployments from Java applications.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-java.md","id":"opa-java"},"opa-java-wasm":{"title":"Java OPA Wasm SDK (Styra)","for_language":"java","software":["java"],"labels":{"category":"wasm","type":"poweredbyopa"},"code":["https://github.com/StyraOSS/opa-java-wasm","https://central.sonatype.com/artifact/com.styra.opa/opa-java-wasm"],"tutorials":["https://github.com/StyraOSS/opa-java-wasm?tab=readme-ov-file#getting-started"],"inventors":["andreatp"],"content":"\\nA Java SDK for using WebAssembly(wasm) compiled Open Policy Agent (OPA) policies powered by Chicory,\\na zero dependencies Java Wasm interpreter.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-java-wasm.md","id":"opa-java-wasm"},"opa-java-client":{"title":"Java Client (Bisnode)","for_language":"java","labels":{"layer":"network","category":"application"},"software":["java"],"code":["https://github.com/Bisnode/opa-java-client"],"inventors":["bisnode"],"content":"\\nIntegrations for interacting with OPA from Java\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-java-client.md","id":"opa-java-client"},"opa-golang":{"title":"OPA Go SDK","for_language":"golang","software":["golang"],"inventors":["styra"],"labels":{"category":"application","layer":"network"},"tutorials":["https://www.openpolicyagent.org/docs/latest/integration/#integrating-with-the-go-sdk"],"code":["https://pkg.go.dev/github.com/open-policy-agent/opa/sdk","https://github.com/open-policy-agent/opa/tree/main/sdk"],"content":"\\nOPA\'s native Go SDK allows application developers to run OPA functionality from within their application.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-golang.md","id":"opa-golang"},"opa-dotnet":{"title":"Wasm .NET Package (me-viper)","for_language":"csharp","software":["csharp"],"inventors":["andriikurochka"],"labels":{"category":"wasm","type":"poweredbyopa"},"tutorials":["https://me-viper.github.io/OpaDotNet/articles/HowToStart.html"],"code":["https://github.com/me-viper/OpaDotNet","https://www.nuget.org/packages/OpaDotNet.Wasm/"],"docs_features":{"wasm-integration":{"note":"This project implements Open Policy Agent (OPA) WebAssembly .NET core SDK."}},"content":"\\nOpen Policy Agent (OPA) WebAssembly .NET core SDK\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-dotnet.md","id":"opa-dotnet"},"opa-dotnet-asp-core":{"title":".NET Package (me-viper)","for_language":"csharp","labels":{"category":"application","layer":"network","type":"poweredbyopa"},"code":["https://github.com/me-viper/OpaDotNet.Extensions","https://www.nuget.org/packages/OpaDotNet.Extensions.AspNetCore/"],"inventors":["me-viper"],"software":["csharp"],"content":"\\nOpen Policy Agent (OPA) ASP.NET core authorization infrastru
1cture\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-dotnet-asp-core.md","id":"opa-dotnet-asp-core"},"opa-csharp":{"title":"C# OPA SDK (Styra)","for_language":"csharp","labels":{"category":"application","layer":"network"},"code":["https://github.com/open-policy-agent/opa-csharp","https://www.nuget.org/packages/Styra.Opa"],"tutorials":["https://open-policy-agent.github.io/opa-csharp/"],"inventors":["styra"],"software":["csharp"],"content":"\\nThe driver to connect to Open Policy Agent (OPA) deployments from C#\\napplications.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-csharp.md","id":"opa-csharp"},"opa-aspnetcore":{"title":"OPA ASP.NET Core SDK (Styra)","for_language":"csharp","labels":{"category":"application","layer":"network"},"code":["https://github.com/open-policy-agent/opa-aspnetcore","https://www.nuget.org/packages/Styra.Opa.AspNetCore"],"tutorials":["https://open-policy-agent.github.io/opa-aspnetcore/"],"inventors":["styra"],"software":["csharp"],"content":"\\nThe OPA ASP.NET Core SDK enables seamless integration of Open Policy Agent\\ndeployments with ASP.NET Core applications through an ASP.NET `Middleware`\\nimplementation. The SDK\u2019s installation and usage\\ndetails are provided on [NuGet](https://www.nuget.org/packages/Styra.Opa.AspNetCore).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/opa-aspnetcore.md","id":"opa-aspnetcore"},"oidc":{"title":"OpenID Connect (OIDC)","software":["oauth","oidc"],"labels":{"category":"security"},"tutorials":["https://www.openpolicyagent.org/docs/oauth-oidc"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/integrating-identity-oauth2-and-openid-connect-in-open-policy-agent/"],"content":"\\nIntegrating OpenID Connect (OIDC) with Open Policy Agent\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/oidc.md","id":"oidc"},"ocpr":{"title":"Open Policy Containers","subtitle":"A Docker-inspired workflow for OPA policies","labels":{"category":"containers","layer":"application"},"inventors":["aserto"],"code":["https://github.com/opcr-io/policy"],"tutorials":["https://openpolicycontainers.com/docs/tutorial/"],"docs_features":{"go-integration":{"note":"Makes use of the\\n[OPA Repl package](https://pkg.go.dev/github.com/open-policy-agent/opa/repl)\\nto interact with an OPA instance.\\n"},"opa-bundles":{"note":"OPCR policy images can be loaded in over the Bundle API. The feature\\nit documented in the\\n[OPCR docs](https://openpolicycontainers.com/docs/opa/).\\n"},"opa-bundles-discovery":{"note":"OPCR images can be loaded in over the Bundle API and contain\\ndiscovery bundles. The feature it documented in the\\n[OPCR docs](https://openpolicycontainers.com/docs/opa/).\\n"},"external-data":{"note":"OPCR policy images can contain data as well as policy. If you need to\\ndistribute data to OPA from an OCI registry, OPCR can build and push\\nsuch images. See the docs for\\n[building images here](https://openpolicycontainers.com/docs/cli/build/).\\n"}},"content":"\\nThe Open Policy Registry project provides a docker-style workflow for OPA\\npolicies. The policy CLI can be used to build, tag, sign, push, and pull OPA\\npolicies as OCIv2 container images, in conjunction with any container registry.\\nThe Open Policy Registry (OPCR) is a reference implementation of a policy\\nregistry, built and hosted on GCP.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/ocpr.md","id":"ocpr"},"oauth2":{"title":"OAuth2","software":["oauth"],"labels":{"category":"security"},"tutorials":["https://www.openpolicyagent.org/docs/oauth-oidc"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/integrating-identity-oauth2-and-openid-connect-in-open-policy-agent/"],"content":"\\nIntegrating OAuth2 with Open Policy Agent\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/oauth2.md","id":"oauth2"},"nopa":{"title":"nopa","subtitle":"NATS + OPA","inventors":["John Hooks"],"labels":{"category":"application","layer":"library"},"software":["golang","NATS"],"code":["https://gitlab.com/sencillodev/nopa"],"content":"\\nNopa is a simple way to store OPA bundles in NATS object storage with real time updates with custom module injection.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/nopa.md","id":"nopa"},"nginx":{"title":"Nginx","labels":{"category":"gateway","layer":"network"},"software":["nginx"],"code":["https://github.com/summerwind/opa-nginx-rbac"],"content":"\\nOPA Authorization for Nginx\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/nginx.md","id":"nginx"},"nacp":{"title":"Nomad Admission Control Proxy","subtitle":"NACP","labels":{"type":"poweredbyopa","layer":"configuration"},"inventors":["mxab"],"code":["https://github.com/mxab/nacp"],"videos":["https://github.com/mxab/nacp/tree/main/example"],"tutorials":["https://github.com/mxab/nacp/tree/main/example"],"content":"\\nNACP is a proxy in front of the Nomad API that allows for mutation and\\nvalidation of job data. It intercepts Nomad API calls that include job data\\n(plan, register, validate) and performs the necessary operations, with\\nvalidation available through embedded Rego rules or webhooks.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/nacp.md","id":"nacp"},"moat":{"title":"Moat","subtitle":"A Data Control Plane for Trino & OPA","labels":{"category":"updates","layer":"application"},"inventors":["moat-io"],"software":["trino"],"code":["https://github.com/moat-io/moat"],"tutorials":["https://moat-io.github.io/moat/"],"docs_features":{"opa-bundles":{"note":"Moat supplies bundles to OPA to provide powerful data authorisation for Trino\\nSee [Moat Bundles](https://moat-io.github.io/moat/bundles/).\\n"},"external-data":{"note":"Moat aggregates data from multiple identity and metadata sources to provide powerful data authorisation for Trino\\nSee [Trino & OPA](https://moat-io.github.io/moat/trino_and_opa/).\\n"}},"content":"\\nOPA and Trino are an awesome combination, but maintaining the policy documents and required data object can be painful. Moat makes this easy with managed curation of principals and tables/views, as well as a predefined set of RBAC/ABAC policies suitable for most use cases. These policies can be used as-is, modified or completely replaced as needed.\\n\\n## Moat provides a Data Control Plane to serve bundles to OPA, including\\n\\n- SCIM2.0 server to allow integration with most identity providers (e.g Okta, EntraId)\\n- Data objects and attributes ingested from various sources (SQL DBs, data catalogs etc)\\n- Principals, attributes and groups ingested from identity providers (SQL DB, LDAP, etc)\\n- Pre-built rego policy documents to support common use cases (e.g. RBAC)\\n- OPA-compliant bundle API with built-in caching to allow fast polling\\n\\nMoat itself is not involved in policy decisions at runtime, it simply provides the information to the battle-hardened OPA.\\n\\nMoat can serve bundles to any number of OPA/Trino installations. This makes it very convenient to manage permissions across a fleet of trino clusters as well as ephemeral cluster
1s. Simply add an OPA container to the coordinator deployment and point its bundle service to moat\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/moat.md","id":"moat"},"minio":{"title":"Minio API Authorization","labels":{"layer":"data","category":"authorization"},"tutorials":["https://github.com/minio/minio/blob/master/docs/iam/opa.md"],"inventors":["minio","styra"],"docs_features":{"rest-api-integration":{"note":"Minio implements a native integration with OPA using the REST API.\\nThe [integration is documented](https://github.com/minio/minio/blob/master/docs/iam/opa.md)\\nin the Minio docs.\\n"}},"content":"\\nMinio is an open source, on-premise object database compatible with the Amazon S3 API. This integration lets OPA enforce policies on Minio\'s API.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/minio.md","id":"minio"},"magda":{"title":"Magda","labels":{"type":"poweredbyopa","category":"application","layer":"application"},"software":["magda"],"code":["https://github.com/magda-io/magda"],"blogs":["https://github.com/magda-io/magda/blob/master/docs/docs/architecture/Guide%20to%20Magda%20Internals.md#authorization-authz"],"content":"\\nMagda is a federated, Kubernetes-based, open-source data catalog system.\\nWorking as Magda\'s central authorisation policy engine, OPA helps not only the API endpoint authorisation.\\nMagda also uses its partial evaluation feature to translate datasets authorisation decisions to other database-specific DSLs (e.g. SQL or Elasticsearch DSL) and use them for dataset authorisation enforcement in different databases.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/magda.md","id":"magda"},"lula":{"title":"Lula","subtitle":"The Cloud-Native Compliance Engine","inventors":["defenseunicorns"],"labels":{"category":"compliance"},"code":["https://github.com/defenseunicorns/lula"],"docs_features":{"go-integration":{"note":"Lula is written in Go and uses the\\n[Rego Go API](https://www.openpolicyagent.org/docs/latest/integration/#integrating-with-the-go-api)\\nto evaluate configuration for compliance against security controls.\\n"}},"content":"\\nAutomated Governance with Machine-Readable data and OPA - [Lula](https://defenseunicorns.com/) is a tool designed to bridge the gap between expected configuration required for compliance and actual configuration.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/lula.md","id":"lula"},"linux-pam":{"title":"SSH and Sudo Authorization with Linux","software":["linuxpam"],"labels":{"layer":"server"},"tutorials":["https://www.openpolicyagent.org/docs/ssh-and-sudo-authorization.html"],"code":["https://github.com/open-policy-agent/contrib/tree/main/pam_opa"],"inventors":["styra"],"content":"\\nHost-level access controls are an important part of every organization\'s security strategy. OPA provides fine-grained, context-aware controls for SSH and sudo using Linux-PAM.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/linux-pam.md","id":"linux-pam"},"legitify":{"title":"Legitify","subtitle":"Security policy for SCM","labels":{"layer":"tooling","category":"application"},"inventors":["legitsecurity"],"tutorials":["https://www.legitsecurity.com/legitify","https://github.com/Legit-Labs/legitify#github-action-usage"],"code":["https://github.com/Legit-Labs/legitify"],"content":"\\nStrengthen the security posture of your source-code management. Detect and\\nremediate misconfigurations, security and compliance issues across all your\\nGitHub & GitLab assets with ease.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/legitify.md","id":"legitify"},"kubestellar-console":{"title":"KubeStellar Console","subtitle":"Multi-cluster Kubernetes dashboard with OPA Gatekeeper policy management and AI-driven compliance scoring","software":["kubernetes"],"labels":{"category":"kubernetes","layer":"application"},"inventors":["kubestellar"],"code":["https://github.com/kubestellar/console"],"tutorials":["https://console.kubestellar.io/security-posture?card=opa_policies","https://console.kubestellar.io/missions/install-open-policy-agent-opa"],"blogs":["https://kubestellar.io/docs/news/ai-maintained-codebase"],"docs_features":{"kubernetes":{"note":"KubeStellar Console provides a unified multi-cluster dashboard with\\nnative OPA Gatekeeper integration. It discovers constraint templates\\nand constraints across all connected clusters, displays policy\\nviolations in real time, and lets operators create new Rego policies\\
1nusing an AI-assisted workflow that generates ConstraintTemplate and\\nConstraint YAML from plain-English descriptions.\\n\\nThe [AI Cloud Maturity Model (ACMM)](https://arxiv.org/abs/2604.09388)\\nbuilt into the console scores clusters across 8 dimensions \u2014 including\\na policy-as-code dimension that checks for OPA/Gatekeeper, Kyverno,\\nand Conftest artifacts \u2014 producing a quantified maturity score with a\\npublic [leaderboard](https://console.kubestellar.io/leaderboard).\\n\\nThe Fleet Compliance Heatmap card aggregates OPA Gatekeeper status\\nalongside Kyverno, Trivy, Kubescape, Falco, and Compliance Trestle\\ninto a single cross-cluster compliance view.\\n"}},"content":"\\nKubeStellar Console is a CNCF Sandbox multi-cluster Kubernetes dashboard that\\nprovides fleet-wide visibility into OPA Gatekeeper policies and violations. It\\nconnects to any number of clusters and aggregates constraint templates,\\nconstraints, and violations into a single pane of glass.\\n\\nKey OPA integration features:\\n\\n- **OPA Policies card** \u2014 lists all Gatekeeper constraint templates per cluster\\n with violation counts and enforcement mode (audit/warn/deny)\\n- **Fleet Compliance Heatmap** \u2014 visualizes OPA Gatekeeper health across every\\n cluster alongside other compliance tools\\n- **AI-assisted policy creation** \u2014 describe a policy in plain English and the\\n console generates the ConstraintTemplate and Constraint YAML, ready to apply\\n- **Per-cluster drill-down** \u2014 inspect individual violations with full resource\\n context, namespace, and remediation guidance\\n- **ACMM scoring** \u2014 the AI Cloud Maturity Model evaluates each cluster\'s\\n policy-as-code posture, checking for OPA/Gatekeeper artifacts as part of an\\n 8-dimension maturity assessment ([paper](https://arxiv.org/abs/2604.09388))\\n- **Guided install mission** \u2014 a built-in [AI mission](https://console.kubestellar.io/missions/install-open-policy-agent-opa)\\n walks operators through installing and configuring OPA Gatekeeper on any\\n connected cluster, with preflight checks and cluster selection\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubestellar-console.md","id":"kubestellar-console"},"kubeshield":{"title":"KubeShield","subtitle":"Secure Kubernetes using eBPF & Open Policy Agent","software":["linux","kubernetes","ebpf"],"labels":{"layer":"application","category":"filtering"},"code":["https://github.com/kubeshield/bpf-opa-demo"],"blogs":["https://appscode.com/blog/post/bpf-opa/"],"docs_features":{"kubernetes":{"note":"KubeShield implements runtime policy for containers in a Kubernetes\\ncluster using eBPF. Follow the\\n[tutorial here](https://github.com/kubeshield/bpf-opa-demo#usage)\\nto get up and running.\\n"}},"content":"\\nEnsure runtime security in any linux machine by combining Extended Berkeley Packet Filter(eBPF) and Open Policy Agent.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubeshield.md","id":"kubeshield"},"kubescape":{"title":"Kubescape","subtitle":"Kubernetes security posture scanner","labels":{"category":"security","layer":"application"},"software":["kubescape"],"code":["https://github.com/kubescape/kubescape","https://github.com/kubescape/regolibrary"],"inventors":["armo"],"tutorials":["https://hub.armosec.io/docs/armo-platform"],"docs_features":{"go-integration":{"note":"Kubescape uses the Go Repo API to test Kubernetes objects against\\na range of posture controls.\\n"}},"content":"\\nThis integration uses OPA for defining security controls over Kubernetes clusters. Kubescape is a simple extensible tool\\nfinding security problems in your environment. OPA enables Kubescape to implement and extend very fast to answer new problems.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubescape.md","id":"kubescape"},"kubernetes-validating-admission":{"title":"Kubernetes Admission Control","subtitle":"Control cluster operations with Rego policies","software":["kubernetes"],"labels":{"category":"containers","layer":"orchestration"},"tutorials":["https://www.openpolicyagent.org/docs/kubernetes"],"code":["https://github.com/open-policy-agent/kube-mgmt","https://github.com/open-policy-agent/gatekeeper"],"inventors":["styra","microsoft","google"],"videos":[{"title":"Securing Kubernetes With Admission Controllers","speakers":[{"name":"Dave Strebel","organization":"microsoft"}
1],"venue":"Kubecon Seattle 2018","link":"https://sched.co/GrZQ"},{"title":"Using OPA for Admission Control in Production","speakers":[{"name":"Zach Abrahamson","organization":"Capital One"},{"name":"Todd Ekenstam","organization":"Intuit"}],"venue":"Kubecon Seattle 2018","link":"https://sched.co/Grbn"},{"title":"Liz Rice Keynote","speakers":[{"name":"Liz Rice","organization":"AquaSecurity"}],"venue":"Kubecon Seattle 2018","link":"https://youtu.be/McDzaTnUVWs?t=418"},{"title":"Intro to Open Policy Agent Gatekeeper","speakers":[{"name":"Rita Zhang","organization":"microsoft"},{"name":"Max Smythe","organization":"google"}],"venue":"Kubecon Barcelona 2019","link":"https://kccnceu19.sched.com/event/MPiM/intro-open-policy-agent-rita-zhang-microsoft-max-smythe-google"},{"title":"Policy Enabled Kubernetes and CICD","speakers":[{"name":"Jimmy Ray","organization":"capitalone"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=vkvWZuqSk5M"},{"title":"TripAdvisor: Building a Testing Framework for Integrating OPA into K8s","speakers":[{"name":"Luke Massa","organization":"tripadvisor"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=X09c1eXvCFM"},{"title":"Enforcing automatic mTLS with Linkerd and OPA Gatekeeper","speakers":[{"name":"Ivan Sim","organization":"buoyant"},{"name":"Rita Zhang","organization":"microsoft"}],"venue":"Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=gMaGVHnvNfs"},{"title":"Enforcing Service Mesh Structure using OPA Gatekeeper","speakers":[{"name":"Sandeep Parikh","organization":"google"}],"venue":"Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=90RHTBinAFU"},{"title":"TGIK: Exploring the Open Policy Agent","speakers":[{"name":"Joe Beda","organization":"VMware"}],"link":"https://www.youtube.com/watch?v=QU9BGPf0hBw"}],"blogs":["https://medium.com/@sbueringer/kubernetes-authorization-via-open-policy-agent-a9455d9d5ceb","https://medium.com/@jimmy.ray/policy-enabled-kubernetes-with-open-policy-agent-3b612b3f0203","https://openpolicyagent.org/blog/securing-the-kubernetes-api-with-open-policy-agent-ce93af0552c3","https://itnext.io/kubernetes-authorization-via-open-policy-agent-a9455d9d5ceb","https://medium.com/capital-one-tech/policy-enabled-kubernetes-with-open-policy-agent-3b612b3f0203","https://www.redhat.com/en/blog/fine-grained-policy-enforcement-in-openshift-with-open-policy-agent"],"docs_features":{"rest-api-integration":{"note":"The Kubernetes API server can be configured to use OPA as an\\nadmission controller. Creating a\\n[ValidatingWebhookConfiguration](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/#validatingwebhookconfiguration)\\nresource can be used to query OPA for policy decisions.\\n"},"kubernetes":{"note":"View a selection of projects and talks about integrating OPA with\\nKubernetes.\\n"}},"content":"\\nKubernetes automates deployment, scaling, and management of containerized\\napplications. OPA provides fine-grained, context-aware authorization and\\nadmission control for clusters.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubernetes-validating-admission.md","id":"kubernetes-validating-admission"},"kubernetes-provisioning":{"title":"Kubernetes Provisioning","software":["kubernetes"],"labels":{"category":"containers","layer":"orchestration"},"inventors":["goldmansachs"],"videos":[{"title":"Kubernetes Policy Enforcement Using OPA at Goldman Sachs","speakers":[{"name":"Miguel Uzcategui","organization":"goldmansachs"},{"name":"Tim Hinrichs","organization":"styra"}],"venue":"Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=lYHr_UaHsYQ&list=PLj6h78yzYM2NDs-iu8WU5fMxINxHXlien&index=140&t=0s"}],"content":"\\nKubernetes automates deployment, scaling, and management of containerized applications. OPA decides which resources need to be created on k8s in response to a namespace being created.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubernetes-provisioning.md","id":"kubernetes-provisioning"},"kubernetes-authorization":{"title":"Kubernetes Authorization","code":["https://github.com/open-policy-agent/contrib/tree/main/k8s_authorization"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/kubernetes-authorization-webhook/","https://itnext.io/kubernetes-authorization-via-open-policy-agent-a9455d9d5ceb","https://itnext.io/optimizing-open-policy-agent-based-kubernetes-authorization-via-go-execution-tracer-7b439bb5dc5b"],"inventors":["styra"],"docs_features":{"rest-api-integration":{"note":"The Kubernetes API server can be configured to use OPA as an\\nauthorization webhook. Such an integration can be configured by\\nfollowing [the documentation](https://github.com/open-policy-agent/contrib/tree/main/k8s_authorization)\\nin the contrib repo.\\n"},"kubernetes":{"note":"View\\n[an example project](https://github.com/open-policy-agent/contrib/tree/main/k8s_authorization)\\nshowing how it\'s possible to integrate OPA with Kubernetes User Authorization.\\n"}},"content":"\\nKubernetes Authorization is a pluggable mechanism that lets administrators control which users can run which APIs and\\nis often handled by builtin RBAC. OPA\'s policy language is more flexible than the RBAC, for example,\\nwriting policy using a prohibited list of APIs instead of the usual RBAC style of listing the permitted APIs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kubernetes-authorization.md","id":"kubernetes-authorization"},"kopa":{"title":"Kopa","labels":{"category":"containers","layer":"orchestration"},"software":["kubernetes"],"code":["https://github.com/sfreet/kopa"],"docs_features":{"kubernetes":{"note":"Kopa integrates OPA with Kubernetes validating admission webhooks."}}
1,"content":"\\nKopa is a Kubernetes validating admission webhook that delegates policy\\ndecisions to OPA.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kopa.md","id":"kopa"},"kong-authorization":{"title":"API Gateway Authorization with Kong","labels":{"layer":"network","category":"gateway"},"software":["kong"],"code":["https://github.com/open-policy-agent/contrib/tree/main/kong_api_authz"],"inventors":["wada-ama"],"content":"\\nKong is a microservice API Gateway. OPA provides fine-grained, context-aware\\ncontrol over the requests that Kong receives.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kong-authorization.md","id":"kong-authorization"},"kafka-authorization":{"title":"Kafka Topic Authorization","subtitle":"Build fine grained access control for Kafka topics","software":["kafka"],"labels":{"category":"streaming","layer":"data"},"blogs":["https://www.opencredo.com/blogs/controlling-kafka-data-flows-using-open-policy-agent"],"tutorials":["https://www.openpolicyagent.org/docs/kafka-authorization"],"code":["https://github.com/StyraOSS/opa-kafka-plugin","https://github.com/llofberg/kafka-authorizer-opa","https://github.com/opencredo/opa-single-message-transformer"],"inventors":["ticketmaster","styra"],"videos":[{"title":"OPA at Scale: How Pinterest Manages Policy Distribution","speakers":[{"name":"Will Fu","organization":"pinterest"},{"name":"Jeremy Krach","organization":"pinterest"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=LhgxFICWsA8"}],"docs_features":{"rest-api-integration":{"note":"This project implements a custom\\n[Kafka authorizer](https://docs.confluent.io/platform/current/kafka/authorization.html#authorizer)\\nthat uses OPA to make authorization decisions by calling the REST API.\\n\\nInstallation and configuration instructions are available in the\\nproject\'s [README](https://github.com/StyraOSS/opa-kafka-plugin#installation).\\n"}},"content":"\\nApache Kafka is a high-performance distributed streaming platform deployed by\\nthousands of companies. OPA provides fine-grained, context-aware access control\\nof which users can read/write which Kafka topics to enforce important\\nrequirements around confidentiality and integrity.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/kafka-authorization.md","id":"kafka-authorization"},"jenkins-job-authorization":{"title":"Jenkins Job Trigger Policy Enforcement","labels":{"layer":"cicd"},"software":["jenkins"],"inventors":["pinterest"],"videos":[{"title":"OPA at Scale: How Pinterest Manages Policy Distribution","speakers":[{"name":"Will Fu","organization":"pinterest"},{"name":"Jeremy Krach","organization":"pinterest"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=LhgxFICWsA8"}],"content":"\\nJenkins automates software development processes. OPA lets you control which people and which machines can run which Jenkins jobs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/jenkins-job-authorization.md","id":"jenkins-job-authorization"},"iptables":{"title":"IPTables","labels":{"layer":"network","category":"linux"},"software":["linux"],"tutorials":["https://github.com/open-policy-agent/contrib/blob/main/opa-iptables/docs/tutorial.md"],"code":["https://github.com/open-policy-agent/contrib/tree/main/opa-iptables"],"inventors":["gsoc","cisco","styra"],"content":"\\nIPTables is a useful tool available to Linux kernel for filtering network packets. OPA makes it possible to manage IPTables rules using context-aware policy.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/iptables.md","id":"iptables"},"i2scim":{"title":"i2scim.io SCIM Restful User/Group Provisioning API","labels":{"category":"security","layer":"application"},"software":["i2scim"],"code":["https://github.com/i2-open/i2scim","https://i2scim.io"],"inventors":["i2"],"tutorials":["https://i2scim.io/OPA_AccessControl.html"],"docs_features":{"rest-api-integration":{"note":"i2scim supports externalized access control decisions using OPA\'s REST API.\\nThe integration is described
1in the [i2scim documentation](https://i2scim.io/OPA_AccessControl.html).\\n"}},"content":"\\ni2scim.io is an open source, Apache 2 Licensed, implementation of SCIM (System for Cross-domain Identity Management RFC7643/7644) for use\\ncloud-native kubernetes platforms. i2scim supports externalized access control decisions through OPA. SCIM is a RESTful HTTP API that can be\\nused to provide a standardized way to provision accounts from Azure, Okta, PingIdentity and other providers and tools. SCIM can also be used\\nas a backing identity store for OAuth and other authentication services.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/i2scim.md","id":"i2scim"},"graphql":{"title":"GraphQL","labels":{"category":"network","layer":"application"},"software":["graphql"],"code":["https://github.com/StyraOSS/graphql-apollo-example"],"tutorials":["https://www.openpolicyagent.org/docs/graphql-api-authorization"],"content":"\\nGraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/graphql.md","id":"graphql"},"gradle-plugin":{"title":"Gradle Build Plugin (Bisnode)","for_language":"java","labels":{"layer":"cicd","category":"cicdplugin","type":"poweredbyopa"},"software":["gradle","java","groovy","kotlin"],"code":["https://github.com/Bisnode/opa-gradle-plugin","https://plugins.gradle.org/plugin/com.bisnode.opa"],"inventors":["bisnode"],"content":"\\nBuild plugin adding various tasks to support using OPA as part of Gradle builds\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/gradle-plugin.md","id":"gradle-plugin"},"google-kubernetes-engine":{"title":"GKE Policy Automation","software":["kubernetes","google-kubernetes-engine"],"labels":{"category":"containers","layer":"orchestration"},"code":["https://github.com/google/gke-policy-automation"],"tutorials":["https://github.com/google/gke-policy-automation/tree/main/gke-policies"],"inventors":["google"],"docs_features":{"kubernetes":{"note":"The GKE Policy Automation project provides a set of policies for\\nvalidating Kubernetes clusters running on GKE. Review the\\n[policy library here](https://github.com/google/gke-policy-automation/tree/main/gke-policies-v2)\\n"}},"content":"\\nTool and policy library for reviewing Google Kubernetes Engine clusters against best practices\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/google-kubernetes-engine.md","id":"google-kubernetes-engine"},"google-calendar":{"title":"Google Calendar","labels":{"category":"data","layer":"rego"},"software":["google-calendar"],"inventors":["styra"],"code":["https://github.com/anderseknert/opa-google-calendar"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/the-power-of-data-calendar-based-policy-enforcement/"],"content":"\\nUsing the Google Calendar API with OPA for calendar powered policy decisions\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/google-calendar.md","id":"google-calendar"},"gloo-api-gateway":{"title":"Gloo API Gateway","labels":{"category":"servicemesh","layer":"gateway"},"blogs":["https://medium.com/solo-io/5-min-with-gloo-api-gateway-configuration-with-open-policy-agent-53da276a6534","https://docs.solo.io/gloo-mesh-enterprise/main/security/external-auth/opa/"],"content":"\\nGloo is an open-source Kubernetes-native ingress controller, and next-generation API gateway.\\nOPA can be used to implement authorization policies for those APIs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/gloo-api-gateway.md","id":"gloo-api-gateway"},"github-action-opa-rego-test":{"title":"GitHub Action for OPA Rego Test","subtitle":"GitHub Action to automate testing OPA Rego policies","labels":{"category":"library","type":"GitHub Action"},"inventors":["masterpoint"],"code":["https://github.com/masterpointio/github-action-opa-rego-test"],"tutorials":["https://github.com/masterpointio/github-action-opa-rego-test/blob/main/README.md"],"docs_features":{"policy-testing":{"note":"[GitHub Action for OPA Rego Policy Tests](docs/website/content/integrations/rego-test-assertions.md) automates testing for your OPA (Open Policy Agent) Rego policies, generates a report with coverage information, and posts the test results as a comment on your pull requests, making it easy for your team to review and approve policies.\\n"}},"content":"\\n[GitHub Action for OPA Rego Policy Tests](docs/website/content/integrations/rego-test-assertions.md) by [Masterpoint](https://masterpoint.io/) is used to automate testing for your OPA (Open Policy Agent) Rego policies, generates a report with coverage information, and posts the test results as a comment on your pull requests, making it easy for your team to review and approve policies.\\n\\nUse this to test your OPA Rego files for [Spacelift policies](https://docs.spacelift.io/concepts/policy), [Kubernetes Admission Controller policies](https://www.openpolicyagent.org/docs/kubernetes), [Docker authorization policies](https://www.openpolicyagent.org/docs/docker-authorization), or any other use case that uses [Open Policy Agent\'s policy language Rego](https://www.openpolicyagent.org/docs). This Action also updates PR comments with the test results in place to prevent duplication.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/github-action-opa-rego-test.md","id":"github-action-opa-rego-test"},"ghostunnel":{"title":"Ghostunnel","subtitle":"A simple TLS proxy with mutual authentication support","labels":{"layer":"network","category":"proxy"},"software":["ghostunnel"],"tutorials":["https://ghostunnel.dev/docs/security/access-flags/#open-policy-agent"],"code":["https://github.com/ghostunnel/ghostunnel"],"docs_features":{"go-integration":{"note":"Ghostunnel is written in Go and embeds OPA to evaluate Rego\\nauthorization policies, in addition to its built-in certificate-based\\naccess control checks.\\n"}},"content":"\\nGhostunnel is a simple TLS proxy with mutual authentication support for securing non-TLS backend applications. It can enforce access control using Rego policies alongside certificate field checks.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/ghostunnel.md","id":"ghostunnel"},"gatekeeper":{"title":"OPA Gatekeeper","subtitle":"Rego Policy Controller for Kubernetes","labels":{"type":"poweredbyopa","layer":"configuration"},"code":["https://github.com/open-policy-agent/gatekeeper"],"software":["kubernetes"],"tutorials":["https://open-policy-agent.github.io/gatekeeper/website/docs/howto/"],"videos":["https://youtu.be/RMiovzGGCfI?t=1049","https://youtu.be/6RNp3m_THw4?t=864"],"docs_features":{"go-integration":{"note":"OPA Gatekeeper is written in Go and uses the\\n[Rego Go API](https://www.openpolicyagent.org/docs/latest/integration/#integrating-with-the-go-api)\\nto evaluate policies loaded from Custom Resources.\\n"},"kubernetes":{"note":"OPA Gatekeeper integrates with\\n[Kubernetes Admission](https://
1open-policy-agent.github.io/gatekeeper/website/docs/customize-admission/)\\nand also uses Custom Resources and the Kubernetes API server to\\nstore policy state.\\n"}},"allow_missing_image":true,"content":"\\nManage Rego Kubernetes admission policies using Custom Resources.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/gatekeeper.md","id":"gatekeeper"},"flipt":{"title":"Flipt","subtitle":"CloudNative Feature Flag Management","labels":{"layer":"application","category":"Feature Flags"},"software":["golang","oidc"],"inventors":["flipt"],"blogs":["https://blog.flipt.io/authorization-with-open-policy-agent"],"code":["https://github.com/flipt-io/flipt"],"tutorials":["https://docs.flipt.io/v1/authorization/overview","https://docs.flipt.io/v1/guides/operation/authorization/rbac-with-keycloak","https://docs.flipt.io/v1/configuration/authorization"],"docs_features":{"go-integration":{"note":"Flipt\'s authorization feature uses the Go API to embed Open Policy Agent and evaluate authorization policies.\\n[These docs](https://docs.flipt.io/v1/authorization/overview)\\nexplain how it works.\\n"}},"content":"\\nFlipt is an open-source, Enterprise-ready, GitOps enabled, CloudNative feature management solution.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/flipt.md","id":"flipt"},"flask-opa":{"title":"Flask-OPA","labels":{"category":"flask","layer":"library"},"software":["flask"],"code":["https://github.com/EliuX/flask-opa"],"blogs":["https://github.com/EliuX/flask-opa/tree/master/examples"],"content":"\\nSimple to use Flask extension that lets you secure your projects with OPA. It allows HTTP API Authorization and Policy Enforcement Point (AOP using decorators on methods).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/flask-opa.md","id":"flask-opa"},"fig":{"title":"fig","labels":{"category":"utilities","layer":"shell"},"code":["https://github.com/open-policy-agent/contrib/tree/main/opa_fig_autocomplete","https://github.com/withfig/autocomplete/blob/master/src/opa.ts"],"inventors":["fig"],"content":"\\nBeautiful shell autocompletion for OPA and many other commands, for Mac OS\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/fig.md","id":"fig"},"fiber":{"title":"fiber","labels":{"category":"application","layer":"library"},"software":["golang","fiber"],"code":["https://github.com/gofiber/contrib/blob/main/v3/opa/README.md"],"content":"\\nFiber is an Express inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go.\\nDesigned to ease things up for fast development with zero memory allocation and performance in mind.\\nWith Open Policy Agent integration, you can run your Rego policies as part of the request lifecycle in the middleware.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/fiber.md","id":"fiber"},"fairwinds-insights":{"title":"Fairwinds Insights Configuration Validation Software","labels":{"category":"kubernetes","layer":"cicd"},"inventors":["fairwinds"],"software":["kubernetes","docker","helm"],"tutorials":["https://insights.docs.fairwinds.com/features/admission-controller/","https://insights.docs.fairwinds.com/features/insights-cli/"],"blogs":["https://www.fairwinds.com/blog/managing-opa-policies-with-fairwinds-insights","https://www.fairwinds.com/blog/manage-open-policy-agent-opa-consistently","https://www.fairwinds.com/blog/kubernetes-multi-cluster-visibility-why-how-to-get-it","https://www.fairwinds.com/blog/what-is-kubernetes-policy-as-code","https://www.fairwinds.com/blog/why-kubernetes-policy-enforcement","https://www.fairwinds.com/blog/an-interview-with-flatfile-on-why-fairwinds-insights-kubernetes-configuration-validation"],"docs_features":{"kubernetes":{"note":"Implements auditing and admission checking of Kubernetes resources\\nusing Rego policy using\\n[Polaris](https://github.com/FairwindsOps/Polaris).\\n"}},"allow_missing_image":true,"content":"\\nAutomate, monitor and enforce OPA policies with visibility across multiple clusters and multiple teams. It ensures the same policies are applied across all your cluster
1s and gives some flexibility if you want certain policies to apply to only certain workloads. Run the same policies in CI/CD, Admission Control, and In-cluster scanning to apply policy consistently throughout the development and deployment process.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/fairwinds-insights.md","id":"fairwinds-insights"},"evolith":{"title":"Evolith","subtitle":"Architecture governance as a PR gate, Rego evaluated in Wasm","labels":{"type":"poweredbyopa","category":"tooling","layer":"configuration"},"inventors":["beyondnet"],"software":["github-actions","nodejs","typescript"],"code":["https://github.com/beyondnetcode/evolith_arch32","https://www.npmjs.com/package/@beyondnet/evolith-cli"],"tutorials":["https://github.com/beyondnetcode/evolith_arch32#quick-start","https://beyondnetcode.github.io/evolith_arch32/"],"docs_features":{"wasm-integration":{"note":"Evolith compiles its rule corpus to a `policy.wasm` bundle and evaluates\\nit in Node.js through the\\n[OPA Wasm JavaScript module](https://github.com/open-policy-agent/npm-opa-wasm),\\nso its CLI, GitHub Action, MCP server and REST API all run the same policy\\nbuild. The distribution model is written up in\\n[ADR-0085](https://github.com/beyondnetcode/evolith_arch32/blob/main/reference/core/architecture/adrs/core/0085-agnostic-opa-wasm-distribution.md).\\n"}},"content":"\\nEvolith runs architecture rules \u2014 layering, dependencies, security, CI/CD, ADRs \u2014 against a repository from CI and fails the pull request. Rules are written in Rego and evaluated through OPA\'s Wasm build. A rule the engine could not evaluate is reported as a failure, never as a silent pass, so coverage and compliance stop looking identical: `skipped` is a first-class outcome, and a blocking rule that ends `skipped` fails the run.\\n\\nIt ships as a CLI (`npx -y @beyondnet/evolith-cli validate --engine opa`), a GitHub Action, an MCP server for AI coding agents and a REST API.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/evolith.md","id":"evolith"},"eopa":{"title":"EOPA","software":["enterprise-opa"],"labels":{"category":"authorization","type":"poweredbyopa"},"code":["https://github.com/open-policy-agent/eopa"],"inventors":["styra"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/introducing-styra-load-enterprise-opa-distribution-for-data-heavy-authorization/"],"videos":[{"title":"Start Loving Your Data-heavy Authorization","speakers":[{"name":"Torin Sandall","organization":"styra"},{"name":"Chris Hendrix","organization":"styra"}],"venue":"online","link":"https://www.youtube.com/watch?v=Is1iBPr1YVs"}],"content":"\\nA version of OPA designed for data heavy workloads, with data-filtering\\nfunctionality included.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/eopa.md","id":"eopa"},"envoy-authorization":{"title":"Container Network Authorization with Envoy","subtitle":"Official OPA Envoy Integration","labels":{"category":"servicemesh","layer":"network"},"software":["envoy"],"tutorials":["https://github.com/tsandall/minimal-opa-envoy-example/blob/master/README.md","https://www.openpolicyagent.org/docs/envoy"],"code":["https://github.com/open-policy-agent/opa-envoy-plugin","https://github.com/tsandall/minimal-opa-envoy-example"],"inventors":["styra"],"blogs":["https://openpolicyagent.org/blog/envoy-external-authorization-with-opa-578213ed567c"],"videos":[{"title":"OPA at Scale: How Pinterest Manages Policy Distribution","speakers":[{"name":"Will Fu","organization":"pinterest"},{"name":"Jeremy Krach","organization":"pinterest"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=LhgxFICWsA8"},{"title":"Deploying Open Policy Agent at Atlassian","speakers":[{"name":"Chris Stivers","organization":"atlassian"},{"name":"Nicholas Higgins","organization":"atlassian"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=nvRTO8xjmrg"},{"title":"How Yelp Moved Security From the App to the Mesh with Envoy and OPA","speakers":[{"name":"Daniel Popescu","organization":"yelp"},{"name":"Ben Plotnick","organization":"yelp"}],"venue":"Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=Z6aN3Smt-9M"}],"docs_features":{"envoy":{"note":"The\\n[opa-envoy-plugin](https://github.com/open-policy-agent/opa-envoy-plugin)\\nproject is the official integration for OPA and Envoy.\\n"},"rest-api-integration":{"note":"The [opa-envoy-plugin](https://github.com/open-policy-agent/opa-envoy-plugin)\\nproject uses the REST API to allow and deny requests routed via an Envoy proxy.\\n\\nRead about this integration in the\\n[OPA Docs](https://www.openpolicyagent.org/docs/envoy).\\n"}},"content":"\\nEnvoy is a networking abstraction for cloud-native applications. OPA hooks into Envoy\u2019s external authorization filter to provide fine-grained, context-aware authorization for network or HTTP requests.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/envoy-authorization.md","id":"envoy-authorization"}
1,"env0":{"title":"env0","labels":{"category":"Infrastructure as Code","layer":"Automation and collaboration"},"software":["terraform","pulumi","cloudformation","kubernetes","ansible","aws","gcp","azure"],"inventors":["env0"],"tutorials":["https://docs.envzero.com/guides/integrations/plugins/opa-plugin","https://docs.envzero.com/guides/policies-governance/policies"],"code":["https://github.com/env0/approval-policies"],"blogs":["https://www.env0.com/blog/opa-tutorial-leveraging-env0-for-advanced-cloud-policy-management","https://www.env0.com/blog/open-policy-agent"],"videos":[{"title":"Open Policy Agent Extensibility to use across your Infrastructure as Code","speakers":[{"name":"Anders Eknert","organization":"styra"}],"venue":"Online","link":"https://www.youtube.com/watch?v=bnsqPu9XwCE"}],"docs_features":{"terraform":{"note":"env0 is a Terraform automation platform that allows you to manage your\\ninfrastructure as code (IaC) at scale. It has a built-in integration with\\nOPA. See docs [here](https://docs.envzero.com/guides/integrations/plugins/opa-plugin).\\n"}},"content":"\\nenv0 is the best way to deploy and manage IaC - Terraform, OpenTofu, CloudFormation, Pulumi, Kubernetes, and more. The env0 platform integrates with OPA to allow its users to streamline cloud governance, automate policy enforcement, and maintain control over cloud deployments while enabling managed self-service.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/env0.md","id":"env0"},"emissary-ingress":{"title":"Emissary-Ingress","labels":{"category":"network","layer":"gateway"},"software":["emissary-ingress"],"blogs":["https://www.infracloud.io/blogs/emissary-ingress-opa-integration/"],"content":"\\nEmissary-Ingress is an open-source Kubernetes-native API Gateway, Layer 7 load balancer and Kubernetes Ingress built on Envoy Proxy.\\nOPA can be integrated with Emissary as an external authorization service to enforce authorization policies over APIs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/emissary-ingress.md","id":"emissary-ingress"},"elasticsearch-datafiltering":{"title":"Elasticsearch Data Filtering","labels":{"layer":"data","category":"filtering"},"software":["elasticsearch"],"code":["https://github.com/open-policy-agent/contrib/tree/main/data_filter_elasticsearch"],"tutorials":["https://github.com/open-policy-agent/contrib/blob/main/data_filter_elasticsearch/README.md"],"inventors":["styra"],"content":"\\nElasticsearch is a distributed, open source search and analytics engine. This OPA integration lets an elasticsearch client construct queries so that the data returned by elasticsearch obeys OPA-defined policies.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/elasticsearch-datafiltering.md","id":"elasticsearch-datafiltering"},"easegress":{"title":"Easegress","labels":{"category":"gateway","layer":"network"},"code":["https://github.com/easegress-io/easegress"],"inventors":["megaease"],"content":"\\nEasegress is a Cloud Native API orchestration system.\\nOPA can be configured as a filter(plugin) to implement authorization policies for the APIs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/easegress.md","id":"easegress"},"docker-machine":{"title":"Docker controls via OPA Policies","software":["docker"],"labels":{"layer":"server","category":"container"},"code":["https://github.com/open-policy-agent/opa-docker-authz"],"tutorials":["https://www.openpolicyagent.org/docs/docker-authorization"],"inventors":["styra"],"content":"\\nDocker\'s out of the box authorization model is all or nothing. This integration demonstrates how to use OPA\'s context-aware policies to exert fine-grained control over Docker.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/docker-machine.md","id":"docker-machine"},"digger":{"title":"Digger","subtitle":"GitOps for Terraform","labels":{"layer":"cicd","category":"Infrastructure as Code"},"software":["terraform"],"inventors":["diggerhq"],"code":["https://github.com/diggerhq/digger"],"tutorials":["https://docs.opentaco.dev/readme/introduction","https://docs.opentaco.dev/digger-api/rbac-via-opa-guide","https://docs.opentaco.dev/configuration/using-opa-conftest"],"content":"\\nDigger is an open-source CI/CD orchestrator for Terraform. It provides role-based access control via OPA, and also integrates Conftest to check Terraform plan output against policies.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/digger.md","id":"digger"}
1,"dependency-management-data":{"title":"dependency-management-data","subtitle":"A set of tooling to get a better understanding of the use of dependencies across your organisation.","labels":{"category":"tooling","layer":"shell"},"inventors":["jamie-tanna"],"blogs":["https://dmd.tanna.dev/cookbooks/custom-advisories-opa/"],"code":["https://gitlab.com/tanna.dev/dependency-management-data"],"tutorials":["https://dmd.tanna.dev/cookbooks/custom-advisories-opa/"],"docs_features":{"go-integration":{"note":"dependency-management-data uses the Go Rego API to make it possible to\\nwrite more complex rules around usages of Open Source and internal\\ndependencies.\\n\\nExample policies can be found [in DMD\'s example project](https://gitlab.com/tanna.dev/dependency-management-data-example/-/tree/main/policies?ref_type=heads)\\nand provide an indication of some common use-cases.\\n"}},"content":"\\ndependency-management-data is a set of tooling that makes it easier to\\nunderstand the usage of Open Source and internal dependencies in an\\norganisation, taking data from Renovate, GitHub Dependabot, or Software Bill of\\nMaterials (SBOMs) and providing an SQLite database that can be used to query it.\\n\\nAlongside this base functionality, it\'s possible to write \\"advisories\\" to flag\\nusage of certain dependencies for i.e. \\"this internal library has a security\\nvulnerability\\" or \\"this Open Source project is no longer maintained\\".\\n\\nAs a step further than this, it\'s now possible to write \\"policies\\", using Open\\nPolicy Agent to provide much more powerful control over usage of dependencies,\\nleveraging the excellent support Rego and OPA has for common operations.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/dependency-management-data.md","id":"dependency-management-data"},"dart-authorization":{"title":"HTTP API Authorization in Dart","labels":{"layer":"network","category":"application"},"software":["dart"],"tutorials":["https://github.com/adaptant-labs/opa-api-authz-dart/blob/master/README.md"],"code":["https://github.com/adaptant-labs/opa-api-authz-dart"],"inventors":["adaptant"],"content":"\\nThis integration demonstrates how to leverage OPA to perform basic HTTP API\\nauthorization in a simple Dart microservice. OPA makes it possible to provide\\nfine-grained context-aware authorization for each REST endpoint and access\\nmethod.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/dart-authorization.md","id":"dart-authorization"},"dapr":{"title":"Dapr","software":["dapr"],"labels":{"category":"application","layer":"network"},"tutorials":["https://docs.dapr.io/reference/components-reference/supported-middleware/middleware-opa/"],"code":["https://github.com/dapr/dapr","https://github.com/dapr/components-contrib/blob/main/middleware/http/opa/middleware.go"],"docs_features":{"go-integration":{"note":"Dapr\'s contrib middleware include an OPA integration built on the Go\\nAPI.\\n[This tutorial](https://docs.dapr.io/reference/components-reference/supported-middleware/middleware-opa/)\\nexplains how to configure it.\\n"}},"content":"\\nMiddleware to apply Open Policy Agent policies on incoming requests\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/dapr.md","id":"dapr"},"custom-library-microservice-authorization":{"title":"Library-based Microservice Authorization","labels":{"category":"servicemesh","layer":"library"},"videos":[{"title":"How Netflix is Solving Authorization Across Their Cloud","speakers":[{"name":"Manish Mehta","organization":"netflix"},{"name":"Torin Sandall","organization":"styra"}],"venue":"Kubecon Austin 2017","link":"https://www.youtube.com/watch?v=R6tUNpRpdnY"}],"allow_missing_image":true,"content":"\\nMicroservice authorization can be enforced through a network proxy like Envoy/Istio/Linkerd/... or can be enforced by modifying the microservice code to use a common library. In both cases OPA makes the authorization decision that the network proxy or the library enforce.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/custom-library-microservice-authorization.md","id":"custom-library-microservice-authorization"},"cosign":{"title":"Container Signing, Verification and Storage in an OCI registry","labels":{"category":"security","layer":"application"},"software":["cosign"],"inventors":["sigstore"],"code":["https://docs.sigstore.dev/cosign/verifying/attestation/","https://github.com/sigstore/cosign-gatekeeper-provider"],"videos":["https://www.youtube.com/watch?v=gCi9_4NYyR0"],"docs_features":{"go-integration":{"note":"Cosign In-Toto attestations can be\\n[written in Rego](https://docs.sigstore.dev/cosign/verifying/attestation/),\\nthese are evaluated in the Cosign binary using the Go API.\\n"}},"content":"\\nCosign is a tool for container image signing and verifying maintained under the Project Sigstore\\nin collaboration with the Linux Foundation. Among other features, Cosign supports KMS signing,\\nbuilt-in binary transparency, and timestamping service with Rekor and Kubernetes policy enforcement.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/cosign.md","id":"cosign"},"coredns-authz":{"title":"CoreDNS Authorization","labels":{"layer":"network","category":"dns"},"software":["coredns"],"code":["https://github.com/coredns/policy"],"inventors":["infoblox"],"content":"\\nCoreDNS is a cloud-native DNS server written in Go. OPA can be used as a plugin to filter queries and responses.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/coredns-authz.md","id":"coredns-authz"}
1,"conftest":{"title":"Conftest","subtitle":"Rego policy for configuration files","labels":{"type":"poweredbyopa","layer":"configuration"},"code":["https://github.com/open-policy-agent/conftest"],"software":["kustomize","terraform","aws","toml","docker"],"tutorials":["https://www.conftest.dev","https://www.conftest.dev/examples/"],"videos":[{"title":"Applying Policy Throughout the Application Lifecycle with Open Policy Agent","speakers":[{"name":"Gareth Rushgrove","organization":"snyk"}],"venue":"Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=cXfsaE6RKfc"},{"title":"Terraform Code Reviews: Supercharged with Conftest","speakers":[{"name":"Jay Wallace","organization":"doordash"}],"venue":"Hashitalks 2020","link":"https://www.youtube.com/watch?v=ziKT-ZjZ7mM"}],"docs_features":{"policy-testing":{"note":"Conftest supports unit testing of policy and has a number of extra language\\nfeatures for working with configuration files. The functionality is\\n[documented here](https://www.conftest.dev/#testingverifying-policies).\\n"},"go-integration":{"note":"Conftest is written in Go and uses the\\n[Rego Go API](https://www.openpolicyagent.org/docs/latest/integration/#integrating-with-the-go-api).\\n"},"opa-bundles":{"note":"Conftest supports the loading of policy in a bundle format. The feature\\nis [documented here](https://www.conftest.dev/sharing/).\\n"},"terraform":{"note":"Conftest has generic support for Terraform source files defined in HCL.\\nThere is an example provided here on\\n[GitHub](https://github.com/open-policy-agent/conftest/tree/master/examples/hcl2).\\n"}},"content":"\\nConftest is a utility built on top of OPA to help you write tests against structured configuration data.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/conftest.md","id":"conftest"},"conforma":{"title":"Conforma","software":["conforma"],"inventors":["conforma"],"labels":{"category":"security","layer":"application"},"code":["https://github.com/conforma/cli"],"blogs":["https://conforma.dev/posts/"],"docs_features":{"go-integration":{"note":"[Conforma](https://conforma.dev/) uses the OPA go\\nlibrary to process rego policies when validating the signatures and\\nattestations of container images and other software artifacts.\\n"}},"content":"\\nSecurely verify supply chain artifacts, and enforce policies about how they were built and tested,\\nin a manageable, scalable, and declarative way.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/conforma.md","id":"conforma"},"cloudflare-worker":{"title":"Cloudflare Worker Enforcement of OPA Policies Using Wasm","software":["cloudflare"],"labels":{"layer":"application","category":"serverless"},"code":["https://github.com/open-policy-agent/contrib/tree/main/wasm/cloudflare-worker"],"tutorials":["https://github.com/open-policy-agent/contrib/blob/main/wasm/cloudflare-worker/README.md"],"docs_features":{"wasm-integration":{"note":"This example project in\\n[OPA contrib](https://github.com/open-policy-agent/contrib/tree/main/wasm/cloudflare-worker)\\nuses the\\n[NodeJS OPA Wasm Module](https://github.com/open-policy-agent/npm-opa-wasm)\\nto enforce policy at the edge of Cloudflare\'s network.\\n"}},"content":"\\nCloudflare Workers are a serverless platform that supports Wasm.\\nThis integration uses OPA\'s Wasm compiler to generate code enforced at the edge of Cloudflare\'s network.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/cloudflare-worker.md","id":"cloudflare-worker"},"clojure":{"title":"App authorization for Clojure","for_language":"clojure","software":["clojure","java"],"labels":{"layer":"network","category":"application"},"code":["https://github.com/anderseknert/clj-opa"],"inventors":["styra"],"content":"\\nAuthorization middleware for Ring based apps and other utilities for working with OPA in Clojure.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/clojure.md","id":"clojure"},"clair-datasource":{"title":"Kubernetes Admission Control using Vulnerability Scanning","software":["kubernetes","clair"],"labels":{"layer":"orchestration","category":"containers","datasource":"clair"},"code":["https://github.com/open-policy-agent/contrib/tree/main/image_enforcer"],"tutorials":["https://github.com/open-policy-agent/contrib/blob/main/image_enforcer/README.md"],"docs_features":{"rest-api-integration":{"note":"This example project in\\n[OPA contrib](https://github.com/open-policy-agent/contrib/tree/main/image_enforcer)\\nuses OPA over the REST API to enforce admission policy based on\\nvulnerability scanning results.\\n"},"kubernetes":{"note":"This example project in\\n[OPA contrib](https://github.com/open-policy-agent/contrib/tree/main/image_enforcer)\\nuses OPA to enforce admission policy in Kubernetes.\\n"}},"content":"\\nAdmission control policies in Kubernetes can be augmented with\\nvulnerability scanning results to make more informed decisions.\\nThis integration demonstrates how to integrate CoreOS Clair with OPA and\\nrun it as an admission controller.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/clair-datasource.md","id":"clair-datasource"},"circleci":{"title":"CircleCI","labels":{"category":"tooling","layer":"cicd","type":"poweredbyopa"},"tutorials":["https://circleci.com/docs/guides/config-policies/config-policy-management-overview/"],"inventors":["cir
1cleci"],"content":"\\nUse config policy management to create organization-level policies to impose rules and scopes around which configuration elements are required, allowed, not allowed etc.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/circleci.md","id":"circleci"},"chef-automate":{"title":"Chef Automate","subtitle":"Operational Visibility Dashboard","tutorials":["https://github.com/chef/automate/tree/master/components/authz-service#authz-with-opa"],"videos":[{"title":"OPA in Practice: From Angular to OPA in Chef Automate","speakers":[{"name":"Michael Sorens","organization":"chef"}],"venue":"OPA Summit at Kubecon San Diego 2019","link":"https://www.youtube.com/watch?v=jrrW855xL3s"}],"docs_features":{"go-integration":{"note":"Chef Automate uses the Go Rego API to evaluate authorization policies\\ncontrolling access to its own API endpoints. The feature is\\n[documented here](https://github.com/chef/automate/tree/master/components/authz-service#authz-with-opa).\\n"}},"allow_missing_image":true,"content":"\\nApplication require authorization decisions made at the API gateway, frontend, backend, and database.\\nOPA helps developers decouple authorization logic from application code, define a custom authorization model\\nthat enables end-users to control tenant permissions, and enforce that policy across the different components of the\\napplication (gateway, frontend, backend, database).\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/chef-automate.md","id":"chef-automate"},"ceph":{"title":"Ceph Object Storage Authorization","software":["ceph"],"labels":{"category":"object","layer":"data"},"tutorials":["https://docs.ceph.com/en/latest/radosgw/opa/"],"inventors":["styra","redhat"],"videos":["https://www.youtube.com/watch?v=9m4FymEvOqM&feature=share"],"docs_feature":{"rest-api-integration":{"note":"The Ceph Object Gateway implements a native integration with OPA using\\nthe REST API.\\nThe [integration is documented](https://docs.ceph.com/en/latest/radosgw/opa/)\\nin the Ceph docs.\\n"}},"content":"\\nCeph is a highly scalable distributed storage solution that uniquely delivers object, block, and file storage in one unified system. OPA provides fine-grained, context-aware authorization of the information stored within Ceph.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/ceph.md","id":"ceph"},"carbonetes":{"title":"Carbonetes - BrainIAC","software":["github","brainiac"],"labels":{"layer":"Infrastructure","category":"security","type":"poweredbyopa"},"code":["https://github.com/carbonetes/brainiac"],"inventors":["carbonetes"],"content":"\\nBrainIAC uses static code analysis to analyze IAC code to detect security issues before deployment. This tool can scan for issues like security policy misconfigurations, insecure cloud-based services, and compliance issues. The BrainIAC tool performs a comprehensive code scan and generates reports containing detailed insights into the identified issues..\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/carbonetes.md","id":"carbonetes"},"bottle":{"title":"Bottle Application Authorization","labels":{"layer":"network","category":"application"},"inventors":["dolevf"],"software":["bottle"],"code":["https://github.com/dolevf/bottle-acl-openpolicyagent"],"blogs":["https://blog.lethalbit.com/open-policy-agent-for-bottle-web-framework/"],"docs_features":{"rest-api-integration":{"note":"This sample python application calls has a middleware to call OPA\\nbefore processing each request. See the\\n[example code](https://github.com/dolevf/bottle-acl-openpolicyagent/blob/00a4336/main.py#L37).\\n"}},"content":"\\nThis integration demonstrates using Open Policy Agent to perform API authorization for a Python application backed by Bottle.\\nBottle is a fast, simple and lightweight WSGI micro web-framework for Python.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/bottle.md","id":"bottle"},"boomerang-bosun":{"title":"Boomerang Bosun Policy Gating","labels":{"type":"poweredbyopa","layer":"application"},"code":["https://github.com/boomerang-io"],"inventors":["ibm","boomerang"],"docs_features":{"rest-api-integration":{"note":"The\\n[Boomerang Bosun Service](https://github.com/boomerang-io/bosun.service.policy)\\ncomponent interacts with an OPA instance over the REST API to evaluate\\npolicy during CICD runs.\\n"}},"content":"\\nBoomerang Bosun is a policy-based gating system that combines Policy Templates with Rules and data to validate Gates.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/boomerang-bosun.md","id":"boomerang-bosun"}
1,"big-acl":{"title":"Big ACL","labels":{"category":"authorization","layer":"application","type":"poweredbyopa"},"inventors":["big-acl"],"code":["https://github.com/big-acl"],"tutorials":["https://docs.big-acl.com"],"blogs":["https://big-acl.com/blog"],"content":"\\nBig ACL natively integrates with OPA through bundle distribution (tar.gz with ETag-based polling), instance status tracking, and decision log collection. It supports RBAC, ABAC, and ReBAC patterns across multiple tenants.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/big-acl.md","id":"big-acl"},"backstage":{"title":"Backstage","labels":{"category":"authorization","layer":"application"},"software":["backstage"],"inventors":["petermacdonald"],"tutorials":["https://github.com/Parsifal-M/backstage-opa-plugins/blob/main/plugins/permission-backend-module-opa-wrapper/README.md"],"code":["https://github.com/Parsifal-M/backstage-opa-plugins/tree/main/plugins/permission-backend-module-opa-wrapper"],"content":"\\nThis integration is a plugin that acts as a wrapper around the Backstage permissions system, allowing you to use OPA to enforce permissions!\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/backstage.md","id":"backstage"},"aws-cloudformation-hook":{"title":"AWS CloudFormation Hook","software":["aws","cloudformation"],"labels":{"type":"poweredbyopa"},"tutorials":["https://www.openpolicyagent.org/docs/latest/aws-cloudformation-hooks/"],"code":["https://github.com/StyraOSS/opa-aws-cloudformation-hook"],"blogs":["https://web.archive.org/web/https://www.styra.com/blog/the-opa-aws-cloudformation-hook/"],"inventors":["styra"],"docs_features":{"rest-api-integration":{"note":"The OPA CloudFormation Hook uses AWS Lambda to consult an OPA instance\\nusing the REST API before allowing a CloudFormation stack to be created.\\n\\nRead [the tutorial](https://www.openpolicyagent.org/docs/latest/aws-cloudformation-hooks/)\\nhere in the OPA documentation.\\n"}},"content":"\\nAWS CloudFormation Hook that uses OPA to make policy decisions on infrastructure provisioned via AWS CloudFormation\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/aws-cloudformation-hook.md","id":"aws-cloudformation-hook"},"aws-api-gateway":{"title":"AWS API Gateway","labels":{"category":"servicemesh","layer":"gateway"},"code":["https://github.com/zotoio/sls-lambda-opa"],"content":"\\nThe AWS API Gateway controls API traffic for your application running on AWS. OPA can be configured as an external authorizer for that Gateway to implement authorization policies on APIs.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/aws-api-gateway.md","id":"aws-api-gateway"},"awesome-opa":{"title":"Awesome OPA List","software":[],"labels":{"category":"learning","type":"poweredbyopa"},"code":["https://github.com/open-policy-agent/awesome-opa"],"docs_features":{"learning-rego":{"note":"The Awesome OPA project maintains a list of\\n[policy packages](https://github.com/open-policy-agent/awesome-opa#policy-packages),\\nand [editor integrations](https://github.com/open-policy-agent/awesome-opa#ide-and-editor-integrations)\\nwhich can be helpful references for learning Rego.\\n"}},"allow_missing_image":true,"content":"\\nA curated list of awesome OPA related tools, frameworks and articles.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/awesome-opa.md","id":"awesome-opa"},"atmos":{"title":"Atmos","software":["aws","gcp","terraform","helm"],"inventors":["cloudposse"],"labels":{"category":"Infrastructure as Code","type":"poweredbyopa"},"tutorials":["https://atmos.tools/core-concepts/validate/opa/"],"code":["https://github.com/cloudposse/atmos"],"docs_features":{"terraform":{"note":"Atmos can validate Terraform stack before applying them. This is done\\nusing the `validate component` command\\n[documented here](https://atmos.tools/cli/commands/validate/component/).\\n"}},"content":"\\nWorkflow automation tool for DevOps. Keep configuration DRY with hierarchical imports of configurations, inheritance, and WAY more.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/atmos.md","id":"atmos"},"aserto":{"title":"Aserto","labels":{"category":"authorization","layer":"application","type":"poweredbyopa"},"inventors":["aserto"],"code":["https://github.com/aserto-dev","https://github.com/opcr-io"],"tutorials":["https://docs.aserto.com/docs"],"blogs":["https://www.aserto.com/blog/how-do-aserto-rego-policies-work","https://www.aserto.com/blog/testing-rego-policies","https://www.aserto.com/blog/aserto-on-aserto-an-opa-authorization-policy-for-aserto-tenants","https://www.aserto.com/blog/rego-getting-started"],"videos":["https://www.youtube.com/watch?v=RJkgmdjJn_w"],"content":"\\nAserto is a cloud-native authorization service that makes it easy to add permissions and RBAC to your SaaS applications and APIs.\\nAserto is based on the Open Policy Agent.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/aserto.md","id":"aserto"},"apache-apisix":{"title":"Authorization Integration with Apache APISIX","software":["apache-apisix"],"labels":{"category":"gateway","layer":"network"},"code":["https://github.com/apache/apisix"],"tutorials":["https://apisix.apache.org/docs/apisix/plugins/opa/"],"videos":["https://www.youtube.com/watch?v=DWl0QEYIXaA"],"blogs":["https://apisix.apache.org/blog/2021/12/24/open-policy-agent/","https://apisix.apache.org/blog/2023/03/02/security-policy-auditable/"],"docs_features":{"rest-api-integration":{"note":"Apache APISIX routes can delegate authorization decisions to OPA through\\nthe REST API. The\\n[Apache APISIX OPA plugin documentation](https://apisix.apache.org/docs/apisix/plugins/opa/)\\ndescribes the request and decision contract, plugin configuration, and\\nexample authorization policies.\\n"}},"content":"\\nApache APISIX provides a plugin for delegating fine-grained authorization decisions to OPA.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/apache-apisix.md","id":"apache-apisix"},"antlr":{"title":"ANTLR Grammar","labels":{"category":"utilities","layer":"rego"},"code":["https://github.com/antlr/grammars-v4"],"inventors":["independent"],"content":"\\nANTLR4 grammar for Rego.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/antlr.md","id":"antlr"},"alluxio":{"title":"Alluxio","labels":{"category":"authorization","type":"poweredbyopa"}
1,"tutorials":["https://documentation.alluxio.io/ee-ai-en/administration/security/enabling-authorization#management-api-authorization-with-open-policy-agent-opa"],"inventors":["alluxio"],"content":"\\nAlluxio is an open source data orchestration technology for analytics and AI for the cloud. Alluxio can integrate with OPA and delegate all permission checks to OPA.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/alluxio.md","id":"alluxio"},"alfred":{"title":"Alfred","subtitle":"Self-hosted OPA playground","labels":{"layer":"network","category":"application"},"software":["alfred"],"inventors":["dolevf"],"code":["https://github.com/dolevf/Open-Policy-Agent-Alfred"],"docs_features":{"learning-rego":{"note":"Similar to the public [OPA Playground](https://play.openpolicyagent.org/),\\nAlfred can be used to learn Rego interactively in an environment that\\ncan\'t use the public playground. Read about\\n[installation](https://github.com/dolevf/Open-Policy-Agent-Alfred#how-to-install).\\n"}},"content":"\\nAlfred introduces a local graphical user interface to interact with Open Policy Agent and acts as an alternative to OPA\'s playground, allowing the user to keep information related to policy testing locally.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/alfred.md","id":"alfred"},"agt-policies-africa":{"title":"AGT Policies Africa","subtitle":"OPA Policy Pack for African Data Protection and AI Agent Compliance","labels":{"category":"security","type":"poweredbyopa"},"code":["https://github.com/kingztech2019/agt-policies-nigeria"],"allow_missing_image":true,"docs_features":{"policy-testing":{"note":"Each jurisdiction ships a full `opa test` suite covering all decision\\noutcomes \u2014 `deny`, `escalate`, `audit`, and `allow` \u2014 for every rule.\\nThe test suite runs in CI and currently covers 140+ cases across\\n9 African jurisdictions.\\n"},"learning-rego":{"note":"The policies demonstrate real-world compliance patterns including\\nregex-based PII detection (national IDs, BVN/NIN biometrics),\\ncross-border data transfer controls, breach-notification suppression\\nguards, sector-specific transaction-limit enforcement, and\\nmulti-rule decision aggregation \u2014 useful reference implementations\\nfor anyone writing regulatory compliance policies in Rego.\\n"}},"content":"\\nAGT Policies Africa is an OPA policy pack for AI agents operating under African\\ndata protection and financial-sector regulations. It provides ready-to-deploy\\nRego policies and YAML `PolicyDocument` definitions for 9 jurisdictions:\\n\\n- **Nigeria** \u2014 NDPA 2023, CBN NIP transaction limits, NFIU AML/CFT, BVN/NIN protection\\n- **Kenya** \u2014 Data Protection Act 2019\\n- **Ghana** \u2014 Data Protection Act 2012 (Act 843)\\n- **Rwanda** \u2014 Law No. 058/2021 on Personal Data Protection\\n- **Egypt** \u2014 Personal Data Protection Law No. 151/2020\\n- **Mauritius** \u2014 Data Protection Act 2017\\n- **South Africa** \u2014 POPIA (Protection of Personal Information Act)\\n- **Tanzania** \u2014 Personal Data Protection Act 2022\\n- **Uganda** \u2014 Data Protection and Privacy Act 2019\\n\\nPolicies enforce controls such as cross-border transfer adequacy checks,\\nspecial-category and biometric data guards, breach notification suppression\\ndetection, national ID redaction (NIN, BVN, Ghana Card, Egypt NID, Mauritius NIC),\\nand sector-specific transaction limits \u2014 all returned as structured\\n`deny / escalate / audit / allow` decisions that AI agent runtimes can act on\\ndirectly without parsing error strings.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/agt-policies-africa.md","id":"agt-policies-africa"},"agent-evidence-admission":{"title":"Agent Evidence Admission","subtitle":"Rego admission rails for agent execution evidence, measured against a conformance corpus","labels":{"type":"poweredbyopa","category":"authorization","layer":"configuration"},"software":["kubernetes"],"code":["https://github.com/astrogilda/agent-evidence-admission","https://github.com/astrogilda/agent-evidence-ve
1ctors"],"docs_features":{"kubernetes":{"note":"A Rego policy admits or refuses a Kubernetes workload on the\\nadversarial-execution-evidence in-toto predicate attached to its image,\\nand declares per obligation what the engine enforces, what it only\\napproximates, and what it cannot reach.\\n"},"policy-testing":{"note":"`rego/execution_evidence_test.rego` runs the policy over a corpus\\ngenerated from\\n[agent-evidence-vectors](https://github.com/astrogilda/agent-evidence-vectors)\\nat tag `v0.10.1`, so the policy and the specification are checked against\\nthe same bytes. CI refuses a tag that has moved off the commit it is\\npinned to, and refuses any row that declares an obligation enforced while\\nthe run shows the rail answering differently from the oracle on a vector\\nciting it.\\n"}},"allow_missing_image":true,"content":"\\nAgent Evidence Admission carries four policy engines that decide whether a Kubernetes workload may run, on the strength of an in-toto attestation describing what an automated agent did while producing it. The Rego rail is `rego/execution_evidence.rego`.\\n\\nThe point of the repository is the honesty of its coverage table rather than the policy itself. `PROFILE-REGISTRY.md` records, obligation by obligation, whether each engine enforces it, approximates it, or cannot reach it, and `scripts/profile-map-gate.py` refuses a row that claims enforcement the run does not support. A reader can rebuild every one of those claims from a fresh clone in four commands, which is the property the project is built around: an admission decision nobody can re-derive is a decision you have to take on trust.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/entries/agent-evidence-admission.md","id":"agent-evidence-admission"}}')},80696:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-aspnetcore-247cc5d32b9861cfbfe3fb30eaffae47.png"},80853:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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
1aA1sP54odeJHv1/ugWEYhqkdU21+a8vGUhIjy9oR5ClANY3OGoHRPSNot6jC0OWxrp5c6UCIU+aNN/MITqw/ztQtrgRkGIZhGIZhGMabPwMWu7PHcBmlwwAAAABJRU5ErkJggg=="},80897:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/tavoai-0b18f579e04e4370b9ed4af3b933e4f8.png"},81002:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-wasm-js-ac815bbeda56b190c52f6e269018a5f0.png"},81274:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/cosign-2265748287bf7735359cb145e19bf6ab.png"},81428:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/rond-df3230ff256d52d094b5ae155c3866e8.png"},82549:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI3MiIgaGVpZ2h0PSI3MiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cmVjdCBmaWxsPSIjMDA1OTlDIiB4PSIwIiB5PSIwIiB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHJ4PSI2IiAvPgogIDxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDQsIDQpIj4KICAgICAgPHBhdGggZmlsbD0iI2ZmZmZmZiIgZD0iTTEgMGExIDEgMCAwIDAtMSAxdjE0YTEgMSAwIDAgMCAxIDFoNXYtMUgydi0xaDR2LTFINHYtMWgydi0xSDJ2LTFoNFY5SDRWOGgyVjdIMlY2aDRWMmgxdjRoMVY0aDF2MmgxVjJoMXY0aDFWNGgxdjJoMVYyaDF2NGgxVjFhMSAxIDAgMCAwLTEtMUgxeiIvPgogIDwvZz4KPC9zdmc+"},82790:e=>{"use strict";e.exports=JSON.parse('{"zig":{"title":"Zig","website":"https://ziglang.org/","content":"\\nZig is a general-purpose programming language and toolchain for maintaining robust, optimal and reusable software.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/zig.md","id":"zig"},"swift":{"title":"Swift","website":"https://www.swift.org/","content":"\\nSwift is a general-purpose programming language built using a modern approach to\\nsafety, performance, and software design patterns.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/swift.md","id":"swift"},"rust":{"title":"Rust","website":"https://rust-lang.org/","content":"\\nRust is a systems programming language focused on performance, memory safety, and concurrency. It is known for preventing common bugs at compile time without sacrificing speed.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/rust.md","id":"rust"},"php":{"title":"PHP","website":"https://www.php.net/","content":"\\nPHP is a popular general-purpose scripting language that is especially suited to web development. It powers many content management systems and websites across the internet.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/php.md","id":"php"},"javascript":{"title":"JavaScript","website":"https://developer.mozilla.org/en-US/docs/Web/JavaScript","content":"\\nJavaScript is a versatile, high-level programming language primarily used for interactive web development. It also powers server-side applications via environments like Node.js.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/javascript.md","id":"javascript"},"java":{"title":"Java","website":"https://www.oracle.com/java/","content":"\\nJava is a high-level, object-oriented programming language known for its portability across platforms. It is widely used in enterprise applications, Android development, and large-scale systems.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/java.md","id":"java"},"golang":{"title":"Go","website":"https://go.dev/","content":"\\nGo (or Golang) is an open-source programming language developed at Google. It is known for its simplicity, concurrency support, and performance, making it ideal for cloud-native applications, tools, and backend systems.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/golang.md","id":"golang"},"csharp":{"title":"C#","website":"https://learn.microsoft.com/en-us/dotnet/csharp/","content":"\\nC# (C-Sharp) is a modern, object-oriented programming language developed by\\nMicrosoft. It is widely used for building Windows applications, web services,\\nand enterprise software with the .NET platform.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/csharp.md","id":"csharp"},"clojure":{"title":"Clojure","website":"https://clojure.org/","content":"\\nClojure is a dynamic, general-purpose programming language, combining the approachability and interactive development of a scripting language with an efficie
1nt and robust infrastructure for multi-threaded programming.\\n","filePath":"/opt/build/repo/docs/src/data/ecosystem/languages/clojure.md","id":"clojure"}}')},84385:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/nacp-1bbbfe4c5b291c67717edfe58a611b77.png"},84587:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/jenkins-job-authorization-c709e5938af6b575fc8853d16f00e42c.png"},85042:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAANwAAABQCAYAAAByKBsiAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyRpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYxIDY0LjE0MDk0OSwgMjAxMC8xMi8wNy0xMDo1NzowMSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNS4xIE1hY2ludG9zaCIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDoyMzA4MzU0MkU3MUYxMUUxQkJEQkNFMjQzMjY0QjRDNCIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDoxNDk4QTk5MEU3MjYxMUUxQkJEQkNFMjQzMjY0QjRDNCI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjIzMDgzNTQwRTcxRjExRTFCQkRCQ0UyNDMyNjRCNEM0IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjIzMDgzNTQxRTcxRjExRTFCQkRCQ0UyNDMyNjRCNEM0Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+jULLTQAADvFJREFUeNrsXXtwVNUZ/+69uxswJNlYRUAd1qpVxwdJeYyKjhuQhwYhUamPVEmwoyNMx2Q6av9qSKd/OM6UwLTTGWZsE53RMi02iahlkJClQFEeZkEeVSgsKKDhkc37sdl7e87du+mS3Lv3de5mN3y/mW8Cu+ee73z3nN/5zndey0mSBAgEIjXg8RUgEEg4BAIJh0AgkHAIBBIOgUAg4RAIJBwCgYRDIBDM4TKakOM4xwrRft9tBeSPn8h0IvTfPkXUEFIkSOQ0kUD+oRNBrErEWMHM5hHOaGLWhCMkKyF/lhGhf702swsTaSTSRMjXiE0AgYSLkYwSq5LIiiQezC6o93uXyDpCvjA2B8RVR7gEor3GwJuZ8XrrkXiIq4pw7YW3l4Ao1aWQaKOJx3MV+a3HcaiJGL+Ea5/zEy+IUKfEaOmARuCh
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"},85092:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});
1const o=i.p+"assets/images/waltid-d4ffe0c9a4b5ad7d6e682403c096ac78.png"},85735:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/carbonetes-5bad17a76942af8eb81ee4c76e400c82.png"},86535:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/traefik-api-gateway-c6bcf039b3bc5a56e31880c433bdc36d.png"},87502:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-dotnet-af6e6a1b7ad8672fab95a8bfb8b9a869.png"},88259:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/elasticsearch-datafiltering-44356f7295b6506fb8535d4fd5e145ff.png"},88687:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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
1RznRia0SWbHCKLt4cLZESa3B1QRqOLmDyMT7EhRvuRM/6PfvcN8T5+RT+TMvyCwksO5wcYn8ebawkoeS1gMcyPXIIfWgv30o89xM8xt0x+p9YKtuNcYgSwjlRMYuYm2aOK0aY0YYRxwPjDMjVz3mNa6vP/z0YStuDjC9mBCcENBVfcHy2zFRszV0VowZoBj1RLckAKesxyDE4EsHRCYHuMTmYIdq4HPU7xz56iPvJvSgv3qznO/Yr6/Zfk7y3pVzT0UVRUY3WhbNYFcwmIbOMHdRE8oWw30bnyBs4p5g1H1zokejsq18kqVt5D1EezohQ7Zv3tnItM9MhUGv3nr8xz/0Gi9mMGNrdC71RSVygqMik1t7te0qTEpYXOfMnH17jOcfokmtAJjzL82GKF5zvevpPUSFbdggnnjbVZsPa/Ec0qUD4ifffSFXzAOZ7NeU4xOV5UMbkRUXWAcN3GGEbIPasUyoowg/ujGMVv+y5f1WqlicCOi0gKjG8+JBBoHUsGtmFJgjOY6HOtlC82LKruHouoCIzhP4blRtGJU5LsnACHbZFtaBPiyXqtV6LthovICowHAWQDIsWJFW0ionH/94IMvm5rqCFgvf1ReYARnIHCsGCcflCdK9/B7H7xgWi296sl6SStYydB8HAjMbQ5ls2LSGp73d2ZauPO9PRZMuodyMaeGgUfrVeTAT25AYJ/CnYvZOuu289osgsGeELrFPWwz5kxc61WJrlE2IDDCwYoZ3UmKTA7dVdRtmm5wD/uMJSk1WC83ILDH4QyME7bqDlovFjJsz8kr7Vn8KFtyG9zDeUa+ijNXhfWKAYHFcLBimavxuRw98IHqHnGCB3seAv81OP5bmtdetomi3uzMMvcnK1qgZ6hAYHvhDJDJerNjK6HyEvD43MEd51pEKvDd03xGblOrePnA9jCg9V4c67WKyOHjQGAJaICwqjtMzXHEJ8dqBdqVxTaI91ivN2+89Au5Ta0Cjmu4xFxFjblXAghMTYsRCRzLw1V87uBV1cC2CWLP/Ou13S89r3jdZVsLawrLn7OeqBDnq161oQICU0ADheMSzdDcxHSsXoDcmHYgU3nUTPx3cltaxdKUPlP8nIfIAFUbaiAwPW1mm+w201V0jip+5Ul1y8KJ5Z7JUuwR/Lffb6h8w1mba0jzTFZgo8oV8yYgMA0O+axJ5txj1jUBffiJu6pf20T/mMBk++3Xbz2fbP923haMINeQm1SuVK9DFyAwAzQ/4VieM4zc2C6zMecjXjz0jkpMTu7hd6+/fCcR3LhMFtXGCmMTPYGwvBkIzA43SNFluIrrLvOxLx/eVjWlMeWr9livfx28FBcJa97l4BpeRFjeDARmwSGfxYoqkvVgLWs5euB9VdmFaa7zmDVJWK8Bc94ly6EuME6vj7C8HQiMgUM+a8aWgCbmbcf7vf03xP5991Sts5UWI5lcVliveca8a9yhoSonf1Z5IDA+XFfxgq3ingZmwxT0mP7MVd3eYDqRmKzXWeaWrW3mJuvW0irwCRAYE8d8Fmc+ZhTZnxzeVu3R3J9Y7umsxqMHQMJ6yfIla46KmqxyKuWtpVXgUyAwBxxcxUnmfKynE9kLT72lapqhcw/n4xG/mPWSloYT1JAW95LtdQRcQwcgMHe4+Sw5H7MGAWIie8QfHrgmDj9xW1WYa3UPZdUGWa8tZsRwnLm1rqCoYWV7HKYBAnOEoorc3M85Rn/7SGSno/9//em3dbtO7hECLax8NG/61tU/PXD9/kEprgbT0qwz811biBq6A4GlgCoXuDurtBltBqJjHpfWsfb0W7qtY1UW7JGA5YLK7996/odccdWbnRVmUGMA1zAdEFh6lpjzMWkd1pkie+gufmbfxzcUf95KBjgoNP8wMHFr31Pijbt/9N+bawtccbWZQQ1BtYZIKKcAAksJDeJ55nzsYRLaFlkUJLLfPnDtrxXHVQ3wRy7b9X0T35lbaTc534bc1jPMb76KWsP0QGAZoKc6N2Q9TZbMKrKJ5Z4quvjY/IvqDiMLtDr9yr/9JeckSFzciOEWJwoJ9EBgGaGo2lnmUVxFNhVzQ5PRuyjQcnpiuccSgaO4BrrOwIAPBOYBSuRygx4uItudWO7Judup5PzrvSee+ysZFJlY7rHctzTiQlAjO/sePHgw6t+hMNSbnXVmFbogy5R6EDf/7rXxtVf+jPVeR3FJTmPe5QcIzCOxpC0n9C2yiowDxDVc4CJ6JFZfyO0kJYXY44Tw00CVJC7iOg9x+QUWLAC03L7HrJAQsTmPt1wTJZG5eS5B4XhEDD0DgQWCrBK3DCkis3uWwk0VEFc44CIGwlQpb+ASVVikgkTdg7iKAyxYYGjQd5mdcSO2aHk/u5EnBTPajhYT4goMBJYDKd22qMDW1nk36hvvMt8SFNBAdXxgILCcSCkyyUVZc6gK5VOruBVH6ygQis8PCCxHMlibPlmzh/WIdJyWQ8FuBMsqAn9AYEOAAhmu4hDU7u2fhRCvpLBa3lMBwA4ENiRSBiUEWTNXcQWvGAFqILAhkjLC6Cow2UcD7a2HBPJgQ4TctRq3068j0iU8BXENF1iwgkAdgVsMl5FjwZzzaCAMEFiBIJfR1ojGJjDktwoEBFZAqApet22rTmBbnP7zIF8gsIJCFfkrigWcSYENKBGNLVwLCARWcBRzs7jANshqYa5VUCCwEYAqN5boJ8plLaEio/hAYCMECe1Lm2sLr1f9WowKEBgAAUGiGYCAQGAABAQCAyAgEBgAAYHAAAgIBAZAQCAwAAICgQEQEAgMgIDsx8UFowSVi6k2y9gt4lIdCAykYmexFhUfT9JatNbEci+P4mMpriuK328UcUfO1AKrNzu6IsaTUf8+xXtMe1XJ/YCDbOMjzJvjac931KHGpKrBmGnV885iLbkgVK7AfnVnsXYqJ5EFQzeuN9cW9qX5zNzmYLSA0LQoED3SRwddIx002EmQZ5BjxdDQ5TyWuo8UuvvI3T63MuQiMOoxobv4G2jSMnLotmTaqPqFSRJcYNQpSdfAZQDXcCTRufroC5IgqMAopGqa9LbQT2L0mFjuSY/jPPUHEfTvyAc4QhA6TN8y9PC7XNROSBR96/ns5e7rmFEeyHfkkzyNbe75kcgyufYU+JoaRhQ3xD1WEUxg9WZn1rCDiNY1pFD+VPL3unkaXShV/mOde+NocMkI2Gx8Al9vdgZkgVdcBwF9D3m8mcTvBc1VZNCny7nBdKz5+DyWjjOgPcfaKc4vaqQzH38I0nEvk3ehDDwZrvmKySMhQUXXZTr2++i7pLrWHOizo3us+r4rIZoIBREY3TzTBm/zhoE1rwmI6J6WDcMcj3Oj5g37dY3R3+bqzQ5rEwXmpngn6KclxWPIG9o27RsjAc/Um53Llusa56G1MkQDo2PqNurTXfN1Oq7qu5iaqYrEtd6g1t9erAujLXn0fVd9fF6cUHMwU0h+tWDtxrib4Z2pNzs9GvRKyNJccdj9RL7uCr3vMVLsiCkHybrp/BKv5WybdEl1bi7I86Ekv0lcSeTDZ5s8i0zUmx05Fi8wv6/rxohWQghsKekWxeiPeDJyWhcpI5dYV6Vi4xJZvjhLKbabnc46L1LQZopWh6o7MQcpiG6Wz6aHg3fRuBBCYDpxCQcXpsjMJcXAcIk5rCQG02yKY2xZorZpGEt5LtEAN40HG5NpHxix7XqHSp6VHKsFr/nrU+j5PG083je8NnnTl0wuMdU7ylq243R8FZOJgayzXnJ+ckyGxWMJ3z5tbO4aXZTf8yQdy7RHWSqBGcQhz/ssXY9n6fN1SeozFKBI89m6ezKg+xLd72AJ8jyr6YMV8npAiv+xuQZNynUblp+QNz0WMdO5vWfjqQiKysl53LbGnVxiWMIuLc3oklvaSFkJcyoxF+7SfEX1fZ3dNLLyqrmoaq/oLn1+V2PxZlNYI91DQbmdrqUQPTUhBDbQPDmm5ebfBdxxcSMpLvGJGOQNmDcMlAa5dTXN9x2QmFTh7G3NNkRxq6XbpkhO2C9QpK2b0iXc0gSaWroHSorP0C0dkRZ2XHNdVjQCa7gIjO6JLtCkjE7KaClZSpdgjJVQQQ5drdoZzYUdJrYbp/t75Lbonu5jFFHU/SgHQOz62CzZCRLbmxTddLmuSjfSc1WN7nxmDNfkVc17XF1E3T1ZtXzHrPPoPYQQ2LalvjA5mR82tqCLrco/1AOjTe4Mh2kK93MHyKgFmlyjqbrpiPEBEqJsL0iQg9wP3aQ5dWSooAQZrOTGNGgyzmUua96qoJgCTioK8wAJGUWc9+kqpowkcbAFX2wRNN/r2B4dT4qM5ofHGJHNiKI8vHxaA9dj6V5vvJc+EttJggksChIYXuKaRNQJMm0IOWJJdx6x2jkVkRBMN/8UhcHZP5o8YYPqFqcotH3WILbJgA8jF3QPni3Xa5KiOEH32dOWB7v3h1PQMD2Fki9qin7HaFKZFIjOvMu6vfW4n0zukKt/nmSSSoxmE8eOIle6XMo6fUdZ0rOlOY+WJiQcJaZ7phA7nUO0WHVL/j8K9VOFxa7m/KY8W5A0yGnCBcX7pmk1wJ7gUez7trLkTOX1NtwTOSaX4jWWsXYWWZLiSvLIg7WSFcwxZmhgx0PG65ovOklh76igtOFBXBHyOG/TTdmlAWqqJ1xNiKatyaFMU01dNzbgp2JV+zP0kHhsO1i64cmQ+TR9/y6doy49IAogrujBs6EJ8V+gAtxu7IHaiL32Cr03y/7TunsyRqVp7ZilC9bqIHglB8NVTEYVTXmdqHr8jEdxxZmmi20S1yDpStDTUBfxi6rEz9HPXEIY8rNelQ+OmGunS3BP0nc/Z3jaDgq0iNXk2sW/yznFID9BD71UbhvdE9OcdSy2qiEYuZRKkbnXlQiNxfMPNDhMZTvDZkkzgE1BHQ7jsad5lhq6wixiJXf2dMbDZJlPzma8J5nJrRaR5hq6p/wMuQwRWQdrKHTro6LB1EgRUhbJ8h16IKUZmFtFayBE1yutyPaUsDl+dnRPhjaW8u5Nb7pYrchFooFWYxRhblD4OgumiFxEnyJ8xkQu3dAaWWvOTR3Qa/cEQuizTjoI9mIRO9uKT7/LcYei2j7VSmbO6cVEZvvsgQdru4csQY6Tmt9r80Lyy9abneOc4lFywxpU0DqbcBW2o6XlJErVvC3pxi1pPldG8toUbGgoPqfrskCUhNKiSfQsCS6ZX9mmYI6xZQBZsim6BjWFgLbpeq9ojtPT3CfTHE13X+OsaMqtjPee7mcU5Gk
1o7sc63Q/T9dZ9J9N1jD67Ebsn8fetR9eQCrG9se/BA10HbABAVrB9EQABgcAACAgEBkBAIDAAAgKBARAQCAyAgEBgAAQEAgMgIBAYAAGBwAAICAQGQEAgMAACAoEBEBAIDICAQGAABAQCAyAgEBgAAYHAAAgIBAZAQCAwAAICgQEQEAgMgIBAYACEQgjx/yj2w7SBfxIoAAAAAElFTkSuQmCC"},88746:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/evolith-d9140d6b22005b9d9da820169c78818e.png"},89071:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/docker-machine-fafe65848e8bda2c2be95601ae18fe62.png"},90866:(e,t,i)=>{"use strict";i.d(t,{A:()=>s});i(96540);const o={grid:"grid_pmaB",gridCenter:"gridCenter_DmrR"};var a=i(74848);function s(e){var t=e.children,i=e.justifyCenter,s=void 0===i||i;return(0,a.jsx)("div",{className:o.grid+" "+(s?o.gridCenter:""),children:t})}},91210:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-java-client-f5dd86c3ef6ef3f85acf14f07bf0daa8.png"},92295:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,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
1kY1zV0uHgd/X+zUrI9lYqv4w0+kPrq7WxW/ZV6NBfqzTn+AIAtEDABsnTp0kYp1bZmGJiUnqcomYz/ltd9No1u3+jtHfhTa2v0SN4IoCFgAmRoaEiHi8fei/qhbdt6mMwpIaWYbxjid+Fw9Dp9lTdvh9qGgAkQ2sw5jddyWG+axld4cQpICppP1Ndn/hqJRJbwRqhdCJiAaG1t3ZPuDub1ySglzo7H40XNQlBaahcKyRWWFf3+ggUL6ngr1B4ETECYZp3XkenuSSYT+kS8oNEnb543e/bb1rS2LpnHG6G2IGACQ42fyiQnKdVlvBYwhxpG9v5wOHo8b4DagYAJCNrcOYTXJrFxaGhIDzwVdDtIKe6IRGKX6As3eSNUP7zoAaCnHqG7vGdipDDq7unpyfB6QEml1PmrV6/r0vNl80aobgiYABgYGNBDYOa9U5R6BRU3nSv9zh8cGhr+TVtbWzGDZkGFQcAEgOu6u/PaZFxXrOe1CvHe4WF3HcadqR0ImAokpdzEa5WCejJ7KSVXU8gcw9ug+iBgAsB1TZfXJiNlVvFahWmikFlJIRPlDVBdEDABEAqpLK9Nzixm2pJSuZR6I6/wogfbUcgss6xYO2+A6oGACQDDMDwNxq2UO5/Xys11xV2mabxTKbGSt3nQQH/N7dFo9IO8AaoDAiYAuru7X6S7Pl6fiJTyWF6bCvr3TiYT7VKqM+nLQd6ep3oKq1stK/pR3gCVDwETHF6ODL1HT8TGi1NE6eE5KWSOoOWneGOeQnS7gTaXPswboLIhYAJCKfkgr02GHn8Gr00lCpkH0+lpC2jxLt6WJ5P+qhvC4WgLb4DKhYAJCMNwU7yWwzlBu5iwp2dZr+MkjtfTpdCXhRzpapBS3BmNRg/jDVCZEDABkc1mdcB42Y/RYBjZS3kxANToXEzyRFrezBvz0KgvhbAsq5jJ5iAgEDABkUql+mjFWs7rORwfDke+wItBMDqzgaFPptM7sD2h52En+t5kW1tb3tdnQTAhYILlZ7yQi5Ty0qDut3Cc7vtCIeNwWvw7b8vDHpmMu7y5uXkGb4DKgYAJkLEBpLxeyBiSUt0eDsf0UZzA6e7ufkYI92jql/yZt+Xh4Pr6aTdgqIfKhRcuYCgsOnktNzmLvs+hnkwbbwkCx3FeSqe305tLa3hbHo5bs2bdN3kRKgMCJmBs29Znxjq8nofpUopllhU9izcEgT7CRD0Zixa9Hi3TvmJZsZN4EYIPARNA2axxjhiZfN4zPabMjylklrW0tMzmjVONejKvm+bIWcheA1TSJtY1ltX2Pt4AwYaACaBVq7ofo3WqmOlIjjPNuodok2kpb5
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"},92587:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/lula-2dc0ff9269f413c9b907a43a6d2d0c63.svg"},93135:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/rego-test-assertions-5331c5a9f38fef183fafac30fdb000af.png"},93637:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/nodejs-express-3a8eb1fb3958976c877b8a2f7851ba11.png"},94341:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-wasm-rust-7feb06fde5657d352dfed2eb0fd8b8e2.png"},95143:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAUQAAAEHCAYAAADWJj8EAAAACXBIWXMAAC4jAAAuIwF4pT92AAAgAElEQVR4nO2dTVLcSBOGayZmPz0nMJxgmiUrwwmMF82GBXAC4ASYEwAnAC+8cS/AJwCvWNI+AT
10n+HpOMF+oKwWiVaWuVGWVSqr3iXCMR7Yl9Pcq/yrzNwVkmD6NlFJHSqniv38qpf5RSt2qyfYCVxiAfgBBlGD6tKOUuiMxrFKI4ZmabN/2+vwAyAQIoi/Tp7FS6sEghlV21WT7sbYVAJAUv+N2eHOyRgwLLmtbAADJAUH0Z89hD2M1fTqqbQUAJAUE0Z911mHJJSVeAACJAkH0xzWLXIjheW0rACAZIIj+3DP2cKqmTxu1rQCAJIAg+nPBsBILbmpbAABJAEH0ZbI9V0pdM/ayQ3WLAIDEgCDKcKWUmjP2BCsRgASBIEqgl+ddMPa0oaZPp7WtAIBOwUoVSaZPD0uX2I1CRDex1hmAdICFKAvHShxhBQsAaQELUZrp0w11vXFlS022Z4M5fwB6DCxEec6YZTiwEgFIBAiiNDomyC3DcVkPDQAIDFzmUEyfXpbZZDfmarK9OcCrAECvgIUYjjPGnosynC+1rQCAqMBCDAm/DGeLVr4AADoAFmJYjhl7RzccADoGghgSbe1dMY5whHXOAHQHBDE83G44sBIB6AgIYmj465x3MG4AgG5AUiUW3DIcnWDBOmcAIgILMR6cBMvGsrs2ACAqsBBjMn26c5zSV7KJMhwA4gELMS6cYm2Fdc4AxAWCGBNt7XESLHsowwEgHn/gWkenqEs8Yc1zLhIskuj50HuVJM9MTbY50wMBGCSIIXaBLqvhzFU5U5NtToG3HX3sS4Mgz5aJH/RmBBkDQeyK6dOzUmrseHSZcQPa/X6obZc+DgA9BTHE7uAkWKTWOa+zSrGeGmQNLMQu4Y8baF+GM30q4oUvte1mMNYAZAksxG7hrnP2mefsukpGodwH5AoEsUu0tccdN9C2DIdjWWKsAcgSCGL3XDHFqp2VqMWXcxxYiSA7IIhdw++G4zNuAGMNAGgASZVU4I8baFceE+s4APQQWIjpwC3DaevSxjoOAL0DgpgKuszllvHTFOMGXAu739DHwVgDAAxAENPijFmG09Z6w1gDAAxAEFNCx+q4ZTj88hiMNQDACJIqKRJr3ADGGgDwDliIaRJr3ADGGgBQARZiqvDLY7ZarXOOdRwAegAsxHThWG8+XWq4x0EZDhgssBBTZvp0yXRTd9Vk+7G2dR16RQpHUNsdRwqdSCpLjtDtG4gBQUwZ3er/xdDd2sajmmzvWv7MDv84hQjJjjVw+zkLEbwzJIIKF/4zWpYBX+Ayp0ys8hh9HM4KlnH0Mhwthg8GMVS07YF6PgLQGliIfSDWuIGQx9FWaCGinyr//oeabLutznGbaX2vJtufa1sBcAQWYj/grj9uWx4TZqzB9OmUXPJLym
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
1FzGQAhXEtcylGtS++KSqXmKy3maq3gyKofrbScC1lK9i6clY2FWAkErzKjGEK5OPxPwQREIbhYXQEGAbmrQ6q7XNDql1frNScL0VarFLI7cqg10QB0weHArvr1qitvrUMcEhQIlqhm5+C07AiAPlCJvw+FuamHYhaCSHEMU1YsJFlMKQPZMCQxVJTsrCV6chHE2Kb+I5Z1gYExJHf5yrZybPCCSGUCsbuBwzoEg6GjdygUs6ZVYzlYiLG7gV/BOgQDYyjW4Yx6iFoZtCBSMWfML9sc1iEYEpRMSamlXFseXdoHDr3sJnZm+TOWfIGBsUEf+j67zM7NVQZbmN1BEelxCt15AAgBxREPe2Ytlu3anENYQxZEiXXIrkAMQRaQoXGYeBnOgoqu2RP5Br10j+If5wFv3oLcZCRRQFZUWgDG6I/qyoxWh7VuQ5bFWmYSxhMSRqkC7asI41ABSB4Sxx0SR6n+qK6UvQhE+qhm1f5LvWWeyw4a3DXMZTPUWwghAGYqAllO29sQ6hcwp18/Q/WtzE4QV6GYyKjhhs2pZxrcYgA8qDSSLmlK0Lxr3hulgbRS6v+BU+iYVLxiyQAAAABJRU5ErkJggg=="},95243:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/opa-playground-92a1aebfb4ea664b7d9c550b29f450a5.png"},99901:(e,t,i)=>{"use strict";i.r(t),i.d(t,{default:()=>o});const o=i.p+"assets/images/raygun-250eb02f38110152f3f908d984ba5406.png"}}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.