.env

@@ -0,0 +1,5 @@
+POSTGRES_PASSWORD=openpgpwd
+POSTGRES_USER=openpg
+POSTGRES_DB=pulumi
+ODOO_PASSWORD=admin
+GRAFANA_PASSWORD=grafana_pwd

Pulumi.yaml

@@ -1,5 +1,5 @@
-name: pulumi4
+name: projet
-description: pulumi
+description: projet pulumi docker
 runtime:
   name: python
   options:

__main__.py

@@ -1,82 +1,81 @@
 import pulumi
 import pulumi_docker as docker
 import json
+import os
 
-# Load the configuration from the JSON file
+# Load the JSON configuration file
-with open('config.json') as f:
+try:
-    config_data = json.load(f)
+    with open("config.json", "r") as f:
+        containers_data = json.load(f)
+except FileNotFoundError:
+    raise Exception("Error: 'config.json' file not found.")
 
-# Create a Docker network
+# Create the network
-network = docker.Network("testNetwork")
+try:
+    network = docker.Network("testNetwork")
+     
+except Exception as e:
+    pulumi.log.error(f"Failed to create network: {e}")
+    network = None
 
-# Initialize the containers list
+# Create containers
-containers = []
+for container in containers_data.get("containers", []):
-
+    instances = container.get("instances", 1)
-
+    for i in range(instances):
-# Initialize the URL dictionary for export
+        container_name = f"{container['name']}-{i}" if instances > 1 else container["name"]
-urls = {}
-
-# Create containers based on the configuration
-for container in config_data["containers"]:
-    container_name = container["name"]
-    container_envs = [f"{key}={value}" for key, value in container.get("env", {}).items()]
-
-    # Create the container
-    docker_container = docker.Container(
-        container_name,
-        name=container_name,
-        image=container["image"],
-        envs=container_envs,
-        ports=[docker.ContainerPortArgs(
-            internal=port["internal"],
-            external=port["external"]
-        ) for port in container["ports"]],
-        network_mode=network.name,
-        command=container.get("command", None) or container.get("entrypoint", None),
-        ##container.get("entrypoint", "/usr/local/bin/entrypoint.sh") 
         
-        volumes=[docker.ContainerVolumeArgs(
+        # Configure volumes
-            host_path=vol["host_path"],
+        volumes = {}
-            container_path=vol["container_path"]
+        for volume in container.get("volumes", []):
-        ) for vol in container.get("volumes", [])]
+            try:
-    )
+                if "volume_name" in volume and volume["volume_name"] not in volumes:
-    containers.append(docker_container)
+                    volumes[volume["volume_name"]] = docker.Volume(volume["volume_name"])
+            except Exception as e:
+                pulumi.log.error(f"Failed to create volume {volume.get('volume_name')}: {e}")
+        volumes_config = []
+        try:
+            if "volumes" in container:
+                volumes_config = [
+                    docker.ContainerVolumeArgs(
+                        container_path=volume["container_path"],
+                        volume_name=volumes[volume["volume_name"]].name
+                    ) if "volume_name" in volume else
+                    docker.ContainerVolumeArgs(
+                        container_path=volume["container_path"],
+                        host_path=os.path.abspath(volume["host_path"])
+                    )
+                    for volume in container["volumes"]
+                ]
+        except KeyError as e:
+            pulumi.log.warn(f"Missing key in volume configuration: {e}")
+        except Exception as e:
+            pulumi.log.error(f"Error configuring volumes for container {container_name}: {e}")
 
