
Wat is GitLab IaC-scanning?
Integreer en automatiseer het testen van inloggegevens volledig en beveilig GitLab-repo's met IaC-scanning. Neem GitOps-implementaties op en pak kritieke beveiligingsproblemen moeiteloos aan met GitLab IaC-scanning.

Infrastructure as Code (IaC) heeft het moderne technologielandschap snel veranderd. Door de inrichting en het beheer van infrastructuur in code vast te leggen, krijgen ontwikkelaars versiebeheer en herhaalbaarheid en nemen potentiële kwetsbaarheden af, maar de groeiende toepassing brengt ook nieuwe kwetsbaarheden met zich mee.
GitLab IaC-scanning is een effectieve en efficiënte manier om onjuiste configuraties en beveiligingslacunes in IaC-configuraties te ontdekken en ertegen te beschermen. Deze gids gaat dieper in op de waarde, de configuratie en de best practices om IaC-configuraties te versterken.

Wat is Infrastructure as Code (IaC)?
Infrastructure as Code (IaC) is een aanpak waarbij taken voor het inrichten, beheren en configureren van infrastructuur als code worden vastgelegd in plaats van via handmatige processen of aangepaste scripts. In plaats van handmatig servers, databases of netwerkcomponenten in te richten, gebruikt IaC standaardcodesjablonen.
De populariteit van IaC komt voort uit de groeiende behoefte aan wendbaarheid bij het implementeren en opschalen van applicaties. Traditioneel infrastructuurbeheer vergde een tijdrovende inrichting waarbij menselijke fouten vaak een rol speelden; IaC biedt consistentie, herhaalbaarheid en snelle updates door infrastructuur net als softwarecode van versiebeheer te voorzien, zodat herhaalbare infrastructuurimplementaties continu zonder menselijk toezicht of menselijke fouten kunnen draaien.
DevOps-praktijken sluiten ook goed aan op IaC en overbruggen de kloof tussen ontwikkeling en beheer. Met IaC kunnen infrastructuurwijzigingen tegelijk met applicatieontwikkeling worden doorgevoerd, voor snellere implementaties en soepeler beheer van pipelines. Samen maken ze implementatieprocessen efficiënter en betrouwbaarder.
Waarom is IaC-scanning essentieel?
Infrastructure as Code heeft nieuwe potentiële kwetsbaarheden gecreëerd. Ontwikkelaars die scripts schrijven om infrastructuurimplementaties te automatiseren, kunnen onbedoeld aanzienlijke beveiligingslacunes in het implementatieproces introduceren; IaC-scanning is essentieel om zulke beveiligingslacunes te ontdekken voordat ze productieomgevingen bereiken.
Moderne cloud-native infrastructuren kunnen dynamische en complexe omgevingen zijn; zelfs de meest oplettende ontwikkelaars kunnen onjuiste configuraties over het hoofd zien. IaC-scantools doorzoeken codedefinities om configuraties te vinden die afwijken van best practices voor beveiliging en om het risico op datalekken en gecompromitteerde systemen door kwetsbaarheden in de infrastructuur te verkleinen. IaC-scantools gebruiken Artificial Intelligence-as-a-Consumption-technologie (AIC). Daarmee verlagen ze de risico's op datalekken of gecompromitteerde systemen door kwetsbaarheden in de infrastructuur aanzienlijk.
Nu nalevings- en gegevensbeschermingsnormen strenger zijn geworden, moeten bedrijven vanaf dag één veilige infrastructuur implementeren om juridische gevolgen of reputatieschade te voorkomen. IaC-scanning ondersteunt dit door te waarborgen dat hun infrastructuur voldoet aan branchevoorschriften en hen zo te beschermen tegen juridische gevolgen.
Inzicht in GitLab IaC-scanning
De functie Infrastructure as Code (IaC) Scanning van GitLab biedt een systematische aanpak om IaC-configuratiebestanden op potentiële kwetsbaarheden te controleren. Zo blijven de configuraties voor het inrichten en beheren van infrastructuur veerkrachtig, veilig en conform de voorschriften. De ondersteuning omvat verschillende IaC-configuratiebestanden, waaronder die voor Terraform, Ansible, AWS CloudFormation en Kubernetes.
- Ondersteunde bestanden en aanpassingsmogelijkheden
- Configuratie en aanpassing van regels
- Automatische afhandeling van kwetsbaarheden
1. Vereisten en compatibiliteit
Effectieve IaC-scanning moet in de testfase plaatsvinden, omdat opname in het .gitlab-ci.yml-bestand van deze fase vereist is.
- Infrastructure as Code heeft nieuwe mogelijkheden voor potentiële kwetsbaarheden gecreëerd. Ontwikkelaars die scripts schrijven om de implementatie van infrastructuur te automatiseren, kunnen onbedoeld aanzienlijke beveiligingslacunes in een infrastructuurimplementatieproces introduceren.
- Standaard is GitLab Runner met een Docker- of Kubernetes-executor verplicht (en automatisch ingeschakeld voor gebruikers van GitLab.com). IaC-scanninganalysers zijn mogelijk niet compatibel met andere CPU-architecturen dan amd64 & het is raadzaam Docker-versie 19.03.0 voor deze taken te vermijden. is essentieel om dergelijke beveiligingslekken op te sporen voordat ze de productieomgeving bereiken.
2. Ondersteunde bestanden en aanpassingsmogelijkheden
GitLab IaC-scanning biedt brede ondersteuning via de KICS-tool. Configuratiebestanden voor Ansible, AWS CloudFormation, Azure Resource Manager Dockerfile, Google Deployment Manager Kubernetes OpenAPI Terraform worden ondersteund; houd bij het beoordelen van resultaten ook rekening met specifieke vereisten, zoals JSON-geformatteerde Azure Resource Manager-sjablonen, en met het ontbreken van ondersteuning voor aangepaste Terraform-modules uit een register.datalekken en systeemcompromittering als gevolg van kwetsbaarheden in de infrastructuur. IaC-scantools maken gebruik van Artificial Intelligence-as-a-Consumption-technologie (AIC). Hierdoor verlagen ze aanzienlijk de risico's die verband houden met kwetsbaarheden in de infrastructuur die leiden tot datalekken of systeemcompromittering.
GitLab blijft met deze functie inzetten op openheid door alle opensource-analysers (OSS) beschikbaar te stellen via GitLab Free. Met de variabele SAST_IMAGE_SUFFIX kun je schakelen tussen standaard- en FIPS-versies van images.
3. Configuratie en aanpassing van regels
IaC-scanning instellen voor je project is vrij eenvoudig. Je kunt dit handmatig doen door de sjabloon SAST-IaC.gitlab-ci.yml op te nemen, die vervolgens IaC-scantaken in je CI/CD-pipeline aanmaakt, of automatisch via merge requests – de resultaten van IaC-scantaken worden na afloop opgeslagen als SAST-rapportartefacten.
Teams die het scanproces willen verbeteren, kunnen standaardregels aanpassen; je kunt onder meer:
- Bestaande regels overschrijven met eigen definities die bijvoorbeeld de ernst aanpassen of rechtstreeks naar eigen documentatie verwijzen.
Je kunt scanprocessen ook aan specifieke analysersversies koppelen, zodat updates met regressies of ongewenste wijzigingen geen gevolgen hebben.
4. Automatische afhandeling van kwetsbaarheden
GitLab IaC-scanning beperkt onnodige ruis in rapporten. Om rapporten relevant te houden en de aandacht op actuele kwetsbaarheden te richten, voert het systeem automatisch bepaalde acties uit:
1. Regels uitschakelen: Zodra je besluit dat een of meer regels niet meer relevant zijn voor je project en ze expliciet uitschakelt, worden de eerder gerapporteerde kwetsbaarheden automatisch afgehandeld.
2. Regels verwijderen: Als GitLab besluit dat een of meer standaardregels verouderd zijn of te veel fout-positieve meldingen opleveren, worden ze waarschijnlijk verwijderd en worden alle door die regels gemarkeerde kwetsbaarheden automatisch afgehandeld.
3. Historische gegevens: Een audittrail is essentieel; het Vulnerability Management-systeem van GitLab voegt opmerkingen toe, zodat je op de hoogte blijft van eerdere kwetsbaarheden die automatisch zijn afgehandeld.
4. Regels opnieuw activeren: Als je eerder uitgeschakelde regels opnieuw inschakelt, worden automatisch afgehandelde bevindingen opnieuw geopend voor triage, zodat eerdere kwetsbaarheden niet onopgemerkt blijven. vereist dat er binnen de testfase wordt gewerkt, aangezien het moet worden opgenomen in het .gitlab-ci.yml-bestand van deze fase.
Rapportage: inzicht in de JSON-indeling
De IaC-scantool van GitLab levert bevindingen als gestructureerde JSON-rapporten die voldoen aan de SAST-rapportindeling, zodat gebruikers uitgebreide resultaten krijgen:
1. Standaardisatie: Dit formaat maakt integratie en vergelijking tussen verschillende projecten of scans eenvoudig.
2. Toegankelijkheid: Gebruikers kunnen rapporten snel en eenvoudig rechtstreeks downloaden vanaf CI-pipelinepagina's of merge-requestpipelines met de instructie artifacts: paths voor “gl-sast-report.json”. Stel hiervoor de instructie artifacts: paths in op “gl-sast-report.json”.
3. Schemadocumentatie: GitLab biedt gedetailleerde schemadocumentatie. Zo kunnen gebruikers die het rapport verder willen onderzoeken of met andere systemen willen integreren, eenvoudig alle onderdelen ervan raadplegen.
GitLab IaC-scanning instellen
Laten we bekijken hoe u GitLab IaC-scanning voor uw projecten instelt.
De stappen voor het instellen van GitLab IaC-scanning zijn –
- Integratie met GitLab CI/CD
- Aangepaste configuratie (optioneel)
- De scan uitvoeren
- Resultaten bekijken
1. Vereisten
- Repository instellen: Uw Infrastructure as Code-bestanden (zoals Terraform-, CloudFormation- en Kubernetes-configuratiebestanden) moeten deel uitmaken van uw repository.
2. Integratie met GitLab CI/CD
Integreer IaC-scanning met de GitLab CI/CD-pipeline om deze in te stellen.
Maak .gitlab-ci.yml aan in de hoofdmap van uw repository of werk het bestand bij.
Voeg de volgende configuratie toe:
Include:
template: Security/Infrastructure-Scanning.gitlab-ci.yml
Hiermee activeert u de IaC-scantaak binnen uw CI/CD-pipeline.
3. Aangepaste configuratie (optioneel)
Voor projecten met specifieke vereisten kunt u het scanproces aanpassen:
- GitLab IaC Scanning legt de nadruk op het elimineren van onnodige ruis in rapporten. Om de relevantie te behouden en de focus op actuele kwetsbaarheden te houden, voert het systeem bepaalde automatische acties uit:
Variables:
IAC_PATHS: “infrastructure/*,!infrastructure/legacy/”: Zodra u besluit dat een of meer regels niet langer relevant zijn voor uw project en u deze expliciet hebt uitgeschakeld, worden eerdere rapporten over kwetsbaarheden automatisch opgelost.
In dit voorbeeld analyseert de scanner alleen bestanden in de map infrastructure en sluit hij de submap legacy uit.
4. De scan uitvoeren: Als GitLab besluit dat een of meer standaardregels verouderd zijn of te veel valse positieven opleveren, worden ze waarschijnlijk verwijderd en worden alle kwetsbaarheden die door dergelijke regels zijn gemarkeerd automatisch opgelost.
Start een CI/CD-pipeline zodra de configuratie is ingesteld. De IaC-scantaak analyseert uw Infrastructure as Code-bestanden en geeft inzicht in mogelijke kwetsbaarheden.
5. Resultaten bekijken: Het bijhouden van een audittrail is van cruciaal belang. Het kwetsbaarheidsbeheersysteem van GitLab voegt opmerkingen toe, zodat u op de hoogte blijft van eerdere kwetsbaarheden die automatisch zijn opgelost.
Na de analyse zijn eventuele kwetsbaarheden zichtbaar:
- 4. Regels opnieuw activeren: Door eerder uitgeschakelde regels opnieuw in te schakelen, worden automatisch opgeloste bevindingen opnieuw geopend voor triage, zodat kwetsbaarheden uit het verleden niet onopgemerkt blijven.
Hier kunt u:
- Rapportage: inzicht in het JSON-formaat
- De kwetsbaarheid als opgelost markeren of een issue aanmaken om deze te volgen.
- Optioneel geautomatiseerde acties instellen op basis van de ernst of het type kwetsbaarheid.
Best practices voor veilige IaC-configuratie (Infrastructure as Code)
Best practices voor veilige IaC-configuratie (Infrastructure as Code) zijn –
- Versiebeheer en het bijhouden van wijzigingen onderhouden
- Afhankelijkheden regelmatig scannen en bijwerken
- Geheimen beschermen
- Configuraties efficiënt valideren en beoordelen
1. Het PoLP-principe (het principe van minimale toegangsrechten): Dit formaat vergemakkelijkt de integratie en vergelijking tussen verschillende projecten of scans.
Het Principe van minimale rechten is een essentieel beveiligingsprincipe dat ervoor zorgt dat entiteiten (gebruikers, systemen of processen) alleen de rechten krijgen die nodig zijn om hun taken uit te voeren, en niet meer. Dit principe is nog belangrijker in IaC-omgevingen, waar rechten programmatisch kunnen worden toegekend; als dat onjuist of te ruim gebeurt, kunnen resources onnodig risico lopen.
Om binnen IaC aan de vereisten van PoLP te voldoen, moet u rechten zorgvuldig in scripts vastleggen, zodat elke service of functie alleen toegang heeft tot de benodigde resources – in cloudinfrastructuren zoals AWS kan dit betekenen dat u alleen-lezenrechten voor een S3-bucket toekent in plaats van algemene rechten voor alle opslagresources; controleer IaC-scripts doorlopend om rechten beperkt te houden terwijl de infrastructuur verandert.: Gebruikers kunnen rapporten snel en eenvoudig rechtstreeks downloaden van CI-pijplijnpagina's of pijplijnen voor samenvoegingsverzoeken met behulp van de artefacten: padenrichtlijn naar “gl-sast-report.json”. Om dit te vergemakkelijken, stelt u uw artifacts: paths-richtlijn in op “gl-sast-report.json”.
2. Beheer versies en houd wijzigingen bij
Versiebeheer is niet alleen nodig bij traditionele softwareontwikkeling; het speelt ook een essentiële rol bij het beheer van infrastructuur in een IaC-omgeving. Wijzigingen bijhouden, configuraties terugdraaien en aanpassingen aan de infrastructuur begrijpen is cruciaal om de omgeving veilig en stabiel te houden.: GitLab biedt gedetailleerde schemadocumentatie zodat geïnteresseerden die zich hierin willen verdiepen of dit rapport met andere systemen willen integreren, gemakkelijk en volledig toegang hebben tot alle onderdelen ervan.
GitLab en GitHub bieden voor IaC-configuraties niet alleen tools om wijzigingen bij te houden, maar ook functies om voorgestelde aanpassingen met teamleden te beoordelen voordat ze in productie worden genomen. Deze collegiale beoordeling zorgt ervoor dat beveiligingsrisico's en naleving van best practices worden meegewogen voordat belangrijke wijzigingen in IaC-omgevingen worden doorgevoerd.
3. Scan en update afhankelijkheden regelmatig
Net als bij softwareontwikkeling zijn infrastructure-as-code-configuraties (IaC) vaak afhankelijk van sjablonen en modules van derden om de uitrol van infrastructuur te vereenvoudigen; die afhankelijkheden maken de uitrol makkelijker, maar kunnen ook kwetsbaarheden introduceren als ze verouderd of gecompromitteerd zijn.
Door afhankelijkheden voortdurend te scannen, voorkomt u dat bekende beveiligingskwetsbaarheden in de infrastructuur terechtkomen. Speciale tools signaleren automatisch verouderde of kwetsbare modules en geven teams aan wanneer ze die moeten updaten – vergelijkbaar met patchbeheer voor software, maar dan specifiek voor infrastructuurmodules om maximale bescherming en weerbaarheid te bereiken.
4. Bescherm geheimen
In het digitale landschap zijn er talloze waarschuwingen voor ernstige inbreuken door blootgestelde geheimen. Het programmatische karakter van IaC maakt het verleidelijk om gevoelige informatie rechtstreeks in scripts vast te leggen – een onverantwoorde praktijk die altijd moet worden vermeden.
Organisaties moeten geheimen niet rechtstreeks in IaC-scripts opnemen, maar speciale tools voor geheimenbeheer gebruiken, zoals HashiCorp Vault of AWS Secrets Manager. Daarmee blijven geheimen versleuteld en beschermd, zelfs als configuratiebestanden openbaar worden.
5. Valideer en beoordeel configuraties efficiënt
Regelmatige beoordeling is nodig om IaC-scripts functioneel en veilig te houden. Wanneer configuraties of de IT-omgeving veranderen, kunnen nieuwe kwetsbaarheden ontstaan waardoor scripts die eerder werkten niet meer goed functioneren of helemaal uitvallen.
Organisaties moeten regelmatig controleren of hun IaC-configuraties voldoen aan branchebenchmarks en best practices om dit te voorkomen. Met geautomatiseerde testtools kan dat zonder handmatige tussenkomst. Test wijzigingen eerst in een staging- of testomgeving voordat u ze in productie neemt. Zo ontdekt u onverwachte problemen vroeg en blijft de productie-infrastructuur veilig en operationeel.
Veelvoorkomende valkuilen bij IaC en hoe u ze vermijdt
Veelvoorkomende valkuilen bij GitLab IaC Scanning en hoe vermijdt u ze?
- Tests overslaan
- Geheimen en inloggegevens hardcoderen
- IaC-scripts onnodig ingewikkeld maken
- Verouderde tools of bibliotheken vermijden
1. Infrastructuurcode behandelen als een eenmalig script
Een veelvoorkomend misverstand over infrastructuurcode (IaC) is dat u die kunt behandelen als een eenmalig script dat u schrijft en daarna nauwelijks meer bekijkt. Anders dan eenmalige scripts vereist IaC, net als andere softwarecode, periodiek onderhoud en regelmatige updates en herzieningen.
Zo voorkomt u dit: Beoordeel en update de code regelmatig. Gebruik tools zoals GitLab IaC Scanning om IaC-configuraties voortdurend te scannen – zo blijft uw code actueel, relevant en vrij van potentiële kwetsbaarheden.
2. Tests overslaan
Teams die snel willen uitrollen, slaan soms grondige tests van IaC-scripts over – vanuit de gedachte dat alles in orde is zolang het script draait – waardoor onverwacht gedrag of beveiligingskwetsbaarheden in de ingerichte infrastructuur kunnen ontstaan. Daardoor blijven problemen mogelijk onopgemerkt of ontstaan beveiligingslekken die direct na de uitrol moeten worden verholpen.
Zo voorkomt u dit: Test IaC-configuraties, net als applicatiecode, in niet-productieomgevingen zoals een staging-omgeving om configuratiefouten en andere problemen in productie te voorkomen; met GitLab IaC Scanning identificeren teams configuratiefouten voordat die productieomgevingen raken.
3. Geheimen en inloggegevens hardcoderen
Hardcoding is een duidelijke valkuil in IaC-scripts en moet altijd worden vermeden om gegevens te beschermen. Geheimen of inloggegevens die rechtstreeks in code zijn opgenomen, vormen aanzienlijke beveiligingsrisico's.
Zo voorkomt u dit: Neem geheimen niet rechtstreeks op in scripts, maar gebruik speciale tools voor geheimenbeheer. GitLab IaC Scanning kan dergelijke praktijken opsporen door configuratiebestanden te scannen en ontwikkelaars bijvoorbeeld te waarschuwen voor hardgecodeerde inloggegevens.
4. IaC-scripts onnodig ingewikkeld maken
Sommige engineers maken IaC-scripts te ingewikkeld omdat ze één aanpak willen ontwerpen voor elk mogelijk scenario. Dat kan uiteenlopende situaties afdekken, maar zorgt ook voor onnodige complexiteit en mogelijke storingspunten in hun IaC-implementaties.
Zo voorkomt u dit: Houd configuraties eenvoudig en duidelijk door ze op te delen in beheersbare modules en gebruik GitLab IaC Scanning; controleer die modules regelmatig met GitLab IaC Scanning, zodat ze effectief, veilig en functioneel blijven.
5. Verouderde tools of bibliotheken vermijden
IaC is vaak afhankelijk van tools of bibliotheken van derden; naarmate die worden doorontwikkeld, kunnen bepaalde functies komen te vervallen. Verouderde methoden kunnen zowel functionele problemen als beveiligingskwetsbaarheden veroorzaken.
Zo voorkomt u dit: Houd tools en bibliotheken van derden waarvan uw IaC-configuraties afhankelijk zijn nauwlettend in de gaten. Werk scripts regelmatig bij volgens de nieuwste versies en aanbevelingen en gebruik scantools zoals GitLab IaC Scanning om verouderde functies of afhankelijkheden op te sporen.
Conclusie
GitLab IaC-scanning kan beveiligingslekken opsporen en afhankelijkheden beheren. U kunt fout-positieve resultaten elimineren, aangepaste regels instellen en audittrails bijhouden. Het maakt rapportage ook een stuk eenvoudiger en u kunt GitLab IaC-scanning gemakkelijk integreren in uw CI/CD-pijplijn voor optimale resultaten. Bescherm geheimen, behoud versiebeheer en wijzigingstracering en pas het principe van minimale toegangsrechten toe met de GitLab IaC-scanner. Zo evalueert en beheert u uw configuraties efficiënt voor soepel infrastructuurbeheer.
- Aangepaste regels: Met GitLab IaC Scanning kunnen gebruikers aangepaste regels definiëren of bestaande regels wijzigen. Deze kunnen worden toegevoegd aan een .iac-custom-rules-map in de root van uw repository.
- Mappen negeren: als u wilt dat de scanner bepaalde mappen overslaat, kunt u deze definiëren in de CI/CD-configuratie onder variabelen:
Variabelen:
IAC_PATHS: “infrastructure/*,!infrastructure/legacy/”
In het bovenstaande voorbeeld analyseert de scanner alleen bestanden in de map infrastructure en sluit hij de submap legacy uit.
4. De scan uitvoeren
Zodra de configuratie is ingesteld, start u een CI/CD-pijplijnrun. De IaC-scantaken analyseert uw Infrastructure as Code-bestanden en geeft inzicht in mogelijke kwetsbaarheden.
5. Resultaten bekijken
Na de analyse worden de kwetsbaarheden (indien aanwezig) zichtbaar:
- In het samenvoegingsverzoek (als de scan daardoor is geactiveerd).
- In het gedeelte Beveiliging en naleving van uw project.
Hier kunt u:
- Details van de kwetsbaarheid bekijken.
- Deze markeren als opgelost of een issue aanmaken om deze bij te houden.
- Optioneel: automatische acties instellen op basis van de ernst of het type kwetsbaarheid.
Best practices voor veilige IaC (Infrastructure as Code) configuratie
Best practices voor veilige IaC (Infrastructure as Code)-configuratie zijn –
- PoLP-principe (het principe van minimale rechten)
- Versiebeheer en wijzigingen bijhouden
- Afhankelijkheden regelmatig scannen en bijwerken
- Geheimen beschermen
- Configuraties efficiënt valideren en evalueren
1. PoLP-principe (het principe van minimale rechten)
Het Principe van minimale rechten is een essentieel beveiligingsconcept dat ervoor zorgt dat entiteiten (gebruikers, systemen of processen) alleen de rechten krijgen die nodig zijn om hun taken uit te voeren, en niets meer. Dit principe wordt nog belangrijker in IaC-omgevingen met machtigingen die programmatisch kunnen worden toegewezen; wanneer deze onjuist of te ruim worden toegekend, kunnen ze resources blootstellen aan onnodige risico's.
Om te voldoen aan de PoLP-vereisten binnen IaC moeten machtigingen zorgvuldig worden gescript, zodat elke service of functie alleen toegang heeft tot de resources die ze nodig hebben – voor cloudinfrastructuren zoals AWS kan dit betekenen dat alleen-lezenrechten worden toegekend voor S3-buckets in plaats van algemene rechten voor alle opslagbronnen; voortdurende beoordeling van IaC-scripts om ervoor te zorgen dat de rechten strikt blijven naarmate de infrastructuur zich ontwikkelt.
2. Versiebeheer en wijzigingen bijhouden
Versiebeheer is niet alleen nodig bij traditionele softwareontwikkeling, maar speelt ook een essentiële rol bij infrastructuurbeheer in een IaC-omgeving. Het bijhouden van wijzigingen, het terugdraaien van configuraties en het begrijpen van infrastructuuraanpassingen is van cruciaal belang voor het handhaven van een veilige en stabiele omgeving voor IaC-infrastructuurbeheer.
GitLab- en GitHub-platforms voor IaC-configuratie bieden niet alleen tools voor het bijhouden van wijzigingen, maar ook samenwerkingsfuncties om voorgestelde wijzigingen met teamleden te beoordelen voordat ze in productieomgevingen worden geïmplementeerd. Dit peer review-proces zorgt ervoor dat er rekening wordt gehouden met veiligheidskwesties en dat best practices worden nageleefd voordat er belangrijke wijzigingen in IaC-omgevingen worden doorgevoerd.
3. Regelmatig scannen en bijwerken van afhankelijkheden
Net als bij softwareontwikkeling zijn Infrastructure as Code (IaC)-configuraties vaak afhankelijk van sjablonen en modules van derden om de implementatie van infrastructuur te stroomlijnen. Hoewel dergelijke afhankelijkheden de implementatie eenvoudiger kunnen maken, vormen ze ook potentiële kwetsbaarheden als ze verouderd of gecompromitteerd zijn.
Door afhankelijkheden voortdurend te scannen, wordt ervoor gezorgd dat er geen bekende beveiligingskwetsbaarheden in de infrastructuur worden geïntroduceerd. Speciale tools die voor deze taak zijn ontworpen, markeren automatisch verouderde of kwetsbare modules en vragen teams om deze indien nodig bij te werken, net als bij software patchbeheer maar dan specifiek toegepast op infrastructuurmodules om maximale bescherming en veerkracht te bereiken.
4. Bescherm geheimen
De digitale wereld staat vol met waarschuwende verhalen over geheimen die worden onthuld en tot ernstige inbreuken leiden. Door het programmatische karakter van IaC zijn programmeurs geneigd om gevoelige informatie rechtstreeks in scripts te coderen – een onverantwoordelijke praktijk die altijd moet worden vermeden.
Organisaties moeten vermijden om geheimen rechtstreeks in IaC-scripts in te bedden. In plaats daarvan moeten ze speciale oplossingen voor geheimenbeheer gebruiken, zoals HashiCorp Vault of AWS Secrets Manager, om geheimen te beveiligen terwijl ze versleuteld blijven, zodat ze zelfs als configuratiebestanden openbaar worden gemaakt, toch beschermd blijven.
5. Configuraties efficiënt valideren en evalueren
Ervoor zorgen dat IaC-scripts zowel functioneel als veilig zijn, is een voortdurende inspanning die regelmatige beoordeling vereist. Naarmate configuraties veranderen of het IT-landschap verschuift, ontstaan er nieuwe kwetsbaarheden die ervoor kunnen zorgen dat voorheen functionele scripts niet meer werken of zelfs helemaal kapot gaan.
Organisaties moeten ervoor zorgen dat hun IaC-configuraties regelmatig voldoen aan de benchmarks en best practices van de sector om dit scenario te voorkomen. Hiervoor kunnen ze geautomatiseerde testtools gebruiken voor regelmatige controles zonder handmatige tussenkomst. Voordat wijzigingen in productieomgevingen worden doorgevoerd, zijn staging- of testomgevingen van onschatbare waarde om vroegtijdig te waarschuwen voor onverwachte problemen, waardoor veilige en toch operationele infrastructuren in productieomgevingen worden gewaarborgd.
Veelvoorkomende valkuilen in IaC en hoe deze te vermijden
Veelvoorkomende valkuilen bij GitLab IaC-scanning en hoe deze te vermijden?
- Infrastructuurcode behandelen als een eenmalig script
- Het negeren van testen
- Geheimen en inloggegevens hardcoderen
- IaC-scripts te ingewikkeld maken
- Verouderde tools of bibliotheken omzeilen
1. Infrastructuurcode behandelen als een eenmalig script
Een veel voorkomende misvatting over infrastructuurcode (IaC) is dat deze wordt behandeld als een eenmalig script dat één keer wordt geschreven en daarna zelden opnieuw wordt bekeken. In tegenstelling tot eenmalige scripts vereist IaC echter periodieke onderhoudsupdates, herzieningen en revisies, net als elke andere softwarecode.
Hoe te voorkomen: Voer regelmatig codebeoordelingen en updates uit met behulp van tools zoals GitLab IaC Scanning om IaC-configuraties continu te scannen. Zo blijft uw code up-to-date, relevant en vrij van mogelijke kwetsbaarheden.
2. Verwaarlozing van testen
Sommige teams die haast hebben met de implementatie, slaan grondige IaC-scripttests over om snel te kunnen werken – in de veronderstelling dat als iets werkt, alles in orde is – wat kan leiden tot onverwacht gedrag of beveiligingskwetsbaarheden in hun geprovisioneerde infrastructuur. Door deze nalatigheid kunnen onverwacht gedrag onopgemerkt blijven of beveiligingslekken ontstaan die onmiddellijk moeten worden gepatcht bij de implementatie.
Hoe te voorkomen: Net als bij applicatiecode is het testen van IaC-configuraties in niet-productieomgevingen, zoals staging, essentieel om verkeerde configuraties en mogelijke valkuilen in de productieomgeving te voorkomen. GitLab IaC Scanning biedt hier een essentiële service waarmee teams verkeerde configuraties kunnen identificeren voordat deze direct invloed hebben op productieomgevingen.
3. Hardcoding van geheimen en inloggegevens
Hardcoding kan een voor de hand liggende valkuil zijn in IaC-scripts en moet altijd worden vermeden om de gegevensbeveiliging te beschermen. Door geheimen of inloggegevens rechtstreeks in hun code in te bedden, kunnen hardgecodeerde geheimen of inloggegevens aanzienlijke veiligheidsrisico's opleveren die niet mogen worden verwaarloosd.
Hoe te voorkomen: Gebruik speciale tools voor geheimenbeheer in plaats van geheimen rechtstreeks in scripts op te nemen. GitLab IaC-scantools kunnen dergelijke praktijken detecteren door ernaar te scannen als onderdeel van hun scanproces, bijvoorbeeld door ontwikkelaars te waarschuwen voor hardgecodeerde inloggegevens in hun configuratiebestanden.
4. IaC-scripts te ingewikkeld maken
Bij hun pogingen om één oplossing te ontwikkelen die elk mogelijk scenario dekt, maken sommige engineers IaC-scripts te ingewikkeld. Hoewel dit verschillende situaties efficiënter kan dekken, creëert het ook onnodige complicaties en potentiële zwakke punten in hun IaC-oplossingen.
Hoe te voorkomen: Geef prioriteit aan eenvoud en duidelijkheid door complexe configuraties op te splitsen in beheersbare modules met behulp van GitLab IaC Scanning; inspecteer deze modules regelmatig met GitLab IaC Scanning, zodat ze effectief, veilig en functioneel blijven.
5. Vermijd verouderde tools of bibliotheken
IaC is vaak afhankelijk van tools of bibliotheken van derden, maar naarmate deze externe bronnen zich ontwikkelen, kunnen bepaalde functies of mogelijkheden verouderd raken. Het gebruik van verouderde methoden kan zowel functionele als beveiligingsrisico's met zich meebrengen.
Hoe te voorkomen: Houd actief toezicht op alle tools of bibliotheken van derden waarvan uw IaC-configuraties afhankelijk zijn, werk scripts regelmatig bij om rekening te houden met bijgewerkte versies en aanbevelingen, en gebruik scantools zoals GitLab IaC Scanning die verouderde functies of afhankelijkheden markeren.

SentinelOne in actie zien
Ontdek hoe AI-gestuurde cloudbeveiliging uw organisatie kan beschermen in een één-op-één demo met een SentinelOne productexpert.
Conclusie
GitLab IaC-scanning kan beveiligingslekken detecteren en afhankelijkheden afhandelen. U kunt valse positieven elimineren, aangepaste regels instellen en audittrails bijhouden. Het maakt rapportage ook een stuk gemakkelijker en u kunt GitLab IaC-scanning eenvoudig integreren in uw CI/CD-pijplijn voor de beste resultaten. Bescherm geheimen, houd versiebeheer en wijzigingstracking bij en pas het principe van minimale toegangsrechten toe met de GitLab IaC-scanner. Het helpt u bij het efficiënt evalueren en beheren van uw configuraties voor een soepel infrastructuurbeheer.
Veelgestelde vragen over GitLab IaC Scanning
GitLab IaC Scanning is een ingebouwde CI/CD-functie die uw Infrastructure as Code-bestanden—zoals Terraform, CloudFormation, Ansible, Dockerfiles en Kubernetes-manifesten—controleert op configuratiefouten en bekende kwetsbaarheden. De scan draait tijdens de testfase van uw pipeline, genereert SAST-rapporten in JSON-formaat en markeert problemen in merge requests, zodat u risicovolle instellingen vóór de uitrol kunt corrigeren.
IaC Scanning werd geïntroduceerd in GitLab 14.5, dat in juni 2021 verscheen. Vanaf die versie activeren ondersteunde IaC-configuratiebestanden in een project automatisch de juiste op KICS gebaseerde analysetools tijdens CI-pipelines, mits u de IaC-sjabloon opneemt in uw .gitlab-ci.yml
GitLab IaC Scanning ondersteunt uiteenlopende configuratiebestanden, allemaal met KICS als basis:
- Ansible-playbooks
- AWS CloudFormation (YAML/JSON)
- Azure Resource Manager (JSON)
- Dockerfiles
- Google Deployment Manager
- Kubernetes-manifesten
- OpenAPI-definities
Terraform HCLAls u Bicep gebruikt, compileer dan naar JSON voordat u scant, en houd er rekening mee dat Terraform-modules uit aangepaste registers nog niet worden gescand .
Alle analyzers voor IaC-scanning in GitLab gebruiken KICS (Keep It Configuration Scanner), een opensource-engine die uw IaC-bestanden controleert aan de hand van een uitgebreide set regels. KICS herkent ondersteunde formaten automatisch en voert de juiste controles uit. Via CI-variabelen of mappen met aangepaste regels kunt u regels aanpassen of uitschakelen en regelversies vastzetten .
Voeg voor IaC-scanning de officiële template toe aan het bestand van uw project .gitlab-ci.yml bovenaan:
voeg de regel toe:
- template: Jobs/SAST-IaC.gitlab-ci.yml
Hierdoor wordt een iacs-job toegevoegd in de testfase. Op GitLab.com of bij een zelfbeheerde installatie met gedeelde runners hoeft u geen extra runner in te stellen. Na uitvoering van een pipeline verschijnen de scanresultaten als jobartefacten, in merge requests en onder Security & Compliance .



