> ## Documentation Index > Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt > Use this file to discover all available pages before exploring further. # Risoluzione automatica delle issue di SonarQube > Utilizzare Devin per risolvere le issue di SonarQube tramite GitHub Actions L'API di Devin è un potente strumento progettato per risolvere automaticamente le issue di codice rilevate da strumenti di code scanning come SonarQube. Sebbene questa documentazione sia incentrata su SonarQube, la strategia di base si applica anche ad altri strumenti di scansione del codice, tra cui Veracode, Orca e altri. Se vuoi vedere questo processo in azione, consulta il nostro repository di esempio ed esplora la spiegazione dettagliata nel post sul blog di Cognition. In produzione, il processo avrà il seguente aspetto:
# Risoluzione automatizzata delle issue con l’API di Devin
In produzione, il processo di risoluzione automatica dei problemi di codice tramite l’API di Devin è snello ed efficiente. Di seguito trovi una panoramica ad alto livello dei passaggi coinvolti:
### 1. Panoramica del processo
1. **Viene aperta una Pull Request**: Una pull request (PR) viene aperta nel repository con modifiche che potrebbero contenere issue individuate da uno strumento di code scanning. 2. **Si attiva una GitHub Action**: L’apertura della PR attiva automaticamente un workflow GitHub Actions. 3. **La GitHub Action chiama la Devin API**: La GitHub Action invia una richiesta alla Devin API, passando le issue individuate per la risoluzione automatizzata. 4. **Viene inizializzata una sessione Devin**: Viene avviata una sessione Devin, che riceve il contesto dell’issue e tenta di risolverla in base ai dati forniti. 5. **Devin propone una PR per la revisione umana**: Una volta risolta l’issue, Devin genera una PR con le modifiche proposte e la invia per la revisione da parte di una persona.
### 2. Passaggi per raggiungere questo obiettivo
Per integrare l’API di Devin con la tua pipeline CI/CD, dovrai completare le seguenti configurazioni: 1. **Configura SonarQube per il supporto CI e API**: * Assicurati che SonarQube sia configurato per supportare l’integrazione continua (CI) e l’integrazione tramite API. Se preferisci non configurare SonarQube per l’accesso via API, puoi utilizzare un cookie per l’autenticazione. [Scopri di più su questa configurazione qui](#). 2. **Configura l’ambiente GitHub per memorizzare i secrets necessari**: * Configura l’ambiente GitHub per archiviare in modo sicuro i secrets necessari, come token di autenticazione e chiavi di configurazione, per interagire con l’API di Devin e altri strumenti integrati. Una volta completati questi passaggi, la tua pipeline sarà pronta per risolvere automaticamente i problemi utilizzando l’API di Devin, velocizzando il processo e riducendo la necessità di interventi manuali. 3. **Testare l’integrazione** Una volta completata la configurazione, puoi testare l’integrazione attivando manualmente una GitHub Action. Questo ti consentirà di verificare che la Action richiami correttamente l’API di Devin e risolva i problemi identificati. 4. **Visualizzare la pagina delle sessioni di Devin** Dopo che la GitHub Action è stata attivata e Devin ha elaborato i problemi, puoi visualizzare lo stato e i risultati nella pagina delle sessioni di Devin. Questa pagina fornisce approfondimenti dettagliati sui problemi risolti e sulle modifiche proposte. Guida dettagliata Salta pure questa sezione se il tuo progetto SonarQube è già configurato correttamente. In caso contrario, quanto segue illustra come garantire che GitHub abbia accesso all’API di SonarQube. Valori richiesti da SonarQube Per configurare l’integrazione, dovrai ottenere i seguenti tre valori dalla tua istanza SonarQube: Avrai bisogno di tre valori da SonarQube:
### 1. Crea **SONAR\_TOKEN**:
1. Fai clic sull'icona del tuo account in alto a destra in SonarQube. 2. Seleziona **Security** dal menu a discesa. 3. Nella sezione **Tokens**, fai clic su **Generate Tokens**. 4. Assegna un nome al token e fai clic su **Generate**. * Copia il token generato per usarlo in GitHub Actions. SonarQube
### 2. Crea **SONAR\_PROJECT**
1. Seleziona il progetto in SonarQube. 2. Fai clic su **Information** in basso a sinistra. 3. Scorri verso il basso per trovare la chiave del progetto. SonarQube
### 3. Crea **SONAR\_ORG**
Fai riferimento ai passaggi sopra per individuare i dettagli della tua organizzazione in SonarQube. Una volta che hai tutti i valori richiesti, sei pronto per configurare la GitHub Action. Questa procedura presuppone che tu abbia un file di configurazione locale di SonarCloud `sonar-project.properties` che specifichi: ``` sonar.projectKey={PROJECT_KEY} sonar.sources=FILE_PATH (di solito ".") ``` La GitHub Action ha il seguente codice sorgente ``` name: Scansione SonarCloud e Correzione Devin on: workflow_dispatch: push: branches: - '**' pull_request: branches: - '**' jobs: analyze: name: Analyze and Remediate runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: SonarCloud Scan uses: SonarSource/sonarqube-scan-action@v4 env: SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} SONAR_ORG: ${{ secrets.SONAR_ORG }} with: args: > -Dsonar.organization=${{ env.SONAR_ORG }} -Dsonar.sources=. - name: Setup Python uses: actions/setup-python@v5 with: python-version: '3.x' - name: Install Dependencies run: pip install aiohttp - name: Configure Git run: | git config --global user.name "GitHub Action" git config --global user.email "action@github.com" - name: Run Devin Remediation env: DEVIN_API_KEY: ${{ secrets.DEVIN_API_KEY }} SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} SONAR_ORG: ${{ secrets.SONAR_ORG }} SONAR_PROJECT_KEY: {SONAR_PROJECT_KEY} run: python .github/scripts/devin_remediation.py ``` A titolo di promemoria: devin\_remediation.py ``` import asyncio import aiohttp import os from datetime import datetime # Variabili di ambiente GITHUB_REPOSITORY = os.getenv("GITHUB_REPOSITORY") SONAR_TOKEN = os.getenv("SONAR_TOKEN") DEVIN_API_KEY = os.getenv("DEVIN_API_KEY") SONAR_ORG = os.getenv("SONAR_ORG") SONAR_PROJECT_KEY = os.getenv("SONAR_PROJECT_KEY") DEVIN_API_BASE = "https://api.devin.ai/v1" async def get_sonarcloud_issues(): """Recupera le vulnerabilità aperte da SonarCloud.""" url = "https://sonarcloud.io/api/issues/search" headers = {"Authorization": f"Bearer {SONAR_TOKEN}"} params = { "organization": SONAR_ORG, "projectKeys": SONAR_PROJECT_KEY, "types": "VULNERABILITY", "statuses": "OPEN" } async with aiohttp.ClientSession() as session: async with session.get(url, headers=headers, params=params) as response: if response.status != 200: print(f"Errore durante il recupero dei problemi SonarCloud: {await response.text()}") return [] result = await response.json() print(f"Trovati {len(result.get('issues', []))} problemi") return result.get('issues', []) async def delegate_task_to_devin(issue): """Delega l'intera attività di correzione, commit e push a Devin AI.""" async with aiohttp.ClientSession() as session: headers = {"Authorization": f"Bearer {DEVIN_API_KEY}"} prompt = f""" Correggi la seguente vulnerabilità in {GITHUB_REPOSITORY}: {issue['message']} nel file {issue['component']}. 1. Crea un nuovo branch denominato 'devin/{issue['key']}-fix-vulnerability'. 2. Implementa la correzione. 3. Scrivi un messaggio di commit dettagliato che spieghi le modifiche: - Chiave problema: {issue['key']} - Componente: {issue['component']} - Corretto da Devin AI il {datetime.now().isoformat()} - Includi 'Co-authored-by: github-actions[bot] '. 4. Esegui il push del branch nel repository remoto. 5. Apri una pull request con una descrizione della correzione. """ data = {"prompt": prompt, "idempotent": True} async with session.post(f"{DEVIN_API_BASE}/sessions", json=data, headers=headers) as response: if response.status != 200: print(f"Errore durante la delega dell'attività a Devin: {await response.text()}") return None result = await response.json() print(f"Sessione Devin creata: {result}") return result async def monitor_devin_session(session_id): """Monitora il progresso di Devin fino al completamento dell'attività.""" async with aiohttp.ClientSession() as session: headers = {"Authorization": f"Bearer {DEVIN_API_KEY}"} while True: async with session.get(f"{DEVIN_API_BASE}/sessions/{session_id}", headers=headers) as response: if response.status != 200: print(f"Errore durante il monitoraggio della sessione Devin: {await response.text()}") return None result = await response.json() status = result.get("status_enum") if status in ["completed", "stopped"]: print(f"Devin ha completato l'attività: {result}") return result elif status == "blocked": print("Devin ha riscontrato un problema. Verificare manualmente.") return None await asyncio.sleep(5) async def main(): try: issues = await get_sonarcloud_issues() for issue in issues: print(f"Elaborazione del problema: {issue['key']}") # Delega l'attività a Devin AI session_data = await delegate_task_to_devin(issue) if session_data: session_id = session_data["session_id"] # Monitora il progresso di Devin await monitor_devin_session(session_id) except Exception as e: print(f"Si è verificato un errore: {str(e)}") raise if __name__ == "__main__": asyncio.run(main()) ``` Per fare in modo che la GitHub Action imposti le variabili d'ambiente corrette, aggiungile ai **GitHub Repository Secrets**. Raggiungere le impostazioni corrette può essere complicato. Vai su **Security** e configura **Secrets**. Aggiungi **SONAR\_TOKEN** e **DEVINS\_API** tra i **Repository Secrets**. SonarQube Una volta configurata, puoi monitorare l'esecuzione della tua GitHub Action. Se viene eseguita correttamente, apparirà come segue: SonarQube Puoi visualizzare le sessioni di Devin nel **Session Manager**. SonarQube Al termine, Devin aprirà automaticamente delle pull request. Per gli utenti GitLab, consulta la [guida](/it/enterprise/use-cases/sonarqube/gitlab) collegata.