DEV Community: VIET QUOC NGUYEN

Set up Trivy Scanner in GitLab CI

VIET QUOC NGUYEN — Sun, 27 Oct 2024 10:30:34 +0000

Here's a blog post to guide others on setting up a security scan CI pipeline (using Trivy) in GitLab. I am keeping it simple as much as I can.

Setting Up a GitLab CI Pipeline for Security Scanning

Continuous Integration (CI) pipelines play a critical role in automating and securing code development workflows. With GitLab CI, you can automate security scans to detect vulnerabilities and misconfigurations in your code. In this guide, we’ll set up a CI pipeline in GitLab using Trivy, a popular open-source security scanner (https://github.com/aquasecurity/trivy), to perform file system scans for configuration issues and vulnerabilities.

Prerequisites

GitLab Repository: You’ll need a GitLab project to set up your CI/CD pipeline.
GitLab Runner: Make sure you have a GitLab Runner available to execute the pipeline jobs.

Step 1: Create the `.gitlab-ci.yml` File

In the root of your GitLab project, create a .gitlab-ci.yml file. This file defines the stages, jobs, and configuration for your CI/CD pipeline.

Here's the .gitlab-ci.yml configuration for our Trivy security scan job:

security-misc-scan:
  stage: security_scan
  variables:
    TRIVY_NO_PROGRESS: "true" # Disables the progress bar for a cleaner log output
    TRIVY_CACHE_DIR: ".trivycache/" # Sets the directory for caching scan data
  before_script:
    - apt-get update; apt-get install curl -y; # Install curl to retrieve the latest Trivy version
    - export TRIVY_VERSION=$(curl -s "https://api.github.com/repos/aquasecurity/trivy/releases/latest" | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/\1/') # Fetch the latest Trivy version
    - echo $TRIVY_VERSION
    - curl -L https://github.com/aquasecurity/trivy/releases/download/v${TRIVY_VERSION}/trivy_${TRIVY_VERSION}_Linux-64bit.tar.gz | tar -zxvf - # Download and extract Trivy
  script:
    - touch misc-scan-report.json # Create a file to store the scan results
    - ./trivy filesystem --scanners config,vuln --exit-code 0 --format template --template "@contrib/gitlab-codequality.tpl" -o misc-scan-report.json . # Run Trivy with config and vulnerability scanners
    - cat misc-scan-report.json # Display the report in the job log
  cache:
    paths:
      - .trivycache/ # Cache directory to save data between pipeline runs
  artifacts:
    paths:
      - misc-scan-report.json # Save the scan report as an artifact
    reports:
      codequality: misc-scan-report.json # Report for GitLab Code Quality
  when: always # Always run this job
  rules:
  - if: $CI_PIPELINE_SOURCE == "parent_pipeline" # Run the job only if the pipeline source is parent_pipeline
  allow_failure: true # Allow this job to fail without impacting the pipeline status
  tags:
  - dind # Runner tag for Docker-in-Docker
  needs: []

Explanation of the Job Configuration

Stage: security_scan defines the stage in the pipeline where this job will run.
Variables: Trivy environment variables are defined for better output and caching.
Before Script: This section downloads and installs Trivy. It fetches the latest release version from GitHub, ensuring the scan uses the most recent updates.
Script: Runs the Trivy scan on the repository files and generates a JSON report file misc-scan-report.json.
Cache: Caches the .trivycache/ directory to speed up scans by reusing downloaded data between jobs.
Artifacts: Stores the JSON report for later review. GitLab can use this report for Code Quality integration.
Rules: Ensures the job runs only if triggered by a parent pipeline.
Tags: Specifies the runner requirements, in this case, a dind (Docker-in-Docker) compatible runner. You need to change it to the tag of your Gitlab runners.

Step 2: Commit and Push Your `.gitlab-ci.yml` File

After creating the file, commit and push it to your GitLab repository:

git add .gitlab-ci.yml
git commit -m "Add Trivy security scan job to CI pipeline"
git push origin main

Step 3: Monitor the Pipeline

Once pushed, GitLab will automatically trigger the pipeline. You can check the job logs to see Trivy’s progress and review the misc-scan-report.json output for any discovered vulnerabilities or misconfigurations.

You can check the full report at Code Quality tab in Gitlab Pipelines page:

Conclusion

By following these steps, you’ve set up a GitLab CI pipeline that automates security scanning with Trivy, enhancing your project’s security without manual intervention. This approach keeps your codebase secure and compliant, helping you catch potential issues early in the development process.

Let me know if you’d like further customization options for different scan configurations!

A Simple OpenAI Chatbot

VIET QUOC NGUYEN — Mon, 22 Jul 2024 19:23:23 +0000

Here is a post about creating a simple AI bot with Python3 and OpenAI library. You can find the full source code here: https://github.com/vietjovi/openai-chatbot

Build Your Own OpenAI-Powered Chatbot with Python: A Deep Dive into the OpenAI Chatbot Repository

Creating a chatbot that can converse with users intelligently has become easier than ever with OpenAI’s API. In this guide, we’ll explore the OpenAI Chatbot repository, which provides a structured way to build, customize, and deploy your own AI-powered chatbot. The code leverages OpenAI's ChatCompletion API to create dynamic conversations, retain context, and store past messages for a personalized experience.

Let’s dive into the code and see how you can set up, run, and expand upon this AI chatbot project.

Project Overview

This chatbot implementation is designed to respond naturally to user questions, with the flexibility to recall past interactions for continuity. The chatbot is built with Python, allowing for easy configuration, prompt customization, and adaptation to various applications.

Key Features

Conversation Context: Tracks past messages to maintain context within a conversation.
Simple Configuration: Allows easy setup and customization of OpenAI API parameters.
Error Handling: Handles cases where API calls might fail, ensuring smoother user experiences.

Getting Started

Prerequisites

OpenAI API Key: Obtain an API key from OpenAI.
Python Environment: Ensure Python 3.7+ and pip are installed.
Git: Clone the project repository.

Step 1: Clone the Repository

Begin by cloning the repository to your local machine:

git clone https://github.com/vietjovi/openai-chatbot.git
cd openai-chatbot

Step 2: Install Dependencies

This project requires specific libraries, which you can install from requirements.txt:

pip install -r requirements.txt

Step 3: Configure the Chatbot

Before running the chatbot, set up the configuration in the config.py file:

API Key: Set api_key to your OpenAI API key.
API Endpoint and Engine: Configure api_endpoint, api_type, api_version, and engine (e.g., gpt-3.5-turbo).
Data Directory: Set data_dir to specify where past conversations are saved.

Here's an example of what your config.py might look like:

# config.py
api_key = 'your-api-key'
api_endpoint = 'https://xxxxxxxx.openai.azure.com/' #Remove this configuration if you use api.openai.com
api_version = "2023-03-15-preview"
api_type = "azure" #Remove this configuration if you use *.openai.com
engine = "gpt-3.5-turbo"
version = "v1.0"
data_dir = './data/'
past_message_included = "5" #How many message history(Q&A) will be kept. It makes a price increase - https://openai.com/pricing

Code Walkthrough

Let’s explore the main sections of the code, focusing on how it initializes, handles messages, and saves conversations.

1. The Core Functions

`openAIRequest(question, userId)`

The openAIRequest function sends a single question to the OpenAI API and receives a response. Here’s a breakdown of the function:

def openAIRequest(question="", userId=""):
    openai.api_key = config.api_key
    openai.api_base = config.api_endpoint
    openai.api_type = config.api_type
    openai.api_version = config.api_version

    response = openai.ChatCompletion.create(
        engine=config.engine,
        messages=[
            {"role": "system", "content": "You are a helpful AI assistant."},
            {"role": "user", "content": question},
        ],
        user=userId
    )

    return response['choices'][0]['message']['content']

`openAIRequestWithPastMessages(pastMsg, question, userId)`

This function builds upon openAIRequest by including past conversation messages, providing continuity in responses. The function uses loadPastMessages to retrieve stored messages and appends them to the current question:

def openAIRequestWithPastMessages(pastMsg=[], question="", userId=""):
    openai.api_key = config.api_key
    openai.api_base = config.api_endpoint
    openai.api_type = config.api_type
    openai.api_version = config.api_version

    msg = [{'role': 'system', 'content': 'You are a helpful AI assistant.'}]
    for m in pastMsg:
        msg.append(m)
    msg.append({'role': 'user', 'content': question})

    try:
        response = openai.ChatCompletion.create(
            engine=config.engine,
            messages=msg,
            user=userId
        )
        answer = response['choices'][0]['message']['content']
    except Exception as e:
        answer = "Sorry, I can not answer your question. Please try again."
        print(e)

    pastMsg.append({'role': 'user', 'content': question})
    pastMsg.append({'role': 'assistant', 'content': answer})
    savePastMessages(userId, pastMsg)

    return answer

2. Loading and Saving Past Messages

To retain the context across sessions, the chatbot stores past messages in a file unique to each user. This allows the chatbot to reference previous exchanges for more natural conversations.

`loadPastMessages(uid)`

This function retrieves past conversations from a file:

def loadPastMessages(uid):
    pastMessages = []
    dataPath = config.data_dir + "/" +  uid
    if os.path.exists(dataPath):
        try:
            with open(dataPath, "r") as f:
                pastMessages = f.read()
        except:
            return []
    return ast.literal_eval(pastMessages) if pastMessages else []

`savePastMessages(uid, msg)`

This function saves the current conversation messages, maintaining a rolling context by removing the oldest entries if a set limit is reached:

def savePastMessages(uid, msg):
    dataPath = config.data_dir + "/" + uid
    if len(msg) > int(config.past_message_included * 2):
        msg = msg[2:]
    try:
        with open(dataPath, "w") as f:
            f.write(str(msg))
        return True
    except:
        return False

3. Running the Chatbot

The main() function initiates the chatbot in the terminal, continuously prompting the user for input until they type “exit” or “bye.”

def main():
    userInput = ''
    userId = "user_123"
    print(f'OPENAI CHATBOT {config.version} - Engine: {config.engine}')
    print("Enter 'bye' or 'exit' to quit")
    while ((userInput.lower() != 'exit') and (userInput.lower() != 'bye')):
        userInput = input("You: ")
        if userInput.lower() in ['exit', 'bye']:
            print('Goodbye. See you!')
            sys.exit(0)
        print("OpenAI-Bot: " + openAIRequestWithPastMessages(loadPastMessages(userId), userInput, userId))
    print('Goodbye. See you!')

To run the chatbot, execute the following command:

python chatbot.py

Customizing the Chatbot

This chatbot is highly customizable. Here are a few ideas:

Personalize System Messages: Change {"role": "system", "content": "You are a helpful AI assistant."} to define a new persona.
Limit Context for Efficiency: Modify past_message_included in config.py to change how much context is retained.
Experiment with API Parameters: Adjust temperature, max_tokens, or other API settings to influence response style and length.

Deploying the Chatbot

Once tested, consider deploying the chatbot on a platform like Heroku or an internal server. Update environment variables to securely store your OpenAI API key.

Conclusion

This OpenAI Chatbot project is a straightforward yet flexible way to harness the power of OpenAI's language models. Whether for support, education, or entertainment, this chatbot provides a strong foundation for engaging, AI-driven conversations.

To dive into the code, explore the OpenAI Chatbot repository on GitHub, and start customizing your own AI assistant!

Happy coding!

Deploy an OpenAI Chatbot with Lambda on AWS

VIET QUOC NGUYEN — Mon, 20 May 2024 13:22:55 +0000

DEV Community: VIET QUOC NGUYEN

Set up Trivy Scanner in GitLab CI

Setting Up a GitLab CI Pipeline for Security Scanning

Prerequisites

Step 1: Create the .gitlab-ci.yml File

Explanation of the Job Configuration

Step 2: Commit and Push Your .gitlab-ci.yml File

Step 3: Monitor the Pipeline

Conclusion

A Simple OpenAI Chatbot

Build Your Own OpenAI-Powered Chatbot with Python: A Deep Dive into the OpenAI Chatbot Repository

Project Overview

Key Features

Getting Started

Prerequisites

Step 1: Clone the Repository

Step 2: Install Dependencies

Step 3: Configure the Chatbot

Code Walkthrough

1. The Core Functions

openAIRequest(question, userId)

openAIRequestWithPastMessages(pastMsg, question, userId)

2. Loading and Saving Past Messages

loadPastMessages(uid)

savePastMessages(uid, msg)

3. Running the Chatbot

Customizing the Chatbot

Deploying the Chatbot

Conclusion

Deploy an OpenAI Chatbot with Lambda on AWS

Step 1: Create the `.gitlab-ci.yml` File

Step 2: Commit and Push Your `.gitlab-ci.yml` File

`openAIRequest(question, userId)`

`openAIRequestWithPastMessages(pastMsg, question, userId)`

`loadPastMessages(uid)`

`savePastMessages(uid, msg)`