-    # Add the URLs for the container
+        # Create the container
-    for port in container["ports"]:
+        try:
-        urls[f"{container_name}_url"] = f"http://localhost:{port['external']}"
+            container_resource = docker.Container(
-
+                container_name,
-# Scale Prometheus containers
+                image=container["image"],
-for i in range(config_data.get("prometheus_scale", 1)):  # Default to 1 if not specified
+                hostname=container_name,
-    prometheus_instance = docker.Container(
+                envs=[
-        f"prometheus-instance-{i}",
+                    f"{key}={value}" for key, value in container.get("envs", {}).items()
-        name=f"prometheus-{i}",
+                ] if "envs" in container else [],
-        image="prom/prometheus:latest",
+                ports=[
-        ports=[docker.ContainerPortArgs(internal=9090, external=9090 + i)],
+                    docker.ContainerPortArgs(
-        network_mode=network.name
+                        internal=port["internal"],
-    )
+                        external=port["external"] + i
-    containers.append(prometheus_instance)
+                    ) for port in container.get("ports", [])
-
+                ] if "ports" in container else [],
-    # Add the Prometheus URLs
+                volumes=volumes_config,
-    urls[f"prometheus_{i}_url"] = f"http://localhost:{9090 + i}"
+                network_mode=network.name if network else None,
-
+            )
-# Scale Fluentd containers
+            ports = container.get("ports", [])
-fluentd_scale = config_data.get("fluentd_scale", 1)  # Default to 1 if not specified
+            if ports:
-
+                for port in ports:
-for i in range(fluentd_scale):  # This will scale based on the value from config_data
+                    external_port = port["external"] + i
-    fluentd_instance = docker.Container(
+                    pulumi.export(
-        f"fluentd-instance-{i}",
+                        f"{container_name}_url",
-        name=f"fluentd-{i}",
+                        f"http://localhost:{external_port}" 
-        image="fluent/fluentd:v1.14-1",  # Corrected image name
+                    )
-        ports=[docker.ContainerPortArgs(internal=24224, external=24224 + i)],  # Assign unique external port for each container
+        except Exception as e:
-        network_mode=network.name
+            pulumi.log.error(f"Failed to create container {container_name}: {e}")
-    )
-    containers.append(fluentd_instance)
-
-    # Add the Fluentd URLs
-    urls[f"fluentd_{i}_url"] = f"http://localhost:{24224 + i}"
-
-# Export network and container details
-pulumi.export("network_name", network.name)
-pulumi.export("containers", [c.name for c in containers])
-pulumi.export("urls", urls)

backup.Dockerfile

@@ -0,0 +1,16 @@
+# Use the Alpine image as the base
+FROM alpine:latest as backup_custom
+
+# Copy the entrypoint script into the container
+COPY entrypoint_backup.sh /usr/local/bin/entrypoint_backup.sh
+
+# Switch to root user for setup
+USER root
+
+# Make the entrypoint script executable
+RUN chmod +x /usr/local/bin/entrypoint_backup.sh
+
+# Set the new entrypoint
+ENTRYPOINT ["/usr/local/bin/entrypoint_backup.sh"]
+
+

config.json

