Scribd
Upload
36 views

Devops Test

Uploaded by

demy2014
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
36 views

Devops Test

Uploaded by

demy2014
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 8

Step-by-Step Guide to Set Up a Simple Microservice Architecture

In this guide, we'll set up a microservice architecture with four components using
Python, Docker, and GitHub Actions. We'll document the process thoroughly to ensure
clarity and ease of understanding.

Step 1: Set Up Project Structure


- Create a directory structure for your project:

microservice-architecture/
├── api-service/
│ ├── app/
│ ├── Dockerfile
│ ├── requirements.txt
│ └── tests/
├── frontend/
│ ├── public/
│ ├── src/
│ ├── Dockerfile
│ └── package.json
├── auth-service/
│ ├── app/
│ ├── Dockerfile
│ ├── requirements.txt
│ └── tests/
├── database/
│ └── init.sql
├── docker-compose.yml
└── .github/
└── workflows/
└── ci-cd.yml

Step 2: Develop the API Service


- Create the API Service:

Use Flask to handle API requests and interact with the database.

api-service/app/main.py:

from flask import Flask, jsonify


from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] =
'postgresql://user:password@db/microservice'
db = SQLAlchemy(app)

class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)

@app.route('/items', methods=['GET'])
def get_items():
items = Item.query.all()
return jsonify([{"id": item.id, "name": item.name} for item in items])

if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000)
Set Up the Dockerfile:
api-service/Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app/main.py"]
Define Requirements:

api-service/requirements.txt:

Flask
Flask-SQLAlchemy
psycopg2-binary

Create Unit Tests:

api-service/tests/test_api.py:

import unittest
from app.main import app, db, Item

class TestAPI(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
db.create_all()
db.session.add(Item(name="Test Item"))
db.session.commit()

def tearDown(self):
db.session.remove()
db.drop_all()

def test_get_items(self):
response = self.app.get('/items')
self.assertEqual(response.status_code, 200)
data = response.get_json()
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['name'], 'Test Item')

if __name__ == "__main__":
unittest.main()

Step 3: Develop the Frontend


- Create a Simple Frontend:

Use HTML and JavaScript to display data from the API.


frontend/src/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Frontend</title>
</head>
<body>
<h1>Items</h1>
<ul id="items"></ul>
<script>
fetch('http://localhost:5000/items')
.then(response => response.json())
.then(data => {
const itemsList = document.getElementById('items');
data.forEach(item => {
const li = document.createElement('li');
li.textContent = item.name;
itemsList.appendChild(li);
});
});
</script>
</body>
</html>

Set Up the Dockerfile:

frontend/Dockerfile:

FROM nginx:alpine
COPY src /usr/share/nginx/html

Step 4: Develop the Auth Service


- Create the Auth Service:

Use Flask to handle JWT token verification and user authentication.


auth-service/app/main.py:

from flask import Flask, request, jsonify


import jwt

app = Flask(__name__)
SECRET_KEY = 'your_secret_key'

@app.route('/verify', methods=['POST'])
def verify_token():
token = request.json.get('token')
try:
jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
return jsonify({"message": "Token is valid"}), 200
except jwt.ExpiredSignatureError:
return jsonify({"message": "Token has expired"}), 401
except jwt.InvalidTokenError:
return jsonify({"message": "Invalid token"}), 401

if __name__ == "__main__":
app.run(host='0.0.0.0', port=5001)
Set Up the Dockerfile:

auth-service/Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app/main.py"]
Define Requirements:

auth-service/requirements.txt:

Flask
PyJWT

Create Unit Tests:

auth-service/tests/test_auth.py:

import unittest
from app.main import app, SECRET_KEY
import jwt

class TestAuth(unittest.TestCase):
def setUp(self):
self.app = app.test_client()

def test_verify_token(self):
token = jwt.encode({"user": "test"}, SECRET_KEY, algorithm="HS256")
response = self.app.post('/verify', json={"token": token})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()["message"], "Token is valid")

def test_invalid_token(self):
response = self.app.post('/verify', json={"token": "invalid_token"})
self.assertEqual(response.status_code, 401)
self.assertEqual(response.get_json()["message"], "Invalid token")

if __name__ == "__main__":
unittest.main()

Step 5: Set Up the Database


- Initialize the Database:

Use a simple SQL initialization script.


database/init.sql:

CREATE DATABASE microservice;


CREATE TABLE items (
id SERIAL PRIMARY KEY,
name VARCHAR(80) NOT NULL
);
INSERT INTO items (name) VALUES ('Item 1'), ('Item 2');
Step 6: Set Up Docker Compose
Define Docker Compose Configuration:

