A complete microservice application setup with a Flutter app, MongoDB, and RabbitMQ, along with all the necessary files and folder structure. The setup uses Docker Compose to orchestrate the services.
Folder Structure
```
microservice-app/
│
├── backend/
│ ├── Dockerfile
│ ├── requirements.txt
│ ├── main.py
│ └── config.py
│
├── frontend/
│ ├── Dockerfile
│ ├── pubspec.yaml
│ └── lib/
│ └── main.dart
│
├── docker-compose.yml
└── README.md
```
1. `docker-compose.yml`
```yaml
version: '3.8'
services:
backend:
build: ./backend
container_name: backend
ports:
- "8000:8000"
depends_on:
- mongodb
- rabbitmq
environment:
- MONGO_URI=mongodb://mongodb:27017/flutterdb
- RABBITMQ_URI=amqp://guest:guest@rabbitmq:5672/
networks:
- microservice-network
mongodb:
image: mongo:latest
container_name: mongodb
ports:
- "27017:27017"
networks:
- microservice-network
rabbitmq:
image: rabbitmq:3-management
container_name: rabbitmq
ports:
- "5672:5672"
- "15672:15672"
networks:
- microservice-network
frontend:
build: ./frontend
container_name: frontend
ports:
- "8080:8080"
depends_on:
- backend
networks:
- microservice-network
networks:
microservice-network:
driver: bridge
```
2. Backend Service
2.1 `backend/Dockerfile`
```dockerfile
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "main.py"]
```
2.2 `backend/requirements.txt`
```txt
fastapi
pymongo
pika
uvicorn
```
2.3 `backend/config.py`
```python
import os
MONGO_URI = os.getenv('MONGO_URI')
RABBITMQ_URI = os.getenv('RABBITMQ_URI')
```
2.4 `backend/main.py`
```python
from fastapi import FastAPI
from pymongo import MongoClient
import pika
import config
app = FastAPI()
client = MongoClient(config.MONGO_URI)
db = client.flutterdb
# RabbitMQ Connection
params = pika.URLParameters(config.RABBITMQ_URI)
connection = pika.BlockingConnection(params)
channel = connection.channel()
@app.get("/")
async def read_root():
return {"message": "Backend service running"}
@app.post("/data")
async def create_data(data: dict):
db.collection.insert_one(data)
channel.basic_publish(exchange='', routing_key='flutter_queue', body=str(data))
return {"message": "Data inserted and sent to RabbitMQ"}
```
3. Frontend Service
3.1 `frontend/Dockerfile`
```dockerfile
FROM cirrusci/flutter:stable
WORKDIR /app
COPY . .
RUN flutter build web
CMD ["flutter", "run", "-d", "chrome"]
```
3.2 `frontend/pubspec.yaml`
```yaml
name: flutter_app
description: A new Flutter project.
version: 1.0.0+1
environment:
sdk: ">=2.7.0 <3.0.0"
dependencies:
flutter:
sdk: flutter
http: ^0.13.3
dev_dependencies:
flutter_test:
sdk: flutter
```
#### 3.3 `frontend/lib/main.dart`
```dart
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: MyHomePage(),
);
}
}
class MyHomePage extends StatefulWidget {
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
Future<void> sendData() async {
final response = await http.post(
Uri.parse('http://backend:8000/data'),
body: {'key': 'value'},
);
print('Response status: ${response.statusCode}');
print('Response body: ${response.body}');
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('Flutter Microservice App'),
),
body: Center(
child: ElevatedButton(
onPressed: sendData,
child: Text('Send Data to Backend'),
),
),
);
}
}
```
4. `README.md`
```markdown
# Microservice Application
## Overview
This is a microservice application setup consisting of a Flutter app (frontend), a FastAPI service (backend), MongoDB, and RabbitMQ. All services are orchestrated using Docker Compose.
## How to Run
1. Clone the repository:
```bash
git clone https://github.com/your-repo/microservice-app.git
cd microservice-app
```
2. Build and run the containers:
```bash
docker-compose up --build
```
3. Access the services:
- Frontend: `http://localhost:8080`
- Backend: `http://localhost:8000`
- RabbitMQ Management: `http://localhost:15672`
- MongoDB: `mongodb://localhost:27017`
```
### Instructions to Run the Application
1. Ensure Docker and Docker Compose are installed on your machine.
2. Place the folder structure and files as described above.
3. Navigate to the root of the `microservice-app` folder.
4. Run `docker-compose up --build` to build and start the application.
5. Access the frontend on `http://localhost:8080`, backend on `http://localhost:8000`, and RabbitMQ Management UI on `http://localhost:15672`.
This setup provides a working microservice application with a Flutter frontend, FastAPI backend, MongoDB for storage, and RabbitMQ for messaging.