@@ -1,51 +1,114 @@
 {
     "containers": [
       {
-        "name": "postgres",
+        "name": "admin",
-        "image": "postgres:16.5",
+        "image": "postgres:latest",
-        "env": {
+        "envs": {
-          "POSTGRES_USER": "odoo",
+          "POSTGRES_DB": "admin",
-          "POSTGRES_PASSWORD": "odoo",
+          "POSTGRES_USER": "admin",
-          "POSTGRES_DB": "postgres",
+          "POSTGRES_PASSWORD": "admin"
-          "POSTGRES_HOST_AUTH_METHOD": "trust"
         },
-        "ports": [
+        "network_mode": "testNetwork",
-          {"internal": 5432, "external": 5432}
+        "ports": [{"internal": 5432, "external": 5432}],
-        ],
         "volumes": [
-          {"host_path": "/local/path/postgresql/data", "container_path": "/var/lib/postgresql/data"}
+          {
+            "container_path": "/var/lib/postgresql/data",
+            "volume_name": "postgres-data"
+          },
+          {
+            "container_path": "/etc/postgresql/postgresql.conf",
+            "host_path": "./postgresql.conf"
+          }
         ]
       },
+      
+      {
+        "name": "postgres_exporter",
+        "image": "wrouesnel/postgres_exporter:latest",
+        "envs": {
+          "DATA_SOURCE_NAME": "postgresql://admin:admin@admin:5432/admin?sslmode=disable" 
+        },
+        "network_mode": "testNetwork",
+        "ports": [{"internal": 9187, "external": 9187}]
+      },
+
+
       {
         "name": "odoo",
-        "image": "odoo:latest",
+        "image": "odoo_custom",
-        "env": {
+        "envs": {
-          "HOST": "postgres",
+          "HOST": "admin",
-          "USER": "odoo",
+          "USER": "admin",
-          "PASSWORD": "odoo",
+          "PASSWORD": "admin",
-          "DATABASE": "postgres",
+          "DATABASE": "admin",
           "ODOO_PASSWORD": "admin"
         },
-        "ports": [
+        "network_mode": "testNetwork",
-          {"internal": 8069, "external": 8069}
+        "ports": [{"internal": 8069, "external": 8069}],
-        ],
+        "instances": 3,
-        "command": [
+        "volumes": [
-          "/bin/bash", "-c", "until pg_isready -h postgres -U odoo; do echo 'Waiting for PostgreSQL...'; sleep 2; done; odoo -i base"
+          {
+            "host_path": "./odoo.conf",
+            "container_path": "/etc/odoo/odoo.conf"
+          }
         ]
       },
       {
         "name": "grafana",
         "image": "grafana/grafana:latest",
-        "env": {
+        "envs": {
           "GF_SECURITY_ADMIN_PASSWORD": "grafana_pwd",
           "GF_DATASOURCES_PROMETHEUS_URL": "http://prometheus:9090"
         },
-        "ports": [
+        "network_mode": "testNetwork",
-          {"internal": 3000, "external": 3000}
+        "ports": [{"internal": 3000, "external": 3000}],
+        "instances": 2
+      },
+      {
+        "name": "prometheus",
+        "image": "prom/prometheus:latest",
+        "network_mode": "testNetwork",
+        "ports": [{"internal": 9090, "external": 9090}],
+        "volumes": [
+          {
+            "container_path": "/prometheus",
+            "volume_name": "prometheus-data"
+          },
+          {
+            "container_path": "/etc/prometheus/prometheus.yml",
+            "host_path": "./prometheus.yml"
+          }
+        ]
+      },
+      {
+        "name": "fluentd",
+        "image": "fluent/fluentd:v1.13-1",
+        "network_mode": "testNetwork",
+        "ports": [{"internal": 24224, "external": 24224}],
+        "volumes": [
+          {
+            "container_path": "/fluentd/etc/fluent.conf",
+            "host_path": "./fluent.conf"
+          }
+        ]
+      },
+      {
+        "name": "backup",
+        "image": "backup_custom",
+        "envs": {
+            "POSTGRES_HOST": "admin",
+            "POSTGRES_DB": "admin",
+            "POSTGRES_USER": "admin",
+            "POSTGRES_PASSWORD": "admin"
+        },
+        "network_mode": "testNetwork",
+        "volumes": [
+          {
+            "container_path": "/backup",
+            "volume_name": "backup-data"
+          }
         ]
       }
-    ],
+    ]
-    "prometheus_scale": 2,
-    "fluentd_scale": 2
   }
   

entrypoint.sh

@@ -1,6 +0,0 @@
-# Wait for PostgreSQL to be ready
-until pg_isready -h $HOST -U $USER; do
-  echo "Waiting for PostgreSQL..."
-  sleep 2
-done
-

entrypoint_backup.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+# Install PostgreSQL client
+apk add --no-cache postgresql-client
+
+# Wait until the PostgreSQL server is ready
+until pg_isready -h admin -U admin; do
+    echo "Waiting for PostgreSQL..."
+    sleep 2
+done
+

entrypoint_odoo.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+sleep10
+odoo -i base

fluent.conf

@@ -0,0 +1,14 @@
+<source>
+  @type forward
+  port 8069  # Odoo logs
+</source>
+
+<source>
+  @type forward
+  port 3000  # Grafana logs
+</source>
+
+<match *>
+  @type file
+  path /fluentd/logs/collected-logs
+</match>

odoo.Dockerfile

@@ -0,0 +1,14 @@
+# Use the existing Odoo image as the base
+FROM odoo:latest as odoo-custom
+
+# Copy the entrypoint script into the container
+COPY entrypoint_odoo.sh /usr/local/bin/entrypoint_odoo.sh
+
+USER root
+
+# Make the entrypoint script executable
+RUN chmod +x /usr/local/bin/entrypoint_odoo.sh
+
+# Set the new entrypoint
+ENTRYPOINT ["/usr/local/bin/entrypoint_odoo.sh"]
+

odoo.conf

@@ -0,0 +1,7 @@
+[options]
+db_host = admin
+db_port = 5432
+db_user = admin
+db_password = admin
+default_productivity_apps = True
+db_name = admin

postgresql.conf

@@ -0,0 +1,3 @@
+shared_preload_libraries = 'pg_stat_statements'
+pg_stat_statements.max = 10000
+pg_stat_statements.track = all

projetPulumi

@@ -0,0 +1 @@
+Subproject commit 2281e6eb41d8540e40e08a3f1f06ca9c179b86e0

prometheus.yml

@@ -0,0 +1,23 @@
+global:
+  scrape_interval: 15s  # How often to scrape metrics (every 15 seconds)
+
+scrape_configs:
+  - job_name: 'postgres'  # For scraping PostgreSQL
+    static_configs:
+      - targets: ['postgres:5432']
+
+  - job_name: 'odoo'  # For scraping Odoo
+    static_configs:
+      - targets: ['odoo:8069']
+
+  - job_name: 'grafana'  # For scraping Grafana
+    static_configs:
+      - targets: ['grafana:3000']
+
+  - job_name: 'postgres_exporter'
+    static_configs:
+      - targets: ['postgres_exporter:9187']      
+
+
+
+