docker-compose.yml:

version: '3'
services:
db:
image: postgres:latest
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: password
POSTGRES_DB: microservice
volumes:
- ./database/init.sql:/docker-entrypoint-initdb.d/init.sql

api-service:
build: ./api-service
ports:
- "5000:5000"
depends_on:
- db

auth-service:
build: ./auth-service
ports:
- "5001:5001"

frontend:
build: ./frontend
ports:
- "80:80"

Step 7: Configure CI/CD with GitHub Actions


- Create CI/CD Workflow:

.github/workflows/ci-cd.yml:

name: CI/CD Pipeline

on:
push:
branches: [ main ]
pull_request:
branches: [ main ]

jobs:
build-and-test:
runs-on: ubuntu-latest

services:
docker:
image: docker:19.03.12
options: --privileged

steps:
- name: Checkout code
uses: actions/checkout@v2

- name: Set up Python


uses: actions/setup-python@v2
with:
python-version: '3.9'

- name: Install dependencies and test API service


run: |
cd api-service
python -m pip install --upgrade pip
pip install -r requirements.txt
python -m unittest discover tests

- name: Install dependencies and test Auth service


run: |
cd auth-service
python -m pip install --upgrade pip
pip install -r requirements.txt
python -m unittest discover tests

- name: Build Docker images


run: |
docker-compose build

- name: Run services


run: |
docker-compose up -d

- name: Run tests


run: |
# Add integration tests if necessary

- name: Push Docker images to Docker Hub


env:
DOCKER_HUB_USERNAME: ${{ secrets.DOCKER_HUB_USERNAME }}
DOCKER_HUB_ACCESS_TOKEN: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
run: |
docker login -u $DOCKER_HUB_USERNAME -p $DOCKER_HUB_ACCESS_TOKEN
docker-compose push

Step 8: Write the README File


Create a comprehensive README file explaining the project.

README.md:

# Microservice Architecture

## Overview

This project demonstrates a simple microservice architecture with four components:


1. **API Service**: Handles API requests and interacts with the database.
2. **Frontend**: A simple static website that displays data retrieved from the API.
3. **Database**: Stores the data accessed by the API service.
4. **Centralized Auth Service**: Verifies JWT tokens and user authentication.

## Project Structure

microservice-architecture/
├── api-service/
├── frontend/
├── auth-service/
├── database/
├── docker-compose.yml
└── .github/
└── workflows/

## Getting Started

### Prerequisites

- Docker
- Docker Compose
- GitHub account (for CI/CD)

### Installation

1. Clone the repository:


```bash
git clone https://github.com/your-username/microservice-architecture.git
cd microservice-architecture
```

2. Build and run the services:


```bash
docker-compose up --build
```

### API Service

The API service is built with Flask and provides a simple endpoint to retrieve a
list of items.

- **Endpoint**: `/items`
- **Method**: `GET`
- **Response**: JSON array of items

### Auth Service

The Auth service is built with Flask and uses JWT for authentication.

- **Endpoint**: `/verify`
- **Method**: `POST`
- **Request Body**: `{"token": "your_jwt_token"}`
- **Response**: JSON message indicating token validity

### Frontend

The frontend is a simple static website that fetches data from the API service and
displays it.

### Database

A PostgreSQL database initialized with a script to create the `items` table and
insert sample data.

## CI/CD

This project uses GitHub Actions for CI/CD. The workflow is defined in
`.github/workflows/ci-cd.yml`.

- **Build and Test**: Installs dependencies and runs unit tests for API and Auth
services.
- **Docker Build and Push**: Builds Docker images and pushes them to Docker Hub.
- **Deployment**: Deploys the services using Docker Compose.

## Contributions

Contributions are welcome! Please open an issue or submit a pull request.

## License
This project is licensed under the MIT License.

Step 9: Push to GitHub


Initialize Git repository:

git init

Add files and commit:

git add .
git commit -m "Initial commit"

Push to GitHub:

git remote add origin https://github.com/your-username/microservice-


architecture.git
git push -u origin main

Final Steps:

Set up secrets in GitHub repository:

DOCKER_HUB_USERNAME
DOCKER_HUB_ACCESS_TOKEN
Verify the CI/CD pipeline:

Make a commit to the main branch and ensure the pipeline runs successfully.

- By following these steps, you will have a complete microservice architecture


setup, containerized with Docker, and a CI/CD pipeline configured with GitHub
Actions.

You might also like