Dwayo DevBlog

Tag: aws

  • Setting Up Seamless CI/CD with GitLab CI and AWS

    Continuous Integration (CI) and Continuous Deployment (CD) are integral practices in modern software development, ensuring that code is consistently tested, built, and deployed. GitLab CI, coupled with the powerful cloud infrastructure of AWS (Amazon Web Services), provides a robust platform for automating these processes. In this guide, we will walk through the steps to set up a seamless CI/CD pipeline using GitLab CI and AWS.

    Prerequisites:

    1. GitLab Account: Ensure you have a GitLab account and a repository for your project.
    2. AWS Account: Set up an AWS account and obtain necessary credentials.

    Setting Up GitLab CI:

    1. Create a .gitlab-ci.yml File:
      In the root of your GitLab repository, create a .gitlab-ci.yml file. This file defines the CI/CD pipeline stages, jobs, and scripts.
       stages:
     - build
     - test
     - deploy

   before_script:
     - apt-get update -qy
     - apt-get install -y python3-pip
     - pip3 install awscli

   build:
     script:
       - echo "Building your application"

   test:
     script:
       - echo "Running tests"

   deploy:
     script:
       - aws s3 sync ./your-deployment-directory s3://your-s3-bucket
    1. Configure GitLab Runner:
      GitLab Runners execute the jobs defined in your .gitlab-ci.yml file. You can use shared or specific runners depending on your needs. Install and register a runner following the instructions in the GitLab documentation.

    Setting Up AWS for Deployment:

    1. Create an S3 Bucket:
      In the AWS Management Console, create an S3 bucket to store your deployment artifacts. Ensure the bucket name is unique and set appropriate permissions.
    2. Configure AWS Credentials:
      Set up AWS credentials on your GitLab CI/CD environment. This can be achieved by adding AWS Access Key ID and Secret Access Key as environment variables in your GitLab CI/CD settings.

    Setting Up Deployment Script:

    1. Install AWS CLI in CI/CD Environment:
      In the .gitlab-ci.yml file, install the AWS CLI as part of the before_script section.
    2. Define Deployment Script:
      Modify the deployment stage in .gitlab-ci.yml to include the necessary AWS CLI commands for deploying your application to AWS.
       deploy:
     script:
       - aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID
       - aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY
       - aws s3 sync ./your-deployment-directory s3://your-s3-bucket
    1. Secure AWS Credentials:
      Utilize GitLab CI/CD environment variables to securely store AWS credentials. Avoid hardcoding sensitive information in your scripts.

    Conclusion:

    By integrating GitLab CI with AWS, you’ve established a robust CI/CD pipeline for your project. Commits to your GitLab repository will trigger automated builds, tests, and deployments, ensuring a smooth and efficient development process. This setup lays the foundation for scalable and reliable software delivery, fostering collaboration and accelerating your release cycles.

  • AWS Greengrass

    AWS IoT Greengrass is a service that extends AWS Cloud capabilities to local devices, making it possible to run AWS Lambda functions on edge devices. This allows you to process data locally, reducing the need for constant communication with the cloud.

    Scenario

    You have a temperature sensor deployed in a remote location, and you want to monitor the temperature readings locally using AWS IoT Greengrass. When the temperature exceeds a certain threshold, you want to trigger a local action, such as turning on a fan or sending an alert.

    Steps

    Set Up AWS IoT Core:

    • Create an AWS IoT Core Thing for your temperature sensor.
    • Attach the required policies to your Thing to allow it to communicate with AWS IoT Core.

    Set Up AWS IoT Greengrass:

      • Create a Greengrass group and core.
      • Add your temperature sensor Thing to the Greengrass group.
      • Deploy the Greengrass group configuration to your devices.

      Create Lambda Function:

      • Write a Lambda function in the AWS Lambda console that reads the temperature from the sensor.
      • Add logic to compare the temperature against a threshold and take action if the threshold is exceeded. For example: 
      import json
import greengrasssdk

client = greengrasssdk.client('iot-data')

def lambda_handler(event, context):
    temperature = event['temperature']
    threshold = 30  # Set your desired threshold

    if temperature > threshold:
        # Temperature exceeds threshold, take action
        message = "High temperature alert! Temperature is {} degrees.".format(temperature)
        client.publish(topic='temperature_alert', payload=json.dumps({'message': message}))

    return {'statusCode': 200, 'body': json.dumps('Temperature checked successfully.')}

      Configure Subscription:

      • Configure a subscription in the Greengrass group to send temperature data to the Lambda function.
      • Define a topic for communication between the temperature sensor and the Lambda function.

      Deploy and Test:

      • Deploy the updated Greengrass group configuration to your devices.
      • Simulate temperature changes or use your actual temperature sensor to trigger the Lambda function when the temperature exceeds the threshold.

      Monitor:

      • Monitor the AWS IoT Greengrass logs to see the temperature readings and any alerts triggered by the Lambda function.

      This example demonstrates how AWS IoT Greengrass can be used to monitor a temperature sensor locally and take actions based on the sensor data without relying on constant communication with the cloud. Adjust the Lambda function and configuration based on your specific requirements and use case.