[{"data":1,"prerenderedAt":671},["ShallowReactive",2],{"/pt-br/the-source/security":3,"footer-pt-br":35,"the-source-banner-pt-br":330,"the-source-navigation-pt-br":336,"the-source-newsletter-pt-br":358,"the-source-the-source-resources-pt-br":365,"authors-pt-br":392,"categories-pt-br":423,"security-articles-list-pt-br":424},{"id":4,"title":5,"body":6,"category":6,"config":7,"content":9,"description":6,"extension":26,"meta":27,"navigation":28,"path":29,"seo":30,"slug":31,"stem":32,"testContent":6,"type":33,"__hash__":34},"pages/pt-br/the-source/security/index.yml","",null,{"layout":8},"the-source",[10,18],{"componentName":11,"componentContent":12},"TheSourceCategoryHero",{"title":13,"description":14,"image":15},"Segurança e conformidade","Descubra como as empresas podem se manter a par da evolução das ameaças à segurança e dos requisitos de conformidade.",{"config":16},{"src":17},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463273/aplkxrvwpii26xao5yhi.png",{"componentName":19,"componentContent":20},"TheSourceCategoryMainSection",{"config":21},{"sourceCTAs":22},[23,24,25],"source-lp-guide-to-dynamic-sboms","source-lp-a-field-guide-to-threat-vectors-in-the-software-supply-chain","application-security-in-the-digital-age","yml",{},true,"/pt-br/the-source/security",{"title":13,"description":14,"ogImage":5},"security","pt-br/the-source/security/index","category","eS1snaBRY1zC7GNOobuX2rywU_RNktlMdQOHzSisJeE",{"data":36},{"text":37,"source":38,"edit":44,"contribute":49,"config":54,"items":59,"minimal":322},"Git é uma marca comercial da Software Freedom Conservancy e nosso uso do nome \"GitLab\" está sob licença",{"text":39,"config":40},"Acessar a origem da página",{"href":41,"dataGaName":42,"dataGaLocation":43},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":45,"config":46},"Editar esta página",{"href":47,"dataGaName":48,"dataGaLocation":43},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":50,"config":51},"Contribua",{"href":52,"dataGaName":53,"dataGaLocation":43},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":55,"facebook":56,"youtube":57,"linkedin":58},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[60,87,159,222,284],{"title":61,"links":62,"subMenu":68},"Plataforma",[63],{"text":64,"config":65},"Plataforma DevSecOps",{"href":66,"dataGaName":67,"dataGaLocation":43},"/pt-br/platform/","devsecops platform",[69],{"title":70,"links":71},"Preços",[72,77,82],{"text":73,"config":74},"Confira os planos",{"href":75,"dataGaName":76,"dataGaLocation":43},"/pt-br/pricing/","view plans",{"text":78,"config":79},"Por que escolher o GitLab Premium?",{"href":80,"dataGaName":81,"dataGaLocation":43},"/pt-br/pricing/premium/","why premium",{"text":83,"config":84},"Por que escolher o GitLab Ultimate?",{"href":85,"dataGaName":86,"dataGaLocation":43},"/pt-br/pricing/ultimate/","why ultimate",{"title":88,"links":89},"Soluções",[90,95,99,104,109,114,119,124,129,134,139,144,149,154],{"text":91,"config":92},"Transformação digital",{"href":93,"dataGaName":94,"dataGaLocation":43},"/pt-br/topics/digital-transformation/","digital transformation",{"text":13,"config":96},{"href":97,"dataGaName":98,"dataGaLocation":43},"/pt-br/solutions/application-security-testing/","Application security testing",{"text":100,"config":101},"Entrega de software automatizada",{"href":102,"dataGaName":103,"dataGaLocation":43},"/pt-br/solutions/delivery-automation/","automated software delivery",{"text":105,"config":106},"Desenvolvimento ágil",{"href":107,"dataGaName":108,"dataGaLocation":43},"/pt-br/solutions/agile-delivery/","agile delivery",{"text":110,"config":111},"Migração para a nuvem",{"href":112,"dataGaName":113,"dataGaLocation":43},"/pt-br/topics/cloud-native/","cloud transformation",{"text":115,"config":116},"SCM",{"href":117,"dataGaName":118,"dataGaLocation":43},"/pt-br/solutions/source-code-management/","source code management",{"text":120,"config":121},"CI/CD",{"href":122,"dataGaName":123,"dataGaLocation":43},"/pt-br/solutions/continuous-integration/","continuous integration & delivery",{"text":125,"config":126},"Gestão de fluxo de valor",{"href":127,"dataGaName":128,"dataGaLocation":43},"/pt-br/solutions/value-stream-management/","value stream management",{"text":130,"config":131},"GitOps",{"href":132,"dataGaName":133,"dataGaLocation":43},"/pt-br/solutions/gitops/","gitops",{"text":135,"config":136},"Grandes empresas",{"href":137,"dataGaName":138,"dataGaLocation":43},"/pt-br/enterprise/","enterprise",{"text":140,"config":141},"Pequenas empresas",{"href":142,"dataGaName":143,"dataGaLocation":43},"/pt-br/small-business/","small business",{"text":145,"config":146},"Setor público",{"href":147,"dataGaName":148,"dataGaLocation":43},"/pt-br/solutions/public-sector/","public sector",{"text":150,"config":151},"Educação",{"href":152,"dataGaName":153,"dataGaLocation":43},"/pt-br/solutions/education/","education",{"text":155,"config":156},"Serviços financeiros",{"href":157,"dataGaName":158,"dataGaLocation":43},"/pt-br/solutions/finance/","financial services",{"title":160,"links":161},"Recursos",[162,167,172,177,182,187,192,197,202,207,212,217],{"text":163,"config":164},"Instalação",{"href":165,"dataGaName":166,"dataGaLocation":43},"/pt-br/install/","install",{"text":168,"config":169},"Guias de início rápido",{"href":170,"dataGaName":171,"dataGaLocation":43},"/pt-br/get-started/","quick setup checklists",{"text":173,"config":174},"Saiba mais",{"href":175,"dataGaName":176,"dataGaLocation":43},"https://university.gitlab.com/","learn",{"text":178,"config":179},"Documentação do produto",{"href":180,"dataGaName":181,"dataGaLocation":43},"https://docs.gitlab.com/","docs",{"text":183,"config":184},"Blog",{"href":185,"dataGaName":186,"dataGaLocation":43},"/blog/","blog",{"text":188,"config":189},"Histórias de sucesso de clientes",{"href":190,"dataGaName":191,"dataGaLocation":43},"/pt-br/customers/","customer success stories",{"text":193,"config":194},"Trabalho remoto",{"href":195,"dataGaName":196,"dataGaLocation":43},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":198,"config":199},"Serviços do GitLab",{"href":200,"dataGaName":201,"dataGaLocation":43},"/pt-br/services/","services",{"text":203,"config":204},"Comunidade",{"href":205,"dataGaName":206,"dataGaLocation":43},"/community/","community",{"text":208,"config":209},"Fórum",{"href":210,"dataGaName":211,"dataGaLocation":43},"https://forum.gitlab.com/","forum",{"text":213,"config":214},"Eventos",{"href":215,"dataGaName":216,"dataGaLocation":43},"/events/","events",{"text":218,"config":219},"Parceiros",{"href":220,"dataGaName":221,"dataGaLocation":43},"/pt-br/partners/","partners",{"title":223,"links":224},"Empresa",[225,230,235,240,245,250,255,259,264,269,274,279],{"text":226,"config":227},"Sobre",{"href":228,"dataGaName":229,"dataGaLocation":43},"/pt-br/company/","company",{"text":231,"config":232},"Vagas",{"href":233,"dataGaName":234,"dataGaLocation":43},"/jobs/","jobs",{"text":236,"config":237},"Liderança",{"href":238,"dataGaName":239,"dataGaLocation":43},"/company/team/e-group/","leadership",{"text":241,"config":242},"Equipe",{"href":243,"dataGaName":244,"dataGaLocation":43},"/company/team/","team",{"text":246,"config":247},"Manual",{"href":248,"dataGaName":249,"dataGaLocation":43},"https://handbook.gitlab.com/","handbook",{"text":251,"config":252},"Relacionamento com investidores",{"href":253,"dataGaName":254,"dataGaLocation":43},"https://ir.gitlab.com/","investor relations",{"text":256,"config":257},"Sustainability",{"href":258,"dataGaName":256,"dataGaLocation":43},"/sustainability/",{"text":260,"config":261},"Diversidade, inclusão e pertencimento (DIB)",{"href":262,"dataGaName":263,"dataGaLocation":43},"/pt-br/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":265,"config":266},"Trust Center",{"href":267,"dataGaName":268,"dataGaLocation":43},"/pt-br/security/","trust center",{"text":270,"config":271},"Boletim informativo",{"href":272,"dataGaName":273,"dataGaLocation":43},"/company/contact/#contact-forms","newsletter",{"text":275,"config":276},"Imprensa",{"href":277,"dataGaName":278,"dataGaLocation":43},"/press/","press",{"text":280,"config":281},"Declaração de Transparência da Lei da Escravidão Moderna",{"href":282,"dataGaName":283,"dataGaLocation":43},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":285,"links":286},"Fale com a gente",[287,292,297,302,307,312,317],{"text":288,"config":289},"Fale com um especialista",{"href":290,"dataGaName":291,"dataGaLocation":43},"/pt-br/sales/","sales",{"text":293,"config":294},"Ajuda",{"href":295,"dataGaName":296,"dataGaLocation":43},"/support/","get help",{"text":298,"config":299},"Portal de clientes",{"href":300,"dataGaName":301,"dataGaLocation":43},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"text":303,"config":304},"Status",{"href":305,"dataGaName":306,"dataGaLocation":43},"https://status.gitlab.com/","status",{"text":308,"config":309},"Termos de uso",{"href":310,"dataGaName":311,"dataGaLocation":43},"/terms/","terms of use",{"text":313,"config":314},"Aviso de Privacidade",{"href":315,"dataGaName":316,"dataGaLocation":43},"/pt-br/privacy/","privacy statement",{"text":318,"config":319},"Preferências de cookies",{"dataGaName":320,"dataGaLocation":43,"id":321,"isOneTrustButton":28},"cookie preferences","ot-sdk-btn",{"items":323},[324,326,328],{"text":308,"config":325},{"href":310,"dataGaName":311,"dataGaLocation":43},{"text":313,"config":327},{"href":315,"dataGaName":316,"dataGaLocation":43},{"text":318,"config":329},{"dataGaName":320,"dataGaLocation":43,"id":321,"isOneTrustButton":28},{"visibility":28,"title":331,"button":332},"The Intelligent Software Development Era: How AI is reshaping DevSecOps teams",{"config":333,"text":335},{"href":334},"/developer-survey/","Get the research report",{"logo":337,"subscribeLink":342,"navItems":346},{"altText":338,"config":339},"the source logo",{"src":340,"href":341},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750191004/t7wz1klfb2kxkezksv9t.svg","/pt-br/the-source/",{"text":343,"config":344},"Assinar",{"href":345},"#subscribe",[347,351,354],{"text":348,"config":349},"Inteligência artificial",{"href":350},"/pt-br/the-source/ai/",{"text":13,"config":352},{"href":353},"/pt-br/the-source/security/",{"text":355,"config":356},"Plataforma e infraestrutura",{"href":357},"/pt-br/the-source/platform/",{"title":359,"description":360,"submitMessage":361,"formData":362},"Boletim informativo The Source","Fique por dentro dos insights para o futuro do desenvolvimento de software.","Você se inscreveu com sucesso no boletim informativo The Source.",{"config":363},{"formId":364,"formName":273,"hideRequiredLabel":28},28471,[366,376,383],{"config":367,"title":368,"description":369,"link":370},{"slug":25},"Segurança de aplicações na era digital","Leia as [descobertas da nossa pesquisa com mais de 5.000 profissionais de DevSecOps em todo o mundo](https://about.gitlab.com/developer-survey/2024/security-compliance/) para saber mais sobre como as empresas estão lidando com o aumento das superfícies de ataque e a mudança de atitude em relação à segurança e à IA.",{"text":371,"config":372},"Leia o relatório",{"href":373,"dataGaName":374,"dataGaLocation":375},"/developer-survey/2024/security-compliance/","Application Security in the Digital Age","thesource",{"config":377,"title":378,"link":379},{"slug":24},"Um guia de campo para vetores de ameaças na cadeia de suprimentos de software",{"config":380},{"href":381,"dataGaName":382,"dataGaLocation":375},"/the-source/security/field-guide-to-threat-vectors-in-the-software-supply-chain/","A field guide to threat vectors in the software supply chain",{"config":384,"title":385,"description":386,"link":387},{"slug":23},"Guia do GitLab para SBOMs dinâmicos: um elemento integral do desenvolvimento de software moderno","Saiba como ganhar visibilidade sobre riscos organizacionais não identificados anteriormente com uma lista de materiais de software (SBOM).",{"text":388,"config":389},"Acesse o guia",{"href":390,"dataGaName":391,"dataGaLocation":375},"/the-source/security/guide-to-dynamic-sboms/","Guide to Dynamic SBOMs",{"amanda-rueda":393,"andre-michael-braun":394,"andrew-haschka":395,"ayoub-fandi":396,"brian-wald":397,"bryan-ross":398,"chandler-gibbons":399,"dave-steer":400,"ddesanto":401,"derek-debellis":402,"emilio-salvador":403,"erika-feldman":404,"george-kichukov":405,"gitlab":406,"grant-hickman":407,"haim-snir":408,"iganbaruch":409,"jlongo":410,"joel-krooswyk":411,"josh-lemos":412,"julie-griffin":413,"kristina-weis":414,"lee-faus":415,"ncregan":416,"rschulman":417,"sabrina-farmer":418,"sandra-gittlen":419,"sharon-gaudin":420,"stephen-walters":421,"taylor-mccaslin":422},"Amanda Rueda","Andre Michael Braun","Andrew Haschka","Ayoub Fandi","Brian Wald","Bryan Ross","Chandler Gibbons","Dave Steer","David DeSanto","Derek DeBellis","Emilio Salvador","Erika Feldman","George Kichukov","GitLab","Grant Hickman","Haim Snir","Itzik Gan Baruch","Joseph Longo","Joel Krooswyk","Josh Lemos","Julie Griffin","Kristina Weis","Lee Faus","Niall Cregan","Robin Schulman","Sabrina Farmer","Sandra Gittlen","Sharon Gaudin","Stephen Walters","Taylor McCaslin",{"ai":348,"platform":355,"security":13},[425,451,498,519,539,561,583,624,648],{"id":426,"title":427,"body":6,"category":31,"config":428,"content":433,"description":435,"extension":26,"meta":443,"navigation":28,"path":444,"seo":445,"slug":446,"stem":447,"type":448,"__hash__":449,"date":434,"timeToRead":436,"heroImage":437,"keyTakeaways":450,"articleBody":442},"theSource/pt-br/the-source/security/key-security-trends-for-cisos-in-2025.yml","Principais tendências de segurança para CISOs em 2025",{"layout":8,"template":429,"author":430,"featured":431,"sourceCTA":432,"isHighlighted":431,"authorName":412},"TheSourceArticle","josh-lemos",false,"source-lp-ai-guide-for-enterprise-leaders-building-the-right-approach",{"title":427,"date":434,"description":435,"timeToRead":436,"heroImage":437,"keyTakeaways":438,"articleBody":442},"2025-02-25","Descubra as tendências de segurança para 2025: como a IA cria riscos e oportunidades, transforma o gerenciamento de identidade e fortalece equipes DevOps.","5 min de leitura","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464506/hyue0lgqq2lqk3arwnel.jpg",[439,440,441],"A adoção da IA traz tanto oportunidades quanto riscos de segurança. As empresas precisam monitorar o uso da IA nos produtos dos fornecedores, se preparar para possíveis interrupções e usar a IA para fortalecer os controles de segurança.","É preciso modernizar o gerenciamento de identidade para lidar com interações complexas entre máquinas, permissões dinâmicas e acesso aos sistemas de IA, o que exige ferramentas de segurança mais flexíveis e adaptáveis.","As ferramentas de IA podem ajudar a suprir a falta de habilidades em segurança no DevOps, automatizando verificações de segurança, sugerindo padrões de código seguro e integrando a segurança em todo o ciclo de vida do desenvolvimento de software.","Em 2025, muitas das suas ferramentas essenciais de segurança incluirão modelos de IA que não poderão ser inspecionados ou totalmente controlados. A diretoria da sua empresa que saber desde já o que você fará para evitar a próxima violação de segurança de grande repercussão. Enquanto isso, seus concorrentes estão usando a IA para automatizar a segurança em uma escala que era impossível há poucos meses. A evolução dos requisitos regulatórios traz uma camada extra de complexidade, pois as novas regras da União Europeia e da Califórnia impactam a forma como você pode usar os sistemas de IA.\n\nO cenário de segurança está mudando rapidamente, mas, com a abordagem certa, você pode transformar esses desafios em oportunidades para fortalecer as defesas e, ao mesmo tempo, se proteger contra novas ameaças cibernéticas. Confira três tendências que dominarão o cenário de segurança empresarial este ano.\n\n## 1. Vulnerabilidades em LLMs proprietários\nMuitos fornecedores agora usam os próprios modelos de linguagem de grande porte (LLMs) em seus produtos, criando novos riscos para a sua empresa. A maioria desses LLMs funciona como caixas-pretas: não é possível entender bem como operam ou quais controles de segurança possuem. Pesquisadores de segurança têm demonstrado a fragilidade dos verificadores de integridade de IA. Há um aumento na superfície de ataque dos próprios modelos e, consequentemente, nos produtos que os utilizam.\n\nComo vários produtos dependem dos poucos LLMs proprietários, quando um deles sofre um ataque, muitos dos seus sistemas podem ser afetados. Essa concentração de riscos é preocupante, pois cada vez mais funções empresariais críticas dependem de ferramentas com IA. Para se proteger, você precisará:\n\n- Identificar quais de seus fornecedores usam LLMs\n- Avaliar os controles de segurança implementados por esses fornecedores\n- Planejar-se para eventuais interrupções caso um serviço baseado em LLM sofra falhas\n- Desenvolver planos de contingência para sistemas críticos que dependem de IA\n\n> Leia mais: [Sete perguntas para fazer ao seu provedor de DevOps para criar uma estratégia de IA que priorize a transparência](https://about.gitlab.com/the-source/ai/building-a-transparency-first-ai-strategy-7-questions-to-ask-your-devops/)\n\n## 2. Desafios no gerenciamento de identidade\nOs sistemas de nuvem e de IA estão mudando a maneira como gerenciamos o acesso aos sistemas que usamos diariamente. Agora, seus sistemas de identidade precisam lidar com:\n\n- Um aumento nas identidades não humanas baseadas em serviços\n- Mais conexões entre máquinas (machine to machine)\n- Mudanças rápidas nas atribuições de acesso\n- Cadeias complexas de permissões entre serviços\n- Sistemas de IA que precisam de diferentes níveis de acesso a dados\n\nAs ferramentas tradicionais de gerenciamento de identidade e acesso não foram projetadas para enfrentar esses desafios. Você precisará de ferramentas de identidade mais flexíveis, que se adaptam rapidamente à medida que suas necessidades mudam. Considere implementar [princípios de Zero Trust e acesso just-in-time](https://about.gitlab.com/the-source/security/field-guide-to-threat-vectors-in-the-software-supply-chain/) para ter maior controle sobre esses ambientes dinâmicos.\n\nAs equipes de segurança também devem desenvolver estratégias e se preparar para a crescente complexidade da IA agêntica, aplicando o mesmo nível de rigor e auditabilidade exigido para os usuários humanos. Com a proliferação dos sistemas de IA, [rastrear e proteger essas identidades não humanas](https://about.gitlab.com/blog/improve-ai-security-in-gitlab-with-composite-identities/) torna-se tão importante quanto gerenciar o acesso de usuários humanos.\n\n## 3. Fazer a segurança funcionar no DevOps\n[Em uma pesquisa recente](https://about.gitlab.com/developer-survey/), 58% dos desenvolvedores afirmaram sentir algum grau de responsabilidade pela segurança das aplicações. No entanto, ainda é difícil encontrar profissionais de DevOps com as habilidades de segurança necessárias. As ferramentas com tecnologia de IA podem ajudar a:\n\n- Verificar o código em busca de vulnerabilidades e ameaças de segurança desde o início da fase de desenvolvimento, antes que causem problemas\n- Sugerir padrões de codificação seguros\n- Configurar automaticamente as permissões de acesso corretas\n- Automatizar tarefas repetitivas ao longo do processo de desenvolvimento\n\nEssas ferramentas podem ajudar sua equipe de segurança a trabalhar com mais eficiência. Elas também permitem que os desenvolvedores identifiquem problemas comuns de segurança antes que o código chegue à produção. Isso resulta em menos situações de emergência para sua equipe e melhores resultados em termos de segurança.\n\nConsidere investir em ferramentas que se integram diretamente aos fluxos de trabalho dos desenvolvedores. Quanto mais fácil for para os desenvolvedores trabalharem com segurança, mais provável será que eles o façam.\n\n## Entre em ação: use a IA para se proteger contra ameaças\nPara ficar à frente dessas mudanças:\n\n1. Mapeie os pontos de contato das ferramentas de IA com seus sistemas e avalie os riscos envolvidos\n1. Atualize sua abordagem ao gerenciamento de identidade para atender às necessidades da nuvem e da IA\n1. Descubra maneiras como a IA pode fortalecer suas práticas de segurança\n1. Mantenha a diretoria da sua empresa informada sobre os novos riscos e regulamentações relacionadas à IA\n1. Estabeleça relações com os principais fornecedores para entender suas medidas de segurança em IA\n1. Capacite sua equipe sobre as oportunidades e os riscos de segurança envolvendo a IA\n\nEmbora a IA traga novos riscos, ela também oferece novas ferramentas para proteger sua empresa. Concentre-se em usar a IA para fortalecer sua postura de segurança, sem perder de vista as novas ameaças. Revisões regulares da postura de segurança de IA ajudarão você a se manter à frente dos riscos emergentes.\n\n## De olho no futuro\nO cenário de segurança continuará evoluindo à medida que a tecnologia de IA avança. Mantenha-se flexível e prepare-se para adaptar sua estratégia de segurança conforme surgem novas ameaças e oportunidades. Construa relacionamentos fortes em toda a sua empresa, especialmente com as equipes jurídica, de desenvolvimento e de operações. Essas parcerias ajudarão você a enfrentar os desafios de segurança com mais eficácia.\n\nLembre-se de que, embora a tecnologia mude, sua missão principal permanece a mesma: proteger os ativos da empresa e garantir a segurança das operações comerciais. Use novas ferramentas e abordagens onde elas fizerem sentido, mas não deixe de lado os princípios de segurança na pressa de adotar a IA.",{},"/pt-br/the-source/security/key-security-trends-for-cisos-in-2025",{"title":427,"description":435,"ogImage":437},"key-security-trends-for-cisos-in-2025","pt-br/the-source/security/key-security-trends-for-cisos-in-2025","article","bK4tLwbrG2968mI27yVd-SE3xXMCaCvYXS-G6Hjkhqw",[439,440,441],{"id":452,"title":453,"body":6,"category":31,"config":454,"content":457,"description":459,"extension":26,"meta":483,"navigation":28,"path":484,"seo":485,"slug":488,"stem":489,"type":448,"__hash__":490,"heroImage":458,"timeToRead":460,"date":461,"articleBody":462,"keyTakeaways":491,"faq":492},"theSource/pt-br/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help.yml","Por que o código legado compromete a segurança e como a IA pode ajudar a resolver o problema",{"layout":8,"template":429,"featured":431,"author":455,"sourceCTA":456,"isHighlighted":431,"authorName":411},"joel-krooswyk","source-lp-how-a-devsecops-platform-drives-business-success-the-complete-guide",{"heroImage":458,"title":453,"description":459,"timeToRead":460,"date":461,"articleBody":462,"keyTakeaways":463,"faq":467},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463670/cdynzww9p2annh3mmbhl.png","Descubra como a refatoração de código com tecnologia de IA pode modernizar sistemas legados, aprimorar seus protocolos de segurança e alinhar sua empresa às demandas do futuro.","6 min de leitura","2025-01-15T00:00:00.000Z","O ritmo acelerado da tecnologia de hoje é incrível. Isso significa que novos produtos e oportunidades de crescimento e inovação estão por toda parte. Mas essa velocidade de crescimento e transformação também traz desafios, especialmente em relação à segurança: basta um agente mal-intencionado para causar grandes interrupções nos negócios, danos à reputação e perda de receita.\n\nVocê provavelmente já ouviu líderes do setor falarem sobre a necessidade de transformação digital e a preocupante dependência de sistemas desatualizados ou \"legados\". Embora o código legado não seja problemático por natureza, ele geralmente não é compatível com as ferramentas de segurança modernas, o que pode resultar em vulnerabilidades exploráveis. Somado ao uso de código aberto, que exige atenção constante à segurança, sua base de código pode estar colocando em risco os dados da sua empresa, seus usuários e sua reputação.\n\nDo ponto de vista da segurança e da conformidade, o código legado representa riscos. Mantê-lo também é caro e demorado, especialmente se a equipe já não conta com desenvolvedores que dominam esse conhecimento antigo.\n\nNo fim das contas, essa dependência generalizada de código legado no setor é uma prática preocupante e onerosa. Então, como sair desse cenário?\n\nA seguir, vamos explorar o que é código legado e como as empresas podem aumentar a segurança do codebase com refatoração de código com tecnologia de IA. Combinada a recursos de testes e segurança orientados por IA, essa estratégia prepara seu codebase para o futuro e oferece à sua equipe inteira a confiança necessária para focar no que vem pela frente.\n\n## O que é código legado?\n\nDe forma geral, código legado se refere a um codebase atual herdado de membros anteriores da equipe e que continua sendo utilizado e mantido. O código pode até funcionar bem, mas é provável que diversos desenvolvedores o tenham modificado ao longo dos anos. A equipe atual pode ter dificuldade para identificar quais modificações são valiosas e quais não são. Além disso, o código pode ter sido escrito em uma estrutura desatualizada ou em uma linguagem de programação que ninguém da equipe conhece (seja por ser apenas antiga ou completamente obsoleta).\n\nPode parecer estranho que as empresas ainda dependam de código legado. Embora os motivos variem, pense da seguinte forma: você mora em uma casa antiga. Ela é aconchegante e familiar, mas o encanamento é instável, a fiação está ultrapassada e, sempre que você conserta uma coisa, outra quebra. Claro, você poderia reformá-la, mas isso significaria um trabalho enorme: empreiteiros, licenças, meses vivendo em meio ao caos e custos que podem sair do controle.\n\nEntão, você continua fazendo remendos, torcendo pelo melhor. Não é o ideal, mas funciona, por enquanto. É mais ou menos assim com o código legado. É a solução conhecida e \"funcional\", mesmo que seja instável e ineficiente. Reescrevê-lo do zero é uma perspectiva assustadora, com seus próprios riscos e custos. Além disso, quem tem tempo para uma reformulação completa quando há novos recursos a desenvolver e bugs urgentes para corrigir?\n\nAo atualizar o código, muitas empresas optam por manter o código legado porque isso costuma ser menos disruptivo no curto prazo. Uma atualização exige muito trabalho de desenvolvimento e testes. Também pode envolver o treinamento de equipes para garantir que tenham as habilidades necessárias para processar a linguagem de código ou a estrutura desatualizada. Quando não há documentação, navegar por esse processo pode ser ainda mais desafiador.\n\n## Qual é o problema do código legado?\n\nSe a sua empresa decidir manter o código legado, como muitas fazem, estará se expondo a uma série de possíveis problemas. Como esse código não foi projetado para tecnologias mais recentes, talvez ele não seja compatível com tipos de software mais modernos (como ferramentas de IA, por exemplo), o que pode impactar o desempenho e a capacidade de ajuste de escala dos seus produtos. Isso pode gerar atrasos e prejudicar a experiência do usuário no futuro.\n\nO que mais preocupa em relação ao código legado, seja ele de cinco ou 50 anos atrás, é que talvez não existam scanners de segurança compatíveis com ele. Isso significa que você não conseguirá detectar falhas por conta própria ao fazer atualizações. Além disso, os desenvolvedores responsáveis por essas atualizações podem não conhecer bem a linguagem ou sua estrutura e, sem querer, acabar criando ainda mais vulnerabilidades no processo. Por fim, aplicações mais antigas costumam ser escritas em C ou C++, linguagens inseguras em relação à memória, responsáveis por cerca de [70% das vulnerabilidades identificadas]( https://www.cisa.gov/news-events/news/urgent-need-memory-safety-software-products ).\n\nEsses três fatores (a dificuldade em proteger o código legado, as poucas opções seguras de atualização e o maior risco de vulnerabilidades) devem ser encarados como sinais de alerta para empresas de todos os setores.\n\nAo desenvolver um catálogo de práticas prejudiciais que colocam em risco a infraestrutura crítica, a [Agência de Segurança Cibernética e de Infraestrutura]( https://www.cisa.gov/stopransomware/bad-practices ) dos EUA incluiu a seguinte observação:\n\n“O uso de software descontinuado (ou fora do ciclo de vida) em serviços relacionados à infraestrutura crítica e às funções nacionais essenciais é perigoso e eleva significativamente o risco à segurança nacional, à segurança econômica nacional e à saúde e segurança públicas. Essa prática é especialmente grave em tecnologias acessíveis pela internet”.\n\nMesmo que você não atue com segurança nacional ou saúde pública, esse alerta continua válido: usar código antigo não é uma prática recomendada. É uma escolha ruim.\n\n## A solução: refatoração de código\n\nDe acordo com o desenvolvedor e autor de software [Martin Fowler]( https://www.martinfowler.com/ ), “Refatoração é uma técnica controlada para melhorar o design de um codebase atual, uma técnica disciplinada para reestruturar um corpo de código, alterando sua estrutura interna sem modificar seu comportamento externo”.\n\nEm outras palavras, a refatoração de código permite modernizar e proteger o código legado sem comprometer sua funcionalidade original.\n\nExistem várias técnicas de refatoração, como a refatoração inline, que simplifica o código ao remover elementos obsoletos, e a refatoração por abstração, que elimina trechos duplicados. O importante é saber que a refatoração de código exige tempo e um alto nível de conhecimento técnico por parte da equipe de desenvolvimento. Além disso, demanda muitos testes, o que pode ser um desafio quando a equipe já está ocupada com outras tarefas.\n\nPortanto, embora a refatoração de código seja, sem dúvida, o caminho para tornar seu código legado mais legível, eficiente e seguro, trata-se de um projeto por si só, especialmente quando aplicado em grande escala.\n\n## Como a IA pode ajudar\n\nSabemos que a IA já está acelerando o ciclo de vida do desenvolvimento de software. E [ela também pode ser uma grande aliada para acelerar o processo de refatoração]( https://about.gitlab.com/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/). Por exemplo, ferramentas como o [GitLab Duo](https://about.gitlab.com/blog/gitlab-duo-chat-now-generally-available/) ajudam a explicar o código atual e a criar novos trechos de código, dois dos maiores obstáculos ao modernizar o codebase legado. Se um desenvolvedor não estiver familiarizado com determinada linguagem, a IA poderá preencher essas lacunas. Em relação a testes e segurança, a IA também pode [analisar as causas raiz, gerar testes](https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) e [ajudar os desenvolvedores a remediar vulnerabilidades](https://about.gitlab.com/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/). Com IA no seu conjunto de ferramentas, a refatoração de código finalmente se torna mais viável e acessível, permitindo que esse projeto saia do backlog de uma vez por todas.\n\nDe acordo com [nossa pesquisa](https://about.gitlab.com/developer-survey/2024/ai/), 34% dos participantes que usam IA no ciclo de vida do desenvolvimento de software já a utilizam para modernizar código legado. No setor de serviços financeiros, esse número sobe para 46%.\n\nClaro que, ao começar a usar a IA em qualquer etapa do processo, é importante considerar alguns pontos.\n\nA IA não é perfeita. Ela ainda exige testes, parâmetros e supervisão humana. Ou seja, embora consiga facilitar e acelerar tarefas manuais críticas e demoradas, não pode realizar esse trabalho sozinha. Principalmente no que diz respeito à segurança, é essencial adotar outras ferramentas para manter seu código o mais protegido possível. Recomendamos a criação de uma [lista de materiais de software dinâmica]( https://about.gitlab.com/blog/the-ultimate-guide-to-sboms/) (ou SBOM) para ter visibilidade total sobre riscos de licenças e segurança relacionados ao seu software, inclusive o código legado.\n\n## Transforme seu codebase em uma base segura para o futuro\n\nEmbora modernizar o codebase legado possa parecer uma tarefa assustadora, esse é o melhor caminho se você quiser manter os dados da sua empresa e dos usuários em segurança. Com as ferramentas e métodos certos, essa jornada pode ser mais eficiente para as equipes e mais econômica para a empresa.\n\nA boa notícia é que suas equipes não precisam gastar tempo e recursos tentando decifrar linguagens antigas ou lidar com estruturas obsoletas, o que costuma gerar frustração, atrasos e gargalos. Ao deixar que a IA assuma o trabalho pesado de refatorar o código, garantindo que ele esteja seguro e funcionando como deve, os desenvolvedores podem se concentrar no que fazem de melhor: criar novos produtos e recursos, além de gerar valor para os clientes.",[464,465,466],"Manter código legado é caro, consome tempo e, quando incompatível com as ferramentas de segurança mais recentes, pode representar um risco sério para empresas de diversos setores.","A refatoração de código é uma estratégia que ajuda a torná-lo mais legível, aumentando a estabilidade do codebase, bem como a produtividade e eficiência dos desenvolvedores.","Combinada a ferramentas de segurança preventiva, a refatoração de código com tecnologia de IA ajuda as equipes a modernizar código legado e, ao mesmo tempo, reduzir o risco de vulnerabilidades de segurança.",[468,471,474,477,480],{"header":469,"content":470},"Por que o código legado é considerado um risco à segurança?","O código legado representa um risco porque, muitas vezes, utiliza estruturas ou linguagens de programação obsoletas, sem as proteções modernas contra ameaças. Isso o torna incompatível com as ferramentas de segurança atuais, o que aumenta a chance de vulnerabilidades. Além disso, softwares descontinuados ou fora de ciclo de vida são mais fáceis de explorar por agentes mal-intencionados, comprometendo a integridade e a segurança dos dados.",{"header":472,"content":473},"Como a refatoração de código com tecnologia de IA pode aumentar a segurança do código legado?","A refatoração com IA moderniza sistemas legados ao:\n - Identificar padrões de código desatualizados ou inseguros e sugerir alternativas mais seguras\n - Automatizar melhorias no código sem alterar seu comportamento externo, o que facilita a leitura e a capacidade de manutenção\n - Gerar testes de segurança e analisar as causas de vulnerabilidades, acelerando a correção de falhas\nEssa abordagem reduz o esforço manual e agiliza a transição para um codebase mais seguro, eficiente e dimensionável.",{"header":475,"content":476},"Quais são os desafios de manter código legado sem o uso de IA?","Alguns dos principais desafios incluem:\n - __Incompatibilidade com práticas modernas de segurança__: os scanners de segurança tradicionais nem sempre são compatíveis com o código legado\n - __Estruturas complexas e desatualizadas__: as equipes de desenvolvedores podem não ter o conhecimento necessário para manter ou atualizar código legado\n - __Altos custos de manutenção__: o tempo e os recursos gastos com sistemas legados desviam o foco da inovação\n - __Riscos à segurança__: códigos desatualizados estão mais sujeitos a vulnerabilidades e ataques, aumentando o risco de violação de dados",{"header":478,"content":479},"Como o GitLab contribui para a modernização de código legado com refatoração baseada em IA?","O GitLab usa o GitLab Duo para ajudar desenvolvedores a compreenderem o código legado, oferecendo explicações e gerando novos trechos de código. A plataforma também inclui:\n - Análises de segurança orientadas por IA para identificar vulnerabilidades em código legado\n - Testes e correções automatizados para reforçar a segurança do código\n - Criação de listas de materiais de software (SBOMs) dinâmicas que oferecem visibilidade sobre riscos de licenças e segurança, inclusive em componentes legados",{"header":481,"content":482},"Quais são os benefícios de usar IA na refatoração de código legado?","Os benefícios incluem:\n - __Mais segurança__: a IA identifica e corrige vulnerabilidades, fortalecendo a proteção do codebase\n - __Maior produtividade__: a automatização de tarefas repetitivas permite que os desenvolvedores possam se concentrar em inovação\n - __Redução de custos__: a modernização do código diminui os custos de manutenção ao torná-lo compatível com estruturas e ferramentas atuais\n - __Modernização em grande escala__: a IA permite uma refatoração uniforme e dimensionável, garantindo o futuro dos ativos de software da empresa",{},"/pt-br/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help",{"title":486,"ogTitle":486,"description":487,"ogDescription":487,"ogImage":458,"noIndex":28},"Como a IA resolve problemas de segurança do código legado","Descubra como a refatoração de código com tecnologia de IA pode modernizar sistemas legados, reforçar a segurança e preparar sua empresa para o futuro.","why-legacy-code-is-a-security-risk-and-how-ai-can-help","pt-br/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help","-AFRnqlvg73f1JAsZ6R_Uokq6qghoUnX7ErKREzf7DM",[464,465,466],[493,494,495,496,497],{"header":469,"content":470},{"header":472,"content":473},{"header":475,"content":476},{"header":478,"content":479},{"header":481,"content":482},{"id":499,"title":500,"body":6,"category":31,"config":501,"content":502,"description":504,"extension":26,"meta":511,"navigation":28,"path":512,"seo":513,"slug":515,"stem":516,"type":448,"__hash__":517,"date":503,"timeToRead":436,"heroImage":505,"keyTakeaways":518,"articleBody":510},"theSource/pt-br/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security.yml","Como abordar a causa raiz de problemas de segurança comuns",{"layout":8,"template":429,"author":430,"featured":28,"sourceCTA":25,"isHighlighted":431,"authorName":412},{"title":500,"date":503,"description":504,"timeToRead":436,"heroImage":505,"keyTakeaways":506,"articleBody":510},"2024-10-29","Frequentemente, os problemas de segurança são percebidos como uma questão da cultura empresarial, mas os líderes também devem focar na complexidade da pilha tecnológica e no gerenciamento de vulnerabilidades.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464489/mragusmxl1wz8ozdaoml.png",[507,508,509],"A mudança para a análise autenticada na gestão de vulnerabilidades aumenta a eficácia, mas pode desviar os esforços de engenharia para tarefas não essenciais, criando uma divisão entre as equipes de segurança e engenharia.","Uma abordagem minimalista para o desenvolvimento de software pode minimizar dependências, reduzir alarmes falsos gerados pelas análises e diminuir a carga do desenvolvedor, contribuindo para melhorar a segurança do software.","Adotar padrões de design comprovados e seguros baseados em casos de uso replicáveis pode reduzir a carga de trabalho das equipes técnicas e aumentar a segurança.","Este ano, a [pesquisa anual de profissionais de DevSecOps](https://about.gitlab.com/developer-survey/) do GitLab revelou vários problemas relacionados à cultura organizacional que podem estar impedindo um alinhamento mais profundo entre as equipes de engenharia e segurança. A maioria (58%) dos entrevistados do setor de segurança disse que tem dificuldade em fazer a equipe de desenvolvimento priorizar a correção de vulnerabilidades, e 52% relataram que a burocracia muitas vezes retarda seus esforços para corrigir vulnerabilidades rapidamente. Além disso, os entrevistados do setor de segurança apontaram várias frustrações específicas relacionadas ao seu trabalho, incluindo dificuldade em entender as descobertas de segurança, excesso de falsos positivos e testes que acontecem no final do processo de desenvolvimento de software.\n\nO [DevSecOps](/topics/devsecops/) promete uma melhor integração entre engenharia e segurança, mas é claro que as frustrações e as diferenças persistem. Essa questão é um sintoma de um problema maior relacionado com a forma como as empresas percebem a segurança, como as equipes colaboram e quanto tempo dedicam a ela.\n\n## Saindo do ciclo vicioso das vulnerabilidades\n\nA análise de vulnerabilidades identifica todas as possíveis falhas. No entanto, o fato de um pacote de software ter uma vulnerabilidade ou exposição comum (CVE) não significa que ela seja acessível ou explorável. Equipes de segurança e desenvolvedores ainda estão filtrando e analisando vulnerabilidades, que cresceram exponencialmente ao longo dos anos, desde que a análise autenticada de vulnerabilidades se tornou padrão.\n\nA transição para a análise autenticada melhorou a eficácia dos programas de segurança de várias maneiras, mas também colocou os desenvolvedores em um ciclo interminável de consertar elementos irrelevantes. Quando as equipes desperdiçam esforços em  correções que não resolvem uma vulnerabilidade explorável, elas deixam de fazer tarefas mais críticas, como corrigir falhas vulneráveis e exploráveis. Essa é a origem de grande parte da divisão entre as equipes de segurança e engenharia hoje.\n\nEntão, como as empresas podem abordar a causa raiz desses problemas e promover uma melhor integração entre engenharia e segurança? Aqui estão três maneiras de evitar frustrações comuns de segurança desde o princípio.\n\n### 1. Reduza o ruído e foque em sinais de alta precisão e ação prática\n\nO excesso de falsos positivos foi a segunda maior frustração apontada pelos profissionais de segurança na nossa pesquisa. Falsos positivos são claramente um desafio, mas muitas vezes são um problema de gerenciamento de vulnerabilidades disfarçado.\n\nSe uma empresa obtiver muitos falsos positivos, isso pode ser um sinal de que ainda não fizeram tudo o que poderiam para garantir que suas descobertas de segurança sejam de alta precisão. As empresas devem concentrar seus esforços de segurança no que realmente importa. Isso significa que as soluções tradicionais de Teste Estático de Segurança de Aplicações (SAST) provavelmente são insuficientes. O SAST é uma ferramenta poderosa, mas perde muito do seu valor se os resultados não forem gerenciáveis ou não tiverem o contexto apropriado. Para que o SAST seja mais eficaz, ele deve ser usado [de forma integrada com outras ferramentas de segurança e desenvolvimento e estar acessível aos desenvolvedores](https://about.gitlab.com/blog/oxeye-joins-gitlab-to-advance-application-security-capabilities/).\n\nOutro problema é que a maioria das ferramentas de análise tem uma visão muito limitada do contexto ao interpretar as descobertas de vulnerabilidades. Esta é uma das áreas em que a IA pode ajudar usando [recursos com tecnologia de IA que explicam vulnerabilidades de segurança](https://about.gitlab.com/pt-br/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/).\n\n### 2. Minimize a pilha de tecnologia, minimize a superfície de ataque\n\nManter o foco no que é importante não se aplica apenas aos testes de segurança: deve começar com a forma como uma empresa cria software.\n\nEmbora a IA prometa ajudar a simplificar os processos de desenvolvimento de software, [nossa pesquisa sugere que muitas empresas ainda têm um longo caminho pela frente](https://about.gitlab.com/the-source/platform/3-surprising-findings-from-our-2024-global-devsecops-survey/). Na verdade, os participantes que usam IA demonstraram uma probabilidade significativamente maior, em comparação com aqueles que não usam IA, de querer consolidar sua cadeia de ferramentas. Isso sugere que a proliferação de diferentes soluções pontuais com modelos de IA distintos pode estar aumentando a complexidade, em vez de reduzi-la.\n\nA complexidade cada vez maior das pilhas de tecnologia das empresas é um dos principais fatores que contribuem para os problemas de segurança. Algum nível de complexidade é inevitável ao construir sistemas de software grandes e multifacetados. No entanto, as empresas devem tomar medidas para evitar a complexidade causada por decisões de design inadequadas, como código difícil de manter e dependências redundantes. Essa complexidade desnecessária aumenta a superfície de ataque e gera mais resultados nas análises de segurança, exigindo que as equipes os classifiquem, priorizem e resolvam.\n\nAs empresas devem abordar o desenvolvimento com a perspectiva de minimização de software, ou seja, sendo intencionais em relação às ferramentas que adotam e ao que decidem incluir em seus codebases. Isso ajudará a minimizar as dependências, melhorar a segurança da cadeia de suprimentos de software, reduzir o ruído das análises e diminuir o trabalho dos desenvolvedores na correção de problemas não críticos.\n\n### 3. Normalize os caminhos otimizados\n\nA realização tardia de testes de segurança no ciclo de vida do desenvolvimento de software foi outra das principais frustrações apontadas pelos participantes da nossa pesquisa. As equipes podem se sentir frustradas quando querem lançar algo e o processo é atrasado porque uma vulnerabilidade foi detectada tardiamente. Porém, em muitos casos, pode não ter sido possível detectar essa vulnerabilidade antes. O que é possível, no entanto, é operacionalizar componentes de segurança facilmente implantáveis e reutilizáveis, limitando as variáveis e possíveis vulnerabilidades.\n\nAs equipes podem evitar surpresas em estágios mais avançados adotando [padrões de design testados e comprovados com base em casos de uso replicáveis](https://about.gitlab.com/the-source/platform/how-devops-and-platform-engineering-turbocharge-efficiency/): a abordagem de \"caminhos otimizados\". Um caminho otimizado é uma rota recomendada, que inclui um conjunto de ferramentas, processos e componentes selecionados que as equipes podem seguir para construir aplicações seguras de forma mais eficiente. Por exemplo, usando GitOps para versionar e implantar uma Infraestrutura como Código bem arquitetada e testada, dimensionável para todas as cargas de trabalho.\n\nA adoção de caminhos otimizados pode remover um pouco da flexibilidade, mas, em última análise, reduz o trabalho operacional e o retrabalho das equipes de engenharia e aumenta a segurança. Isso precisa ser um esforço colaborativo entre segurança e desenvolvimento. A segurança pode ajudar a projetar caminhos otimizados, mas a engenharia precisa estar envolvida para operá-los e mantê-los como parte do codebase.\n\n## A segurança é um domínio, não uma equipe{class=\"no-anchor\"}\n\nJá estamos observando a segurança como uma prática sendo incorporada nas equipes de engenharia, e podemos esperar que os limites entre as duas continuem a se tornar mais indefinidos. No entanto, com a rápida adoção da IA e a aceleração correspondente no desenvolvimento de software, 66% dos participantes da nossa pesquisa afirmaram que estão lançando software duas vezes mais rápido ou até mais do que no ano passado. Será fundamental que as empresas estabeleçam sistemas e estruturas que otimizem o máximo benefício em termos de segurança. É por isso que resolver a desconexão cultural entre desenvolvimento e segurança não resolve todo o problema. Promover uma cultura de colaboração é essencial, mas as equipes de segurança e engenharia também devem trabalhar juntas para repensar os aspectos fundamentais do desenvolvimento de software, como otimizar as bases de código atuais e criar soluções focadas na engenharia que possam ser dimensionadas e adotadas de forma transparente por equipes técnicas de toda a empresa.",{},"/pt-br/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security",{"title":500,"description":514,"ogImage":505},"Problemas de segurança são vistos como questão cultural, mas líderes também devem focar na complexidade da pilha tecnológica e na gestão de vulnerabilidades.","security-its-more-than-culture-addressing-the-root-cause-of-common-security","pt-br/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security","VtSzpOzdvE5v_AXJAh0pd-WyTP2Wut6jd1IUprX3xvA",[507,508,509],{"id":520,"title":521,"body":6,"category":31,"config":522,"content":523,"description":524,"extension":26,"meta":531,"navigation":28,"path":532,"seo":533,"slug":535,"stem":536,"type":448,"__hash__":537,"date":503,"timeToRead":460,"heroImage":525,"keyTakeaways":538,"articleBody":530},"theSource/pt-br/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design.yml","Fortaleça sua estratégia de cibersegurança com o Seguro por Design",{"layout":8,"template":429,"author":455,"featured":431,"sourceCTA":23,"isHighlighted":431,"authorName":411},{"title":521,"date":503,"description":524,"timeToRead":460,"heroImage":525,"keyTakeaways":526,"articleBody":530},"Saiba mais sobre o Seguro por Design, conceitos relacionados e quais etapas seguir para integrar a segurança nos processos de desenvolvimento de software.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463932/pnfdgovoaq5qd1yprxuc.png",[527,528,529],"Seguro por Design, Seguro por Padrão e Seguro por Demanda evitam vulnerabilidades e ataques à cadeia de suprimentos de software, incentivando fabricantes a incorporar segurança em todas as etapas do design e desenvolvimento de produtos.","Adotar uma abordagem abrangente de DevSecOps e criar e manter listas de materiais de software (SBOMs) são etapas essenciais para seguir os princípios de Seguro por Design.","Incorporar a IA ao ciclo de vida do desenvolvimento de software também pode agilizar os processos de desenvolvimento, aprimorar a segurança e ajudar na resolução de vulnerabilidades.","A abordagem de cibersegurança de uma empresa deve evoluir constantemente conforme as superfícies de ataque aumentam e sabe-se mais sobre possíveis ameaças. Ao compreender que as ameaças podem entrar em qualquer ponto da cadeia de suprimentos de software, uma abordagem com princípios de Seguro por Design integra segurança nas fases de design, programação, teste e implantação do desenvolvimento de software. Sendo este o padrão para agências federais nos EUA (e qualquer empresa que tenha contato com os softwares que elas usam), os princípios do Seguro por Design se tornaram um benchmark imprescindível para incorporar a segurança ao ciclo de vida do desenvolvimento de software.\n\nCom o tempo, o Seguro por Design se ramificou em conceitos relacionados, como _Seguro por Padrão_ e _Seguro por Demanda_, que focam em diferentes maneiras de abordar o Seguro por Design:\n\n- [Seguro por Padrão](#o-que-é-seguro-por-padrão) se concentra em garantir que todos os produtos de software sejam seguros quando estão prontos para uso.\n- [Seguro por Demanda](#o-que-é-seguro-por-demanda) estende os princípios de Seguro por Design ao processo de aquisição.\n\nSaiba mais sobre o Seguro por Design e essas abordagens relacionadas, incluindo um [guia passo a passo](#como-criar-uma-estratégia-de-cibersegurança-com-princípios-de-seguro-por-design) sobre como as empresas podem adaptar suas estratégias para evitar vulnerabilidades exploráveis e ataques à cadeia de suprimentos de software.\n\n## O que é o Seguro por Design?\nA Agência de Segurança Cibernética e de Infraestrutura dos EUA (CISA) apresentou sua [Iniciativa Seguro por Design](https://www.cisa.gov/securebydesign) em abril de 2023, com foco em três princípios fundamentais de segurança de software:\n\n1. Assumir a propriedade dos resultados de segurança do cliente\n1. Adotar transparência e responsabilidade radicais\n1. Construir a estrutura organizacional e a liderança para atingir esses objetivos\n\nO Seguro por Design integra princípios e protocolos de segurança em todas as etapas do processo de desenvolvimento de software. Isso significa que as medidas de segurança são incorporadas nas fases de design, programação, teste e implantação do desenvolvimento de software, em vez de serem adicionadas posteriormente.\n\nO objetivo do Seguro por Design é criar uma base segura para o software desde o princípio, reduzindo vulnerabilidades e possíveis superfícies de ataque.\n\n### O que é o Seguro por Padrão?\nSeguro por Padrão é um desdobramento do Seguro por Design que se concentra em garantir que qualquer software ou hardware esteja definido com a configuração mais segura sem exigir que o usuário faça sua reconfiguração. Os produtos que adotam os princípios do Seguro por Padrão ativam automaticamente os controles de segurança mais importantes necessários para proteger as empresas do acesso não autorizado de agentes mal-intencionados. Ou seja, os usuários não precisam executar outras etapas para garantir que o produto esteja protegido contra técnicas de exploração predominantes.\n\nAs táticas de Seguro por Padrão incluem eliminar senhas padrão e exigir autenticação multifator e logon único para que apenas usuários autorizados tenham acesso aos recursos. Essa abordagem também inclui atualizações e patches automáticos, assim como configurações seguras para todos os dispositivos e todas as contas do usuário.\n\n### O que é o Seguro por Demanda?\nSeguro por Demanda combina os princípios de Seguro por Design com contratos de orçamento e aquisição com o objetivo de impulsionar o Seguro por Design como uma exigência para fornecedores e terceirizados. O [Guia Seguro por Demanda da CISA](https://www.cisa.gov/resources-tools/resources/secure-demand-guide) fornece respostas e recursos que os compradores de software podem usar para entender melhor a abordagem de cibersegurança de um possível fornecedor. Ele inclui dúvidas sobre práticas de autenticação do fornecedor, segurança da cadeia de suprimentos de software e relatórios e divulgação de vulnerabilidades.\n\nAo exigir que os fornecedores sigam os princípios e protocolos de Seguro por Design em seus produtos e serviços, as empresas podem evitar que possíveis vulnerabilidades entrem em sua cadeia de suprimentos de software. A abordagem Seguro por Demanda também incentiva ainda mais os fornecedores a melhorar continuamente sua própria abordagem de cibersegurança.\n\n## Como construir uma estratégia de cibersegurança com os princípios do Seguro por Design\nConforme as empresas priorizam o Seguro por Design, as etapas incluem a utilização de práticas eficazes de DevSecOps, a manutenção de uma lista de materiais de software (SBOM) e a incorporação da IA para se defender contra ameaças que podem entrar em qualquer ponto do ciclo de vida do desenvolvimento de software.\n\n### Adoção de práticas de DevSecOps\nUm dos primeiros passos para dar sustentação a uma postura de Seguro por Design é ter um processo de desenvolvimento de software seguro: desenvolver, compilar, proteger e implantar software usando uma abordagem abrangente de DevSecOps.\n\nHoje em dia, muitos desenvolvedores utilizam conjuntos de ferramentas complexos para criar novos programas. Uma [pesquisa recente do GitLab](https://about.gitlab.com/developer-survey/) mostra que 62% dos participantes usam seis ou mais ferramentas de desenvolvimento e 20% usam 11 ou mais. Essa prática ineficiente aumenta os riscos de entrada de possíveis vulnerabilidades de segurança.\n\nOs desenvolvedores devem ter acesso a todas as ferramentas necessárias para os fluxos de trabalho do DevSecOps em uma única interface fácil de usar. Utilizando uma solução de ponta a ponta, como uma [plataforma DevSecOps](/platform/), as empresas podem implementar uma abordagem de Seguro por Design sem aumentar a carga dos desenvolvedores.\n\n### Como criar e manter SBOMs\nAdotar a transparência é outra parte significativa da integração dos princípios de Seguro por Design. As empresas devem entender o que compõe seu software, especialmente quando podem haver componentes de várias fontes.\n\n[SBOMs são ferramentas essenciais para alcançar essa transparência](https://about.gitlab.com/blog/the-ultimate-guide-to-sboms/). Essas ferramentas oferecem inventários detalhados de componentes de software, incluindo detalhes de versão, licença e dependência, que ampliam a visibilidade sobre possíveis vulnerabilidades ou códigos maliciosos.\n\nA manutenção desse inventário permite que as empresas entendam completamente as possíveis vulnerabilidades e riscos que podem surgir quando os elementos são retirados de repositórios de código aberto e componentes licenciados de terceiros. Uma plataforma DevSecOps pode ajudar a [gerar e atualizar automaticamente os SBOMs](/solutions/application-security-testing/), integrá-los aos fluxos de trabalho e vinculá-los às vulnerabilidades associadas.\n\nEmbora muitas empresas usem SBOMs, eles devem ser dinâmicos, conectados a ferramentas de análise de segurança e atualizados continuamente para serem totalmente eficazes. Quando integrados a ferramentas de análise e painéis de controle, os SBOMs podem ser uma opção para identificar os riscos associados a uma aplicação. Mesmo quando não são necessários, os SBOMs podem auxiliar a conformidade com os regulamentos de segurança, validando que o código é seguro.\n\n### Como usar a IA no desenvolvimento de software\nConforme as empresas exploram maneiras de usar a IA, os fluxos de trabalho de desenvolvimento de software são um ponto de entrada valioso para essa tecnologia, que tem o potencial de acelerar os processos de desenvolvimento e aprimorar a segurança.\n\nEmpresas de todos os setores começaram a explorar essas aplicações: 39% dos participantes [da pesquisa do GitLab](https://about.gitlab.com/developer-survey/2024/ai/) afirmam já usar a IA no ciclo de vida do desenvolvimento de software.\n\nAplicar a IA a todo o ciclo de vida do desenvolvimento de software pode ajudar as empresas a evitar backlogs e silos orientados pela IA nos fluxos de trabalho de desenvolvimento. A IA pode executar funções importantes, como:\n\n* Explicação de código e refatoração de código legado em [linguagens seguras para memória](https://about.gitlab.com/blog/memory-safe-vs-unsafe/)\n* [Análise da causa raiz de pipelines DevSecOps](https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/), acelerando a resolução de problemas complexos durante os testes\n* [Resolução de vulnerabilidades](https://about.gitlab.com/pt-br/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/) para lidar com vulnerabilidades conhecidas, possibilitando uma remediação mais completa\n\nConforme os líderes integram a IA em seus fluxos de trabalho, é crucial priorizar a privacidade e a segurança dos dados. Um aspecto essencial da adoção de uma abordagem com princípios de Seguro por Design é desenvolver uma [estratégia de IA que proteja dados confidenciais e os direitos de propriedade intelectual](https://about.gitlab.com/the-source/ai/building-a-transparency-first-ai-strategy-7-questions-to-ask-your-devops/).\n\n### O que vem por aí\nEm breve, o Seguro por Design pode se tornar a abordagem padrão para criar um ecossistema de software mais confiável. O [governo dos EUA](https://about.gitlab.com/the-source/security/national-cybersecurity-strategy-a-wake-up-call-for-software-developers/) tem colaborado com desenvolvedores de software para criar estruturas que incentivem legalmente o setor privado a produzir e lançar software com os princípios de Seguro por Design, levando as empresas a investir mais em tecnologia e práticas de segurança.\n\nCom a segurança integrada ao desenvolvimento de software desde o princípio, a transparência por meio de SBOMs eficazes e a IA aprimorando o processo de desenvolvimento, todos os envolvidos no ciclo de vida do desenvolvimento de software estarão posicionados para ter bons resultados.",{},"/pt-br/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design",{"title":521,"description":524,"ogImage":525,"config":534},{"ignoreTitleCharLimit":28,"ignoreDescriptionCharLimit":28},"strengthen-your-cybersecurity-strategy-with-secure-by-design","pt-br/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design","OrA_pUfnrVV2aXpOoeGdGr1ZEbKTPj2bi-pSeCiyPtI",[527,528,529],{"id":540,"title":541,"body":6,"category":31,"config":542,"content":544,"description":546,"extension":26,"meta":553,"navigation":28,"path":554,"seo":555,"slug":557,"stem":558,"type":448,"__hash__":559,"date":545,"timeToRead":436,"heroImage":547,"keyTakeaways":560,"articleBody":552},"theSource/pt-br/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam.yml","Como o GitLab pode ajudar você a se preparar para a avaliação do SOC 2",{"layout":8,"template":429,"author":543,"featured":431,"isHighlighted":431,"authorName":406},"gitlab",{"title":541,"date":545,"description":546,"timeToRead":436,"heroImage":547,"keyTakeaways":548,"articleBody":552},"2024-07-18","Conheça os recursos da plataforma DevSecOps que auxiliam na obtenção do SOC2.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463759/yk7f6poowtw5y5d5oflv.png",[549,550,551],"Os testes automatizados e os relatórios de cobertura de código aprimoram a disponibilidade e a integridade de processamento do SOC 2.","As análises de segurança e os controles baseados em funções do GitLab garantem a conformidade com a estrutura SOC 2, protegendo os dados contra vulnerabilidades e acessos não autorizados.","Os modelos do GitLab para testes de desempenho de carga e de navegador simplificam as avaliações do SOC 2 ao validar o desempenho e a segurança da aplicação em todas as etapas do desenvolvimento.","Os clientes do GitLab descobriram que usar o GitLab como sua plataforma para DevSecOps simplificou o processo de avaliação do SOC 2.  Este artigo analisa a estrutura SOC 2 e os recursos do GitLab que ajudam os clientes a se preparar para a certificação.\n\n## Introdução ao SOC 2\nOs Controles de Sistema e Organização 2, ou [SOC 2](https://us.aicpa.org/interestareas/frc/assuranceadvisoryservices/serviceorganization-smanagement), são um padrão de conformidade voluntário que define como as empresas devem gerenciar os dados dos clientes. O relatório de avaliação SOC 2 permite que as empresas atestem a confiabilidade do software que oferecem aos clientes corporativos.\n\nDesenvolvido pela Associação Internacional de Contadores Profissionais Certificados (AICPA), o SOC 2 se concentra em cinco critérios de serviços de confiança (Trust Services Criteria, TSC):\n- Segurança: proteger os dados dos clientes contra vulnerabilidades e acessos não autorizados.\n- Disponibilidade: garantindo que os sistemas sejam tolerantes a falhas e desempenhem de forma eficiente sob alta demanda para atender aos acordos de nível de serviço de disponibilidade.\n- Integridade do processamento: assegurar que os sistemas funcionem conforme projetado, sem vulnerabilidades, erros ou bugs.\n- Confidencialidade: proteger informações confidenciais, como código-fonte da aplicação, nomes de usuário, senhas e dados de cartão de crédito, entre outras, garantindo que o acesso seja restrito apenas às pessoas que necessitam desses dados para realizar seu trabalho.\n- Privacidade: proteger informações de identificação pessoal (PII) contra acessos não autorizados.\n\nA segurança é o único critério exigido em todas as avaliações do SOC 2. Os demais critérios podem ser incluídos na avaliação quando forem considerados essenciais para os serviços prestados.\n\n## Critério de segurança\nO critério de segurança diz respeito não apenas à segurança de servidores e sistemas físicos, mas também das aplicações. As vulnerabilidades do software podem expor uma aplicação a invasores, colocando os dados dos clientes em risco, mas o GitLab pode ajudar com isso.\n\nO GitLab oferece análises de segurança para identificar possíveis vulnerabilidades nas aplicações criadas pela empresa, incluindo os seguintes recursos:\n- [Testes Estáticos de Segurança de Aplicações (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/), que analisa o código-fonte em busca de possíveis bugs e vulnerabilidades, como códigos inseguros que podem levar à execução não intencional de códigos.\n- [Dependency Scanning](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/), que identifica vulnerabilidades de segurança nas dependências de software de uma aplicação.\n- [Análise de Contêiner](https://docs.gitlab.com/ee/user/application_security/container_scanning/), que identifica vulnerabilidades de segurança nas dependências do sistema operacional de uma aplicação em contêiner.\n- [Testes Dinâmicos de Segurança de Aplicações (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/), que identifica vulnerabilidades de segurança em uma aplicação web em execução que possam torná-la suscetível a um ataque.\n- [Análise de Infraestrutura como Código (IaC)](https://docs.gitlab.com/ee/user/application_security/iac_scanning/), que analisa arquivos de configuração de Infraestrutura como Código, incluindo Terraform, Ansible, AWS CloudFormation e Kubernetes, para identificar vulnerabilidades de segurança.\n\nAlém disso, o GitLab oferece um [relatório de vulnerabilidades](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/), que lista todas as vulnerabilidades conhecidas, identificadas pelas análises acima, na aplicação atual. O GitLab também disponibiliza uma lista de materiais de software ([SBOM](https://docs.gitlab.com/ee/user/application_security/dependency_list/)) no formato JSON CycloneDX padrão, que mostra todas as dependências em nível de software e de sistema operacional e suas vulnerabilidades conhecidas.\n\nA realização de análises periódicas de vulnerabilidades e a geração de relatórios detalhados de vulnerabilidades contribuem para o cumprimento de três critérios de segurança:\n- CC7.1 - Para alcançar seus objetivos, a entidade usa procedimentos de detecção e monitoramento para identificar (1) alterações nas configurações que possam introduzir novas vulnerabilidades e (2) suscetibilidades a vulnerabilidades recém-descobertas.\n- CC4.1 - Princípio 16 do COSO: a entidade seleciona, desenvolve e realiza avaliações contínuas e/ou independentes para verificar se os componentes do controle interno estão implementados e funcionando.\n- CC4.2 - Princípio 17 do COSO: a entidade avalia e comunica as deficiências nos controles internos em tempo hábil às partes responsáveis por realizar ações corretivas, incluindo a alta gerência e o conselho de administração, conforme necessário.\n\nUma parte crucial das análises de segurança é a governança e a garantia de aplicação. O GitLab oferece recursos para assegurar a execução periódica das análises, impedindo que as equipes de desenvolvimento de software possam contorná-las. Esses recursos incluem:\n- [Controles de acesso baseados em função](https://docs.gitlab.com/ee/user/permissions.html) para restringir quem pode fazer alterações nas configurações do projeto.\n- [Políticas de execução de análise](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) para garantir que as análises sejam executadas em cada repositório de código.\n- [Políticas de resultados de análise](https://docs.gitlab.com/ee/user/application_security/policies/merge_request_approval_policies.html) para assegurar que os resultados das análises sejam revisados e aprovados pelas partes interessadas de segurança apropriadas, evitando a introdução de vulnerabilidades recém-descobertas no software implantado.\n- [Relatórios de conformidade](https://docs.gitlab.com/ee/user/application_security/), que destacam quaisquer alterações nas configurações do GitLab que possam comprometer os processos de segurança implementados.\n\nCom essas configurações, as empresas podem provar que a segurança do software é a principal prioridade em suas aplicações e que práticas de segurança estão sendo rigorosamente aplicadas.\n\n## Critérios de disponibilidade e integridade do processamento\nO GitLab também pode ajudar com os TSCs de disponibilidade e integridade do processamento. Esses critérios se concentram na qualidade e no desempenho da aplicação. Para atender a esses critérios, o GitLab oferece:\n- Resultados de testes unitários e alterações na cobertura de código por meio de [relatórios de cobertura de código](https://docs.gitlab.com/ee/ci/testing/code_coverage.html), que garantem que o código-fonte esteja sendo validado por um conjunto de testes.\n- [Qualidade do código](https://docs.gitlab.com/ee/ci/testing/code_quality.html), que analisa a qualidade e a complexidade do código-fonte para facilitar a legibilidade e a manutenção.\n\nEmbora as práticas mencionadas sejam adotadas no início do ciclo de vida do desenvolvimento de software para garantir um código testado e de alta qualidade, o GitLab também disponibiliza modelos para diversos tipos de testes automatizados em aplicações em execução para assegurar que elas funcionem como esperado. Esses testes incluem:\n- [Teste de desempenho do navegador](https://docs.gitlab.com/ee/ci/testing/browser_performance_testing.html), que mede o tempo de carregamento dos sites durante o ciclo de vida do desenvolvimento, avaliando o impacto de alterações no código sobre o desempenho do navegador.\n- [Teste de desempenho de carga](https://docs.gitlab.com/ee/ci/testing/load_performance_testing.html), que avalia o desempenho do sistema no back-end de uma aplicação durante o ciclo de vida do desenvolvimento, testando o impacto de alterações no código sobre o desempenho.\n- [Teste de fuzzing guiado por cobertura](https://docs.gitlab.com/ee/user/application_security/coverage_fuzzing/), que envia dados inesperados, malformados ou aleatórios para uma aplicação e a monitora quanto a comportamentos instáveis e falhas.\n- [Teste de fuzzing da API da web](https://docs.gitlab.com/ee/user/application_security/api_fuzzing/), que envia dados inesperados, malformados ou aleatórios para os endpoints da API, com o objetivo de identificar bugs e problemas de segurança.\n\nAo adotar práticas eficazes de DevSecOps com o GitLab para criar aplicações seguras e de alta qualidade, as empresas terão mais facilidade em ser aprovadas na avaliação SOC 2 e atestar a segurança dos dados dos clientes.\n\n> **Saiba mais:** [Fortaleça a sua postura de cibersegurança](https://about.gitlab.com/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design/) com os princípios de Seguro por Design.",{},"/pt-br/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam",{"title":556,"description":546,"ogImage":547},"GitLab na preparação para SOC 2 | GitLab","how-gitlab-can-help-you-prepare-for-your-soc-2-exam","pt-br/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam","SXImbnXNsEkZpJCQuiOKkzY-QNRxZIEUWwFaW7FG_dY",[549,550,551],{"id":562,"title":563,"body":6,"category":31,"config":564,"content":565,"description":567,"extension":26,"meta":575,"navigation":28,"path":576,"seo":577,"slug":579,"stem":580,"type":448,"__hash__":581,"date":566,"timeToRead":568,"heroImage":569,"keyTakeaways":582,"articleBody":574},"theSource/pt-br/the-source/security/10-tips-to-prioritize-security-in-software-development.yml","Dez dicas para priorizar a segurança no desenvolvimento de software",{"layout":8,"template":429,"author":543,"featured":431,"isHighlighted":431,"authorName":406},{"title":563,"date":566,"description":567,"timeToRead":568,"heroImage":569,"keyTakeaways":570,"articleBody":574},"2024-04-16","Siga estas recomendações para integrar a segurança desde o início do ciclo de desenvolvimento, garantindo maior eficiência e um software mais seguro.","2 min de leitura","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464607/pmqkaclogv0y5tf4hk3t.png",[571,572,573],"A mudança para a esquerda aumenta a segurança do software ao possibilitar a detecção de vulnerabilidades no início do SDLC.","O GitLab integra segurança ao DevSecOps, permitindo um gerenciamento proativo de riscos.","Simplifique os processos com o GitLab para melhorar a velocidade e a conformidade no desenvolvimento.","Os ataques cibernéticos e as ameaças à cibersegurança continuam sendo uma das principais prioridades das empresas. Com isso, o papel dos desenvolvedores também segue evoluindo. Mais da metade dos participantes da [Pesquisa global de DevSecOps 2024](https://about.gitlab.com/developer-survey/) do GitLab afirmou ser responsável pela segurança das aplicações dentro de uma equipe maior, indicando que as práticas de segurança continuam mudando para a esquerda.\n\nMudar para a esquerda, ou seja, projetar software com as melhores práticas de segurança integradas para detectar e corrigir vulnerabilidades mais cedo no ciclo de vida do desenvolvimento de software (SDLC), permite que as equipes trabalhem com mais eficiência e lancem software mais rapidamente.\n\nEmbora 67% dos profissionais de segurança entrevistados pelo GitLab afirmem já ter adotado essa abordagem ou planejem adotá-la nos próximos três anos, talvez você ainda não saiba como começar.\n\nConfira estas dicas para ajudar suas equipes a implementar a mudança para a esquerda e aumentar a eficiência do DevSecOps:\n\n### 1. Calcule o tempo\n\nQuanto tempo é perdido remediando vulnerabilidades após o merge do código? Calcule esse tempo, identifique padrões no tipo ou origem dessas vulnerabilidades e faça os ajustes necessários para melhorar o processo.\n\n### 2. Identifique gargalos\n\nOnde estão os problemas e gargalos nos protocolos e processos de segurança? Identifique-os e, em seguida, crie e execute um plano de resolução.\n\n### 3. Comece aos poucos\n\nFaça pequenas alterações no código, pois elas são mais fáceis de revisar, proteger e lançar mais rapidamente do que grandes modificações no projeto.\n\n### 4. Elimine o modelo em cascata\n\nSua equipe ainda segue processos de segurança no modelo em cascata dentro do SDLC? Eliminar ou reduzir o uso do modelo em cascata ajudará sua empresa a se adaptar mais facilmente às mudanças de direção conforme necessário.\n\n### 5. Automatize as análises\n\nOs processos manuais estão atrasando e dificultando a detecção de vulnerabilidades? Automatize as descobertas em uma solicitação de merge para facilitar a revisão, a localização das fontes e o acesso para que os desenvolvedores possam tratar as questões.\n\n### 6. Atualize os fluxos de trabalho\n\nAs análises de segurança fazem parte dos fluxos de trabalho dos seus desenvolvedores? Com a segurança integrada aos seus fluxos de trabalho, os desenvolvedores podem identificar e corrigir vulnerabilidades antes de enviar o código para a produção.\n\n### 7. Garanta a conformidade\n\nTrabalhos imprevistos e não programados estão atrasando os lançamentos? Automatizar e implementar estruturas de conformidade ajuda a manter a uniformidade entre os ambientes de desenvolvimento, equipes e aplicações.\n\n### 8. Dê autonomia aos desenvolvedores com relatórios de segurança\n\nSeus desenvolvedores têm acesso a relatórios SAST e DAST? Essas ferramentas valiosas auxiliam as equipes de desenvolvimento a definir práticas de programação seguras, corrigindo vulnerabilidades dentro do seu próprio fluxo de trabalho.\n\n### 9. Torne o trabalho das equipes mais inteligente\n\nPermita que a equipe de segurança trabalhe de forma mais inteligente com painéis que oferecem visibilidade sobre as vulnerabilidades resolvidas e não resolvidas, onde elas estão, quem as criou e seu status de remediação.\n\n### 10. Elimine a complexidade da cadeia de ferramentas\n\nSimplifique e reduza sua cadeia de ferramentas para que os colaboradores possam focar em uma só interface: uma fonte única de verdade.\n\n## Mude para a esquerda com o GitLab\n\nO GitLab ajuda você a implementar uma estratégia de segurança proativa para descobrir vulnerabilidades mais cedo no SDLC. A segurança e a conformidade estão integradas na plataforma DevSecOps do GitLab, com um fluxo de trabalho completo que permite compreender e gerenciar riscos. Faça análises automáticas de vulnerabilidades em branches de recurso para corrigi-las antes de enviar o código para a produção.\n\nCom um histórico de apoio a iniciativas de DevSecOps em agências federais, estaduais e locais dos EUA, além de fornecedores e instituições de ensino, o GitLab oferece uma plataforma de desenvolvimento de software de ponta a ponta que atende a rigorosos requisitos de segurança e conformidade. Saiba mais sobre [como o GitLab pode ajudar você a adotar a mudança para a esquerda](https://about.gitlab.com/solutions/public-sector/) e acelerar a realização dos seus objetivos.",{},"/pt-br/the-source/security/10-tips-to-prioritize-security-in-software-development",{"title":563,"description":567,"ogImage":569,"config":578},{"ignoreTitleCharLimit":28,"ignoreDescriptionCharLimit":28},"10-tips-to-prioritize-security-in-software-development","pt-br/the-source/security/10-tips-to-prioritize-security-in-software-development","hilJuDD7qDlNaUzWP5rB2PH9DmYq1RlTqFvLv6ysyvU",[571,572,573],{"id":584,"title":585,"body":6,"category":31,"config":586,"content":588,"description":591,"extension":26,"meta":610,"navigation":28,"path":611,"seo":612,"slug":615,"stem":616,"type":448,"__hash__":617,"heroImage":589,"date":590,"timeToRead":436,"keyTakeaways":618,"articleBody":596,"faq":619},"theSource/pt-br/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab.yml","Como implementar as melhores práticas de gerenciamento de segredos com o GitLab",{"layout":8,"template":429,"featured":431,"author":587,"isHighlighted":431,"authorName":410},"jlongo",{"title":585,"heroImage":589,"date":590,"timeToRead":436,"description":591,"keyTakeaways":592,"articleBody":596,"faq":597},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463593/wgbh2snwpsyle9jom1k1.png","2024-03-12T00:00:00.000Z","Práticas inseguras de gerenciamento de segredos representam um risco para as empresas responsáveis pelo armazenamento e proteção de dados de clientes. Aprenda a reduzir esse risco e aumentar a confiança dos seus clientes.",[593,594,595],"Práticas inseguras de gerenciamento de segredos representam riscos de violação de dados, mas a integração nativa do GitLab aprimora a segurança.","O gerenciamento de segredos auditável e atribuível permite que as equipes de segurança monitorem atividades anômalas ou maliciosas e respondam rapidamente.","O GitLab oferece armazenamento e uso de segredos com controles de acesso robustos e ferramentas de detecção.","Práticas inseguras de gerenciamento de segredos (SMPs) representam um risco enorme para qualquer empresa, especialmente aquelas responsáveis pelo armazenamento e proteção dos dados de seus clientes. É um problema comum e frequentemente está no centro do registro de riscos de uma empresa. Um segredo vazado pode resultar na perda de confidencialidade e, potencialmente, em um vazamento de dados. Esse tipo de incidente pode levar a perdas financeiras significativas e à falta de confiança entre os clientes da empresa.\n\nPara muitas empresas, SMPs inseguras podem resultar da falta de conhecimento sobre as ferramentas e estratégias disponíveis para resolver esse problema. Práticas adequadas de gerenciamento de segredos podem ajudar a reduzir o potencial de comprometimento e aumentar a confiança na estratégia de gerenciamento de segredos de uma empresa. Neste artigo, discutiremos as melhores práticas de gerenciamento de segredos, a capacidade do GitLab de apoiar essas práticas e nossa estratégia para melhorar os recursos nativos de gerenciamento de segredos da plataforma DevSecOps.\n\n## Desenvolva uma estratégia criptográfica\n\nToda empresa precisa de uma estratégia criptográfica como base para garantir que os desenvolvedores operem de maneira padronizada e que todas as aplicações e seus componentes sejam desenvolvidos de acordo com os requisitos criptográficos da empresa.\n\nEntender os dados processados pela sua empresa, bem como a tolerância ao risco e o panorama de ameaças ajudará você a desenvolver uma estratégia criptográfica robusta.\n\n### Geração de segredos\n\nSegredos, incluindo tokens de acesso e chaves SSH, devem ser gerados usando dispositivos criptográficos, como Módulos de Segurança de Hardware (HSM). Esses dispositivos ajudam a gerar segredos criptograficamente fortes e armazená-los de maneira resistente a violação e intrusão.\n\nEmbora confiar em dispositivos físicos possa ser caro e operacionalmente proibitivo para as empresas, os principais provedores de serviços em nuvem oferecem serviços de Cloud HSM, como, por exemplo, o [AWS CloudHSM](https://aws.amazon.com/cloudhsm/) e o [GCP Cloud HSM](https://cloud.google.com/kms/docs/hsm).\n\n### Armazenamento de segredos\n\nArmazenar segredos é tão crítico quanto gerá-los. Os segredos gerados devem ser armazenados de maneira segura para garantir sua proteção a longo prazo e permitir que os usuários os recuperem quando necessário.\n\nOs principais provedores de serviços em nuvem, assim como empresas de segurança como a  [HashiCorp](https://www.vaultproject.io/), oferecem serviços baseados em nuvem para armazenar e recuperar segredos com segurança. Esses serviços permitem que os usuários utilizem os segredos em seus processos e código de maneira contínua, eliminando a necessidade de codificá-los diretamente no código.\n\n#### Como funciona o armazenamento de segredos no GitLab?\n\nO GitLab tem compatibilidade nativa com estes [provedores de gerenciamento de segredos](https://docs.gitlab.com/ee/ci/secrets/index.html):\n\n- Vault da HashiCorp\n- Google Cloud Secret Manager\n- Azure Key Vault\n\nAo configurar o GitLab para se conectar a um provedor de gerenciamento de segredos, os segredos são explicitamente solicitados apenas quando necessários por um job de CI. Quando os segredos não são necessários para os jobs de CI, eles permanecem armazenados de forma segura no ambiente do serviço de gerenciamento de segredos, reduzindo assim o potencial de comprometimento. Além de oferecer compatibilidade nativa para os provedores de gerenciamento de segredos mencionados, o GitLab também oferece [autenticação OIDC](https://docs.gitlab.com/ee/ci/secrets/id_token_authentication.html) para autenticação com outros provedores (como o AWS Secret Manager). Este é um método muito mais seguro e recomendado de armazenar segredos em comparação com o armazenamento e o [mascaramento](https://docs.gitlab.com/ee/ci/variables/#mask-a-cicd-variable) de segredos como variáveis CI/CD.\n\n### Uso de segredos\n\nOs segredos devem ser usados para um único propósito. Reutilizar segredos em diferentes aplicações ou serviços aumenta o potencial de exposição e o impacto caso sejam comprometidos.\n\nPara reduzir o potencial de exposição ou atividade maliciosa, o acesso aos segredos deve ser controlado com o [princípio do menor privilégio](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/) em mente. O acesso deve ser concedido apenas às pessoas ou serviços que necessitem dele para realizar seu trabalho e atividades operacionais.\n\n#### Como funciona o uso de segredos no GitLab?\n\nO GitLab oferece aos administradores um excelente [modelo de controle de acesso baseado em funções](https://docs.gitlab.com/ee/user/permissions.html) e a capacidade de criar [funções personalizadas](https://docs.gitlab.com/ee/user/custom_roles.html), permitindo que os administradores alinhem os perfis de acesso com os padrões organizacionais e a tolerância ao risco de suas empresas.\n\nO GitLab também permite que os usuários executem a [detecção de segredos](https://docs.gitlab.com/ee/user/application_security/secret_detection/) para verificar segredos e credenciais que possam ter sido comprometidos inadvertidamente. Usuários do GitLab Ultimate podem aplicar [respostas automáticas a segredos vazados](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response/), como revogar o segredo, para mitigar o impacto de credenciais vazadas.\n\n### Auditabilidade\n\nO acesso e o uso de segredos devem ser auditáveis e atribuíveis. Em um cenário ideal, indivíduos não teriam acesso para visualizar segredos em texto simples, mas a situação das operações de uma empresa nem sempre é ideal.\n\nO gerenciamento de segredos auditável e atribuível permite que as equipes de segurança monitorem atividades anômalas ou maliciosas e respondam rapidamente a essas atividades por meio de intervenção automatizada e manual.\n\n#### Como funciona a auditabilidade no GitLab?\n\nOs [eventos de auditoria](https://docs.gitlab.com/ee/administration/audit_events.html) do GitLab registram atividades relacionadas a tokens e chaves criados dentro do GitLab. Alguns exemplos incluem:\n\n- eventos de tokens de acesso pessoal\n- eventos de tokens de implantação\n- eventos de tokens de agentes de cluster\n\nEssas atividades são salvas no banco de dados e também estão disponíveis para  [streaming de eventos de auditoria](https://docs.gitlab.com/ee/administration/audit_event_streaming/) para clientes do GitLab Ultimate.\n\n## Em breve: GitLab Secret Manager\n\nO GitLab planeja lançar uma experiência nativa de gerenciamento de segredos no final de 2024. O GitLab Secret Manager será uma solução em nuvem multi-inquilino e estará acessível tanto para clientes do GitLab.com quanto para clientes do GitLab Self-Managed por meio do nosso serviço Cloud Connector. Esse novo serviço oferece uma interface fácil de usar, alinhada com a interface atual de variáveis CI/CD, tornando a adoção mais simples do que um produto de terceiros, com uma curva de aprendizado mínima. O GitLab Secret Manager garantirá a segurança e proteção de informações confidenciais e importantes em seus pipelines de CI.\n\n> Para obter mais informações ou esclarecer dúvidas sobre o GitLab Secret Manager, acesse nosso [épico MVC](https://gitlab.com/groups/gitlab-org/-/epics/10723) e deixe um comentário.",[598,601,604,607],{"header":599,"content":600},"O que é gerenciamento de segredos e por que é importante para a segurança de software?","O gerenciamento de segredos envolve armazenar, acessar e usar informações confidenciais e importantes, como chaves de API, tokens de acesso e senhas, de forma segura. Um gerenciamento adequado de segredos previne o acesso não autorizado, reduz o risco de violações de dados e garante a confidencialidade e integridade dos dados confidenciais nos processos de desenvolvimento e implantação de software.",{"header":602,"content":603},"Como o GitLab garante o armazenamento e recuperação seguros de segredos?","O GitLab se integra com os principais provedores de gerenciamento de segredos, incluindo Vault da HashiCorp, Google Cloud Secret Manager e Azure Key Vault. Essas integrações permitem que os segredos sejam armazenados com segurança e recuperados de forma explícita apenas quando necessários pelos jobs de CI, reduzindo o risco de exposição e acesso não autorizado.",{"header":605,"content":606},"Quais são as melhores práticas para gerar e usar segredos?","- __Geração de segredos__: use dispositivos criptográficos como Módulos de Segurança de Hardware (HSMs) para gerar segredos fortes. Serviços de Cloud HSM (por exemplo, AWS CloudHSM, GCP Cloud HSM) oferecem geração de segredos resistente a alterações e com custo acessível.\n- __Uso de segredos__: implemente o princípio do menor privilégio, garantindo que os segredos sejam usados para um único propósito e acessados apenas por usuários ou serviços autorizados. Evite embutir segredos diretamente no código para minimizar a exposição.",{"header":608,"content":609},"Como o GitLab ajuda na detecção e auditabilidade de segredos?","O GitLab realiza a detecção de segredos para verificar segredos e credenciais comprometidos inadvertidamente. Administradores podem aplicar respostas automatizadas, como revogar segredos vazados, para minimizar os riscos de segurança. Além disso, eventos de auditoria registram e transmitem atividades relacionadas ao uso de tokens e chaves, permitindo monitoramento contínuo e detecção de anomalias.",{},"/pt-br/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab",{"description":613,"ogDescription":613,"title":614,"ogTitle":614,"ogImage":589,"noIndex":28},"Gerenciamento inseguro de segredos põe empresas em risco. Aprenda a reduzir riscos e aumentar a confiança dos clientes.","Gerenciamento de segredos no GitLab: guia prático","how-to-implement-secret-management-best-practices-with-gitlab","pt-br/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab","jHwIazq5YHIJ51gKl4M9J0pXUbe7_jfnSU5j6-zyk8k",[593,594,595],[620,621,622,623],{"header":599,"content":600},{"header":602,"content":603},{"header":605,"content":606},{"header":608,"content":609},{"id":625,"title":626,"body":6,"category":31,"config":627,"content":629,"description":631,"extension":26,"meta":639,"navigation":28,"path":640,"seo":641,"slug":644,"stem":645,"type":448,"__hash__":646,"date":630,"timeToRead":632,"heroImage":633,"keyTakeaways":647,"articleBody":638},"theSource/pt-br/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era.yml","Gestão de políticas de segurança e conformidade em escala empresarial na era da IA",{"layout":8,"template":429,"author":628,"featured":431,"isHighlighted":431,"authorName":407},"grant-hickman",{"title":626,"date":630,"description":631,"timeToRead":632,"heroImage":633,"keyTakeaways":634,"articleBody":638},"2023-10-17","Descubra como a Gestão de Políticas de Segurança do GitLab pode ajudar a segurança e a conformidade da sua empresa a acompanhar o ritmo dinâmico do desenvolvimento de software.","8 min de leitura","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464499/qriml3qncnibzphitcax.png",[635,636,637],"As equipes de segurança têm dificuldade em acompanhar o ritmo acelerado do desenvolvimento de software, intensificado pela IA. A gestão eficaz de vulnerabilidades se torna essencial para garantir uma segurança reforçada.","As políticas de segurança do GitLab automatizam a conformidade, promovendo a colaboração entre as equipes de desenvolvimento e AppSec para detecção e remediação eficientes de vulnerabilidades.","Técnicas de priorização, como CVSS e pontuação baseada em risco, ajudam a gerenciar vulnerabilidades, garantindo o foco em problemas críticos diante do aumento de vulnerabilidades de código gerado por IA.","As equipes de segurança têm enfrentado desafios para acompanhar o ritmo do desenvolvimento de software. E continuam enfrentando obstáculos, como líderes que negligenciaram a importância da segurança no processo de desenvolvimento e a disparidade no número de desenvolvedores em relação aos profissionais de segurança. Com a chegada da IA, esse ritmo se intensificou ainda mais. A velocidade de desenvolvimento só tende a aumentar à medida que as empresas evoluem para níveis corporativos. Com isso, as ferramentas de segurança usadas para controlar os processos de desenvolvimento devem acompanhar esse crescimento.\n\nAs equipes de segurança de aplicações precisam gerenciar e priorizar vulnerabilidades de forma eficaz. Com as [políticas de segurança do GitLab](https://docs.gitlab.com/ee/user/application_security/policies/) e nosso conjunto de ferramentas de segurança, as empresas podem promover a colaboração entre as equipes de AppSec e desenvolvimento, facilitando a detecção, triagem e remediação eficientes de vulnerabilidades. As políticas de segurança também oferecem um mecanismo para automatizar a conformidade de segurança e gerenciá-la em escala empresarial.\n\nEmbora a análise de mais possíveis fontes de vulnerabilidades aumente as chances de detecção precoce e resolução de problemas, o grande volume de descobertas pode sobrecarregar as equipes de AppSec. À medida que obtemos mais insights sobre vulnerabilidades por meio de análises adicionais, identificar o que requer ação imediata torna-se cada vez mais desafiador.\n\n## Processos de triagem para gestão de vulnerabilidades\nAtualmente, existem algumas abordagens comuns para realizar a triagem de vulnerabilidades:\n\n- **Common Vulnerability Scoring System (CVSS):** o sistema comum de pontuação de vulnerabilidades oferece um método padronizado para avaliar a severidade da vulnerabilidade. Ao utilizar as pontuações do CVSS, as empresas podem priorizar as vulnerabilidades com base em seu possível impacto e alocar os recursos necessários adequadamente.\n\n- **Pontuação baseada em risco:** esse sistema permite que as empresas avaliem as vulnerabilidades com base na probabilidade de exploração e no possível impacto para os negócios. Ao considerar fatores contextuais, como o valor dos ativos, os recursos de agentes mal-intencionados e a prevalência de exploits, as empresas podem priorizar vulnerabilidades de forma eficaz.\n\n- **Modelagem de ameaças:** é uma abordagem que envolve identificar e avaliar possíveis ameaças a uma aplicação ou sistema. Ao realizar uma análise completa da arquitetura do sistema, do fluxo de dados e dos possíveis vetores de ataque, as empresas podem priorizar as vulnerabilidades com base em sua relevância em relação a ameaças prováveis. Essa abordagem ajuda a alocar recursos de forma eficaz, pois foca em vulnerabilidades com maior probabilidade de serem exploradas.\n\n- **Business Impact Analysis (BIA):** é uma técnica usada para avaliar o possível impacto das vulnerabilidades nas operações e objetivos empresariais. Envolve identificar ativos críticos, avaliar sua importância para a empresa e quantificar as possíveis consequências de um ataque bem-sucedido. Ao considerar o possível impacto financeiro, reputacional e operacional, as empresas podem priorizar as vulnerabilidades que apresentam os maiores riscos para suas funções essenciais de negócios.\n\nCom a crescente proliferação de código gerado por IA, aumentam também as vulnerabilidades não intencionais que são introduzidas. Técnicas como essas são fundamentais para ajudar as empresas a fazer triagens e determinar quais questões devem ser priorizadas. Mas, afinal, como podemos aplicar essas estruturas conceituais no mundo real? Vamos entender melhor como colocar essas técnicas em prática.\n\n## Gestão de políticas de segurança\nAs [políticas de segurança](https://docs.gitlab.com/ee/user/application_security/policies/) são a solução para transformar políticas e requisitos de conformidade de nível empresarial em diretrizes operacionais tangíveis, incorporadas às suas práticas de DevSecOps e ao ciclo de vida do desenvolvimento de software. Ao criar regras dentro das políticas de segurança do GitLab, as empresas podem definir critérios detalhados para a avaliação de vulnerabilidades, garantindo que apenas as descobertas passíveis de resolução sejam sinalizadas para maior atenção.\n\nAs políticas de segurança permitem implementar seus requisitos e melhores práticas de segurança e conformidade ao transformá-los em código. As [políticas de execução de análise](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) garantem que os scanners sejam executados em projetos específicos conforme suas necessidades e requisitos, assegurando que vulnerabilidades e exposições sejam detectadas antes do merge do código na produção.\n\nVocê também pode utilizar as [políticas de aprovação de solicitação de merge](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) para criar fluxos de trabalho personalizados para resolver vulnerabilidades. As políticas avaliam os resultados dos scanners de segurança e conformidade para impedir ou bloquear a fusão de merge requests, a menos que tenham sido devidamente revisadas e aprovadas com base nas regras definidas.\n\nAo adotar as políticas de aprovação de solicitação de merge e políticas de execução de análise, você adiciona uma camada de controle ao processo de desenvolvimento. Isso pode garantir que o código, escrito por humanos ou não, seja analisado automaticamente e que as violações de políticas incentivem a colaboração entre as equipes de engenharia e AppSec onde for mais aplicável.\n\n### Definir regras granulares nas políticas de aprovação de solicitação de merge\nPara ir mais além, você pode definir regras granulares dentro das políticas de aprovação de solicitação de merge com base nos filtros e atributos compartilhados abaixo. Essas regras podem ajudar a identificar quais vulnerabilidades são mais relevantes e a destacar informações úteis:\n\n- **Status da vulnerabilidade:** as políticas de segurança podem ser aplicadas com base no status de uma vulnerabilidade, geralmente com foco nas recém-detectadas que precisam passar por triagem. Também é possível criar regras baseadas em vulnerabilidades previamente detectadas com uma severidade específica, ou incluir ou excluir vulnerabilidades que foram descartadas.\n\n- **Branch:** direcione a aplicação de regras apenas para branches específicos, como o branch padrão de projetos críticos ou qualquer branch protegido.\n\n- **Correção disponível:** filtre as descobertas das análises de dependência e de contêiner quando uma correção não estiver disponível. Frequentemente, elas dependem de mudanças upstream de terceiros e ainda não permitem uma ação direta. É possível criar e monitorar tíquetes a partir das vulnerabilidades com uma data de vencimento para resolvê-las assim que uma correção estiver disponível.\n\n- **Falso positivo:** quando os scanners do GitLab identificarem uma descoberta como falso positivo (em análises de contêiner e Dependency Scanning), esse estado será marcado na vulnerabilidade. As políticas de segurança podem então usar isso para filtrar falsos positivos na supervisão das políticas de segurança, permitindo que engenheiros de AppSec e desenvolvedores ignorem essas detecções e façam o merge do código sem interrupções. As vulnerabilidades continuarão disponíveis no relatório de vulnerabilidades, caso seja necessária uma análise mais aprofundada.\n\n- **Tempo ou Acordo de Nível de Serviço (SLA):** às vezes, vulnerabilidades de menor severidade podem ser toleradas pelas empresas por um tempo, mas devem ser planejadas e tratadas dentro de um SLA razoável. Com as políticas de segurança, você pode definir SLAs baseados na severidade de uma descoberta, como permitir que vulnerabilidades de severidade média sejam mescladas sem a necessidade de aprovação, com um SLA de 60 dias para resolução (que pode ser registrado em um tíquete de acompanhamento com data de vencimento). No entanto, se a vulnerabilidade ultrapassar o SLA de 60 dias, as solicitações de merge serão bloqueadas e a vulnerabilidade deverá ser resolvida.\n\n![security-policies-rules-ds-all-filters](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175811/Blog/k0bror5vmcosg8jm4zi1.png)\n\n### Priorize descobertas críticas em toda a empresa\nUma abordagem comum para lidar com grandes volumes de vulnerabilidades é começar aos poucos, priorizando as descobertas mais críticas em toda a empresa. Um SLA de triagem de vulnerabilidades pode facilitar esse processo, definindo regras para tratar vulnerabilidades dentro de um SLA específico, com base na severidade. Confira abaixo uma demonstração rápida de como usar uma política de aprovação de solicitação de merge do GitLab para aplicar SLAs diferentes conforme o nível de severidade das vulnerabilidades. Nesse caso, se uma descoberta de alta severidade for detectada, as solicitações de merge não serão bloqueadas por 30 dias, permitindo que os desenvolvedores resolvam o problema dentro da janela do SLA.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/cOsAaLXdV2k\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Garanta a separação de funções\n\nAs políticas de segurança podem ser gerenciadas de várias maneiras, mas a melhor abordagem é criar um projeto isolado no GitLab, que garanta a separação de funções entre os profissionais de segurança e as equipes de desenvolvimento. As políticas são armazenadas em YAML. Essa abordagem de política como código fortalece sua equipe de segurança e oferece diversos benefícios, como um histórico no Git de alterações nas políticas para maior visibilidade, controle de versão que facilita a reversão de mudanças prejudiciais, supervisão e aprovações obrigatórias de alterações nas políticas (se necessário), auditabilidade por meio dos eventos de auditoria do GitLab e controles concretos que podem ser apresentados como evidências a auditores.\n\n![gitlab security-policies policy-yml](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175821/Blog/bqfig4ufupuitbarasuj.png)\n\n## Conectando todos os pontos\nGerenciar o fluxo crescente de vulnerabilidades requer uma abordagem precisa que equilibre análises detalhadas com triagem e remediação eficientes. As políticas de segurança do GitLab são uma solução eficaz que facilita a colaboração, oferece liberdade na definição de regras de política personalizadas e viabiliza a operacionalização precisa dos requisitos de negócios e estruturas de conformidade. Com as ferramentas de segurança do GitLab e a aplicação de filtros e atributos personalizados, as empresas podem otimizar a gestão de vulnerabilidades e direcionar seus esforços para os riscos mais críticos. Isso não apenas fortalece sua postura geral de segurança, como também garante a conformidade com os requisitos de órgãos externos. Ainda que existam preocupações em relação ao código gerado por IA, os três pilares da segurança (pessoas, processos e tecnologia) permanecem firmes. Ao incorporar políticas de segurança em seus processos de negócios, você pode proteger sua empresa contra esses riscos.\n\nAlém de usar políticas de segurança para implementar políticas como código em grande escala, a plataforma DevSecOps do GitLab oferece um conjunto completo de ferramentas de segurança. Em nosso recente [Relatório global de DevSecOps de 2023](https://learn.gitlab.com/devsecops-survey-2023/), 57% dos profissionais de segurança afirmaram usar seis ou mais ferramentas para o desenvolvimento de software, enquanto 69% expressaram o desejo de consolidar sua cadeia de ferramentas. A consolidação de ferramentas é prioridade para muitos CISOs, e o GitLab se destaca ao ajudar a reduzir a expansão da cadeia de ferramentas. Oferecemos as principais soluções para análise de segurança: Testes Estáticos de Segurança de Aplicações (inclusive para infraestrutura como código), detecção de segredos, Testes Dinâmicos de Segurança de Aplicações (inclusive para APIs), Dependency Scanning e segurança de API. Também facilitamos a gestão de vulnerabilidades para as equipes de AppSec, com relatórios dinâmicos de vulnerabilidades. Por fim, fechamos o ciclo de conformidade com estruturas de conformidade, relatórios de adesão e eventos de auditoria.\n\nSaiba mais sobre como gerenciar a [segurança de aplicações](https://docs.gitlab.com/ee/user/application_security/#use-security-scanning-tools-with-merge-request-pipelines) usando o GitLab.\n\n> **Próximo artigo:** Josh Lemos, Diretor de Segurança da Informação do GitLab, explica como [resolver problemas comuns de segurança](https://about.gitlab.com/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/).\n",{},"/pt-br/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era",{"title":642,"description":643,"ogImage":633},"Segurança e conformidade na era da IA | GitLab","Descubra como o gerenciamento de políticas de segurança do GitLab pode ajudar sua segurança e conformidade a acompanhar o ritmo do desenvolvimento de software.","enterprise-scale-security-and-compliance-policy-management-in-the-ai-era","pt-br/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era","ux84W1jqQuNJ5GlF6RpVmXzHioW_KHRVdd2UI1ZdDyQ",[635,636,637],{"id":649,"title":650,"body":6,"category":31,"config":651,"content":653,"description":655,"extension":26,"meta":663,"navigation":28,"path":664,"seo":665,"slug":667,"stem":668,"type":448,"__hash__":669,"date":654,"timeToRead":656,"heroImage":657,"keyTakeaways":670,"articleBody":662},"theSource/pt-br/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles.yml","Como fortalecer a segurança aplicando os princípios de DevSecOps",{"layout":8,"template":429,"author":652,"featured":431,"isHighlighted":431,"authorName":416},"ncregan",{"title":650,"date":654,"description":655,"timeToRead":656,"heroImage":657,"keyTakeaways":658,"articleBody":662},"2023-02-23","Aprenda a aplicar os princípios de DevSecOps hoje mesmo e descubra todo o potencial dessa abordagem.","4 min de leitura","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464433/bdwagz0bt5bpgghjkout.png",[659,660,661],"O DevSecOps integra segurança ao SDLC, garantindo a entrega de aplicações seguras sem atrasos.","A automação no DevSecOps aumenta a segurança, otimizando a detecção e a resposta a ameaças.","A colaboração no DevSecOps promove uma abordagem unificada para um desenvolvimento de software rápido e seguro.","Ao seguir os princípios do DevSecOps, as empresas podem proteger suas aplicações contra agentes mal-intencionados, enquanto agregam valor com rapidez e eficiência. Neste artigo, vamos analisar a fundo os princípios de DevSecOps e como eles podem ajudar as empresas a se manterem à frente em termos de segurança. Vamos começar.\n\n## O que é DevSecOps?\nO [DevSecOps](/topics/devsecops/) é uma abordagem de desenvolvimento de software que integra os três princípios de desenvolvimento, segurança e operações. Essa metodologia permite que as equipes criem produtos seguros e confiáveis, ao mesmo tempo em que entregam valor com rapidez e eficiência. A execução bem-sucedida do DevSecOps envolve integração contínua, automação e testes, com o objetivo de acelerar o tempo de comercialização, sem comprometer a qualidade ou a segurança.\n\n## Princípios de DevSecOps: uma visão geral\nOs [princípios de DevSecOps](/blog/4-must-know-devops-principles/) permitem que as equipes de desenvolvimento criem aplicações seguras e confiáveis com agilidade, por meio da execução de testes de segurança incorporados. Ao adotar uma abordagem de DevSecOps, as equipes integram segurança a todo o ciclo de vida do desenvolvimento de software (SDLC), desde o design inicial até a entrega e implantação contínuas. Isso ajuda a prevenir a exploração de vulnerabilidades por agentes mal-intencionados, evitando violações de segurança e reduzindo o risco de ataques cibernéticos.\n\nOs princípios do DevSecOps incluem:\n\n### Automação e integração\nA automação e a integração são componentes essenciais do DevSecOps. A automação dos processos de segurança auxilia no desenvolvimento de aplicações seguras e confiáveis, além de reduzir o risco de futuros ataques mal-intencionados. Você pode configurar e executar medidas de segurança em diversos pontos do ciclo de desenvolvimento, simplificando e maximizando as práticas de segurança por meio da aplicação da segurança contínua.\n\n### Entrega e implantação contínuas\nA entrega e a implantação contínuas são outro processo que permite que as equipes respondam rapidamente a possíveis ameaças e protejam sua cadeia de suprimentos de software contra agentes mal-intencionados. O [uso de processos automatizados para a implantação contínua de aplicações](/blog/cd-solution-overview/) possibilita o desenvolvimento rápido de novos recursos e produtos, ao mesmo tempo em que garante a segurança e a qualidade das aplicações.\n\n### Uma abordagem colaborativa para a segurança\nA segurança é uma parte fundamental do DevSecOps. Para manter as aplicações seguras e confiáveis, é preciso adotar [uma abordagem altamente colaborativa](/topics/version-control/software-team-collaboration/), com diversas verificações de segurança contínuas. É necessário que todas as partes envolvidas no processo de desenvolvimento participem também do processo de segurança.\n\nAs equipes de segurança devem trabalhar com os desenvolvedores para garantir que as aplicações sejam projetadas com os [controles de segurança adequados](/topics/devsecops/devsecops-security-checklist/) e o mínimo possível de vulnerabilidades. Ao mesmo tempo, para que as aplicações sejam implantadas e monitoradas de forma segura, as equipes de operações precisam colaborar com as equipes de segurança.\n\n### Segurança em todas as etapas do SDLC\nA integração da segurança em cada etapa do SDLC garante o desenvolvimento eficiente de aplicações seguras, sem sacrificar a qualidade. É essencial abranger [todas as etapas do ciclo de vida](/blog/top-10-gitlab-hacks/), desde o design até o desenvolvimento e a implantação.\n\nPara que o processo seja eficaz, os desenvolvedores devem projetar aplicações com controles de segurança adequados, e as equipes de operações devem implantá-los e monitorá-los de forma segura.\n\n### Estratégias proativas de monitoramento e resposta\nAs estratégias proativas de monitoramento e resposta são essenciais para manter a segurança das aplicações ao longo de sua vida útil. O [monitoramento](/blog/working-with-performance-metrics/) é realizado por meio da implantação de ferramentas automatizadas, que identificam possíveis vulnerabilidades e alertam as equipes assim que são detectadas.\n\nIsso ajuda a minimizar os riscos e garantir a uniformidade em toda a empresa. Já a adoção de uma estratégia de resposta abrangente permite identificar e resolver problemas antes que se tornem riscos de segurança.\n\n## Benefícios da implementação do DevSecOps\nA implementação do DevSecOps oferece inúmeros benefícios para as empresas:\n1. Ajuda a conquistar a confiança dos clientes ao oferecer aplicações seguras.\n2. Impede que agentes mal-intencionados explorem vulnerabilidades e melhora a segurança dos sistemas.\n3. A metodologia DevSecOps permite que as equipes agreguem valor rapidamente, garantindo o mais alto nível de segurança.\n4. Ao integrar segurança ao pipeline de desenvolvimento de software, desde a fase de design até a implantação, as equipes conseguem identificar e resolver possíveis riscos rapidamente, reduzindo as chances de ataques mal-intencionados.\n5. O DevSecOps ajuda as empresas a se anteciparem a possíveis ameaças e permanecerem competitivas no mercado.\n\n[Implementar o DevSecOps](/blog/whats-next-for-devsecops/) é essencial para qualquer empresa que queira proteger seus sistemas contra ataques mal-intencionados e, ao mesmo tempo, agregar valor com rapidez e eficiência. Além disso, a integração da segurança ao SDLC garante que todas as novas aplicações sejam protegidas desde o princípio. Estabelecer uma cultura e abordagem de DevSecOps contribui para a máxima eficiência e qualidade do processo de desenvolvimento de software.",{},"/pt-br/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles",{"title":650,"description":655,"ogImage":657,"config":666},{"ignoreTitleCharLimit":28,"ignoreDescriptionCharLimit":28},"how-to-strengthen-security-by-applying-devsecops-principles","pt-br/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles","hP6q1X7AJg20R8VIMz_6VhNdPYhIolVfmb7JfNjV0Zk",[659,660,661],1772652131188]