Institutional Gramar – un outils pour penser la gestions des ressources

geekeries

Du 19 au 24 juin 2023, j’ai pu participer au congrès de l’IASC (International Association for the Study of the Commons) qui s’est déroulé à Nairobi. La thématique de la conférence était « the commons we want« , a donné lieu à une très grande diversité de panels en parallèle et donc a un programme riche et varié.

J’ai eu la chance, presque un peu par hasard, de participer au workshop, puis au panel sur l’Institutional Gramar (IG) proposé par Saba Siddiki, Christopher Frantz, et Ute Brady. Ce qui m’a permis une introduction rapide aux potentialités de la formalisation proposée.

Une synthèse de l’institutional Grammar

L’approche de la Grammaire institutionnelle (Institutional Grammar ou IG en anglais) est une approche définie conceptuellement par Crawford et Ostrom en 1995. Au fil des 25 dernières années, cette approche a été largement utilisée dans l’analyse des politiques, la modélisation informatique, etc.

l’IG appelée « Institutional Grammar 2.0 », actualise l’approche pour de nouvelles applications dans divers domaines de recherche. Cette version 2.0 offre une représentation plus précise et complète des informations institutionnelles, en mettant l’accent sur le sens, les fonctions et les effets des déclarations institutionnelles.

La formalisation des informations en passant par un encodage particulier et non ambigu (ou en tout cas moins ambigu que le langage naturel), indépendamment du domaine d’application et de la méthode analytique utilisée, ouvre des perspectives extrêmement intéressantes et déjà largement utilisées en termes d’analyse comparée et d’évolution temporelle des organisations. En soulignant l’importance de l’analyse institutionnelle, il me semble que l’IG est adaptable à diverses situations d’actions.

La formalisation proposée par l’IG 2.0 repose sur une grammaire générative décrite dans la table ci dessous par Watkins et Westphal (2016).

Tableau reprenant les composants de l’IG dans le papier de Watkins et Westphal (2016)

L’intérêt de l’Institutional Grammar réside pour moi dans le cadre d’analyse rigoureux qu’elle offre et qui donne des outils holistiques pour étudier le fonctionnement des institutions et des organisations. En utilisant cette approche, les chercheurs peuvent mieux comprendre comment les règles, les normes et les valeurs institutionnelles influencent les comportements et les décisions des acteurs impliqués.

Cette compréhension approfondie des structures institutionnelles et de leurs effets permet de proposer des solutions plus adaptées pour résoudre les problèmes et les défis auxquels sont confrontées les organisations. L’Institutional Grammar peut également aider à identifier les facteurs qui favorisent ou entravent l’efficacité des institutions, ce qui peut avoir des implications importantes pour l’amélioration des politiques publiques et des pratiques organisationnelles.

De retour dans la vraie vie, j’ai essayé de comprendre plus finement la méthodologie et les usages que je pouvais en faire. J’ai identifier deux cas d’usage au Sénégal : autour du lac de Guiers dans le cadre du projet Santés & Territoires, et dans la zone pastorale dans le cadre du projet Dundi Ferlo, et dans le cadre de la convention de programme sur les Communs.

Santés & Territoires : une approche co-construite de one Health

Le projet s’appuie sur une approche participative, impliquant les acteurs du système autour de la transition agro-écologique comme levier d’amélioration des santés (approche one Health). Des chercheurs et des acteurs locaux sont donc impliqués dans 4 pays : au Sénégal, au Bénin, au Laos et au Cambodge, au travers de dispositifs de recherche-action que peuvent être les livings lab. Au Sénégal, les livings-lab se positionnent autour du lac de Guiers (à Mbane, et Keur Momar Sarr).

Entre février et septembre 2023, Amandine Adamczewski-Hertzog et moi avons encadré Mathilde Hibon dans le cadre de son stage de fin d’études pour un double diplôme entre l’école d’agronomie de Purpan et l’ISARA (Norwegian University of Life Sciences, vous pouvez retrouver son rapport ici).

Mathilde put encoder tous ses entretiens avec l’IG. Cela lui a donné 150 entrées dans sa base. À partir de là, on a exploré ces entrées avec des outils de l’analyse de réseau (R, et gephi). En les exprimant par point de vue. C’est à dire, envisager la manière dont chacun considère les relations d’interaction (au travers de règles ou de stratégies). Voilà le résultat de l’une de ces analyses du point de vue des populations locales.

En regardant les relations qui sont identifiées à partir des entretiens mener auprès des institutions, on constate que la centralité des acteurs n’est pas du tout la même, ce qui permet entre autres choses de visualiser facilement les différences de points de vue.

La CP Commun

Dans le cadre de la CP Commun, l’équipe GIREL du GRET Sénégal a séléctionné deux terrain : Mont-Rolland et Diender pour y déployer le jeu f’eau diem. Le jeu f’eau diem étant utilisé comme une arène qui permet de virtualiser les problèmes auxquels les participants font face. On réutilise à notre compte le concept de Johan Huizinga (1949) : “The Magic Circle”. Cela renvoie à l’espace conceptuel (mental) et physique (le lieu) dans lequel les règles du jeu prennent le dessus sur celles de la réalité quotidienne. L’identification de cet espace permet aux observateurs de la session de jeu de mieux comprendre les relations que les joueurs tissent localement avec la réalité. Comment ceux-ci adoptent des rôles ou des comportements qu’ils n’auraient pas dans leur vie quotidienne.

Les participants a la session de jeu f’eau diem de Diender en mai 2024

De cette manière nous nous attendons à ce que les joueurs ne nous parlent pas directement de leurs problèmes et de solutions de gestion mais de ceux identifiés dans le jeu, qui pour autant ont des équivalences dans la réalité.

A partir des observations des sessions de jeux, l’objectif est de remplir la matrice des formalisations des règles largement inspirées de l’Institutional gramar. Ce formalisme nous semblait être en mesure de capturer les éléments de réglementation formelle ou informelle que les participants allaient évoquer dans le cercle magique (c.f. fig I).

Figure issue du papier de Schlüter, A., & Theesfeld, I. (2010). The grammar of institutions: The challenge of distinguishing between strategies, norms, and rules. Rationality and Society p. 457

Les institutions (action d’instituer en économie) sont composées d’un ensemble de stratégies, normes et règles qui sont mises en place par un groupe d’agents. Pour un agent, une institution peut-être consciente et inconsciente. La Stratégie décrit le comportement d’un joueur dans un jeu. Elle peut être individuelle si on ne sait pas qui d’autre la mobilise. Collective, dans ce cas là, on assiste à l’apparition d’une institution. Les normes peuvent être internalisées, c’est-à-dire incorporées à l’intérieur de l’individu de manière à ce qu’il s’y conforme sans récompense ou punition externe, ou elles peuvent être imposées par des sanctions positives ou négatives venant de l’extérieur.

Les règles identifiées par les observateurs devaient être mises en discussion puis testées dans des sessions de jeux. S’il y a eu des adaptations locales, on peut globalement dire que le plan ne s’est pas passé comme prévu. Philippe Karpe (Cirad – UMR SENS) nous avait un peu mis en garde vis-a-vis de la grille. Elle était très compatible avec le droit positif, mais assez peu opérante pour faire face aux systèmes de régulation endogène mis en place par les participants. On a donc encore du travail 🙂

Dundi Ferlo : travailler avec les populations locales au projet de Grande Muraille Verte

Penda Diop Diallo, a emmené le CNRF (Centre National de Recherche Forestière Sénégalais) dans les approches de modélisation d’accompagnement (ComMod). Dans ce projet il s’agira de s’inscrire dans le projet panafricain de la grande muraille verte, en prenant en accompagnant les acteurs dans le processus. Dans les faits, cela veut dire accompagner la mise en place de parcelles de reboisement gérer collectivement par les populations locales aussi bien du point de vue du fourrage herbacé, que du potentiel fourrage aérien, et un jour des productions forestières non ligneuses.

Dans le cadre de ce travail, Penda accompagnée d’Anna Ndiaye ont réutilisé et adapté un jeu sérieux dans la plus pure approche ComMod. Il s’agissait de se servir de cet outil comme d’un simulateur social qui permettent aux acteurs de se projeter dans des mesures de gestion, d’en évaluer ainsi la faisabilité et les implications sur l’usage de la ressource.

Ces activités, réalisées à Vélingara Ferlo et Younofere, ont amené les acteurs à exprimer des ensembles de règles de gestion qui ont été implémentés la même année dans les parcelles. Penda a travaillé à la formalisation de ces règles dans l’Institutional Grammar pour pouvoir identifier les trajectoires institutionnelles que chacune des zones a décidé de prendre. Cela permettra de comparer facilement les directions que vont prendre les deux terrains d’étude.

Les perspectives

Si ça vous intéresse je vous encourage à aller voir le site de l’institutional Grammar initiative. En terme de perspective, il me semble que ce cadre est extrêmement stimulant, malgré les limites identifié précédemment, pour modéliser et donc simplifier les types de relation liés aux règles formelles et informelles dans la zone.

Cormas dans container OpenMole

SMA, ,

Je parlais l’autre jour de l’utilisation de Cormas dans Docker et j’avais évoqué la possibilité d’utiliser cette plateforme multi-agent à l’intérieur d’openMole pour pouvoir bénéficier des possibilités de la taupe pour paralléliser le calcul et explorer des modèles.

J’avais profité de Romain pendant le coding-camp 2018 pour qu’on propose une première version de plug-in cormas pour openMole. En plus d’ouvrir des portent au calcul pour Cormas, l’idée était de permettre à l’équipe de développer de se concentrer sur le développement de la plateforme plutôt que sur le redéveloppement des méthodes de calcules.

Etape 1 : un container OpenMole

Pour tester Cormas dans openMole le plus simple est d’utiliser docker. En effet l’équipe openMole propose un joli petit container qui rox les poneys ! Vous pouvez le lancer comme ça :

## telecharger la derniere image
docker pull openmole/openmole:8.0-SNAPSHOT
## cree un conteneur avec les droit décriture sur le dossier monte
docker run -u root  -v /root/openMole_workSpace:/var/openmole openmole/openmole:8.0-SNAPSHOT chown -R openmole:openmole /var/openmole/
## lancer le contener en mode detache
docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -p 8080:8443 -v /root/openMole_workSpace:/var/openmole/ openmole/openmole:8.0-SNAPSHOT

Etape 2 : le plug-in cormas pour OpenMole

Voilà la primitive cormas n’est pas directement intégrée à OpenMole, il faudra donc télécharger le plug-in, et l’importer en utilisant le bouton idoine (la prise électrique) dans la barre d’outils en haut.

Etape 3 : Le script OpenMole

Une fois que le plug-in est installé, il ne reste plus qu’à exécuter un script. Pour se simplifier la vie, on utilisera pour l’exemple un modèle chargé par défaut dans cormas : le modèle des pompiers. Pour ceux qui n’ont pas une petite idée ce que c’est, on a un automate cellulaire dont les cellules passe de arbre à brulé et des agents pompier qui vont essayer d’éteindre l’incendie.

Vous pouvez maintenant crée un script.oms qui sera executable par OpenMole.

// OpenMole Variable definition.
// Those variables will be populated in openMole
// and send in JSON to Pharo/Cormas

val seed = Val[Int]

val numberOfFires = Val[Int]
val numberOfFiremen = Val[Int]
val percentageOfTrees = Val[Double]
val dimensionMin = Val[Int]
val dimensionMax = Val[Int]
val nbTrees = Val[Int]

// The CORMASTask take in parameters the class and method able to
// launch our simulation. In OUr case using the Cormas-Model-FireAutomata
// we run a methods build for OpenMole. You can take a look.
// set() allow you to pass some other thing to your task. You can pass :
// * your model as a file.st
// * inputs from OpenMole Variable
// * outputs as an array
// * defined parameters how doesn't change between simulation.

val model = CORMASTask("CMFireAutomataModel simuOpenMole") set (
//resources += workDirectory / "Cormas-Model-FireAutomata.st",
inputs += seed,
cormasInputs += numberOfFires,
cormasInputs += numberOfFiremen,
cormasInputs += percentageOfTrees,
cormasInputs += dimensionMin,
cormasInputs += dimensionMax,
cormasOutputs += nbTrees,

outputs += (seed, numberOfFires, numberOfFiremen, percentageOfTrees, dimensionMin, dimensionMax),

numberOfFires := 3,
numberOfFiremen := 10,
percentageOfTrees := 0.65,
dimensionMin := 60,
dimensionMax := 80
)

// With the DirectSampling() method you define an easy wait to generate
// a sampling for numberOfFires between 1 to 10.
DirectSampling(
evaluation = model hook CSVHook(workDirectory / "results.csv"),
DirectSampling(
  evaluation = model hook CSVHook(workDirectory / "results.csv"),
  sampling = (numberOfFires in (1 to 10)) x
             (seed in (UniformDistribution[Int]() take 10))
)

Dans ce script la partie propre à Cormas est bien sûr la CORMASTask(). Elle devra contenir l’ensemble des instructions qui seront passées au docker de cormas. Dans l’exemple ici, nous fixons tous les paramètres par défaut. C’est dans la méthode DirectSampling() que l’on va faire varier le nombre de feux a l’initialisation et qu’on définira le nombre de réplications du modèle.

Etape 4 : passer à l’échelle

À l’étape précédente, on utilise un seul thread de l’ordinateur. Pour passer à l’échelle rien de plus simple, il faut simplement modifier la fin du script :

val env = LocalEnvironment(2)

// With the DirectSampling() method you define an easy wait to generate
// a sampling for numberOfFires between 1 to 10.
DirectSampling(
evaluation = model on env hook CSVHook(workDirectory / "results.csv"),
sampling = (numberOfFires in (1 to 10)) x
(seed in (UniformDistribution[Int]() take 10))
)

On définit une variable env qu’on va ensuite appelée dans évaluation. Notre variable env fera alors tourner les modèles en parallèle sur … 2 thread. Si vous avez accès à plus en local, n’hésitez pas à pousser. Enfin si vous avez la chance d’avoir accès à un cluster il ne vous reste plus qu’a explorer les différents environnements pris en charge par OpenMole.

Voilà par exemple sur un cluster SGE, 100 jobs lancés que l’on peut monitor dans l’interface openMole

et que l’on peut voir sur le cluster avec qstat

Références :

Peaufiner XFCE

geekeries,

Vous savez comme va la vie, on à parfois besoin de changer le papier peint ! Depuis quelques mois, mon Linux tombait en petites pièces. De petits dysfonctionnements … qui ne sont pas gênants. Et puis un jour de grisaille, on se dit que ça suffit ! Je suis reparti sur une install de manjaro (ce dériver d’Archlinux) avec XFCE.

Ça fonctionne bien, mais je cherchais quelque chose d’un peut plus eye candy... Et bien XCFE est super paramétrable ! Ici quelques idées de choses à installer pour s’éloigner de l’austérité 🙂

Plank un dock léger et minimal

Installer plank, ce chouette dock qui est disponible dans les dépôts officiels

sudo pacman -S plank

N’oubliez pas de l’ajouter dans les applications au démarrage

Il est possible qu’une ligne grise vienne faire comme un reflet à quelques centimètres au déçu du dock. C’est l’ombre … qu’il faudra désactiver dans les paramètres de fenêtres: Paramètres -> Peaufinage des fenêtres -> Compositeur.

Un thème pour changer de look

Il n’y a pas mal de thèmes et icônes disponible sur https://www.xfce-look.org/

Une petite note sur Zettlr

geekeries,

Depuis 2018, j’ai pris l’habitude de prendre des notes en markdown des réunions, ou des pensées qui arrivait au fils de l’eau. Markdown parce que j’aime ce format, parce qu’il reste lisible même sans logiciel dédié, parce que c’est devenu un standard sur les différents dépôts git, et parce que j’aime les environnements de travail minimalistes, ça m’aide à rester concentré.

J’utilise depuis maintenant 1 an Zettlr après avoir passé pas mal de temps sur atom. Et j’en suis très satisfait ! Il permet l’export en docx, odt, etc. quand je dois travailler avec des collègues. Il supporte bien les entêtes yaml.

Ce matin je voulais changer la police de l’éditeur. Je suis un grand fan de la police utiliser par les blogs du monde diplo : WalbaumGrotesk. Je me suis dit que ce serait chouette de l’avoir pour écrire. J’ai un peut tâtonner, mais voilà, il faut aller dans Fichier → CSS personnalisé et ça permet pas mal de choses.

Pour mois ça donne ça pour utilisé cette chouette font!

body #editor {
font-family: 'WalbaumGrotesk Text', monospace;
}

Construire un container pour Cormas

geekeries, SMA,

Cormas est une plateforme de modélisation multi-agents développée en SmallTalk. Historiquement le choix de développement s’était porté sur VisualWork mais depuis quelque temps l’équipe regardait en direction de Pharo.

Cormas sous pharo

Le portage se fait petit à petit, et la feuille de route avance assez rapidement. Si le sujet vous intéresse, nous sommes en train de rédiger un manuel d’utilisation de cette nouvelle version de Cormas sous pharo.

Comme c’est le moment des grandes décisions on s’interroge sur les passerelles avec d’autres outils régulièrement utilisés par les communautés de chercheurs utilisant les SMA et plus largement la simulation. Pour le moment l’attention est portée sur les connexions entre cette nouvelle version de cormas et R et cormas/openMole.

Pour cette dernière, openMole intègre un système de conteneur basé sur udocker. Je suis donc en train de fouiller les possibilités de dockerisé cormas/pharo pour dans un futur que j’espère assez proche nous puissions faire l’ensemble de nos explorations en utilisant openMole.

Ecrire un dockerfile

# Set the base image
FROM ubuntu
# Dockerfile author / maintainer
MAINTAINER Etienne  <moi@truc.fr>

# Update software repository
# and install dependencies
run dpkg --add-architecture i386
run apt-get update && apt-get install -y curl unzip libx11-6:i386 libgl1-mesa-glx:i386 libfontconfig1:i386 libssl1.0.0:i386 libcairo2:i386

RUN mkdir cormas && cd cormas
RUN curl https://get.pharo.org | bash
RUN ./pharo Pharo.image config http://ss3.gemstone.com/ss/Cormas --install=development

Construire un conteneur à partir du dockerfile

sudo docker build -t cormas

Lancer un conteneur à partir du build

docker run --name cormas_instance -t cormas

Tester le fonctionnement

Votre conteneur doit être en train de fonctionner. Pour le vérifier, vous pouvez lancer les commandes suivantes.

docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
914f52adbd98 cormas "/bin/bash" About a minute ago Up About a minute cormas_instance
eeba02bea345 mdillon/postgis "docker-entrypoint.s…" 2 weeks ago Exited (0) 2 weeks ago psql-futurSahel

Vous voyez que j’ai deux conteneurs (psql-futurSahel et cormas_instance) et que le conteneur cormas_instance est en cour de fonctionnement.

On peut maintenant essayer d’interagir avec pharo à l’intérieur du conteneur

sudo docker exec -it 914f52adbd98 /pharo Pharo.image eval '1 + 20'

Si tout s’est bien passé, vous constaterez que pharo vous répond de manière aimable 21 !

Note :

Pour pousser un nouveau conteneur

sudo docker tag cormas elcep/cormas
sudo docker push elcep/cormas

 

Références :

Docker.(PostgreSQL + postGIS) copier des données d’un conteneur à l’autre

geekeries, Géomatique, , ,

Dans un précédent post, je faisais mes premiers pas avec Docker. Arrive rapidement la situation où, vous avez deux conteneurs. L’un avec une base de données spatiale en développement et  l’autre avec LA base de données en production.

Bon, et il peut arriver qu’on veuille sauvegarder les données et/ou restaurer ces données. Typiquement. Vous avez peuplé votre base de nouvelles tables, vues, fonctions… et c’est le moment de passer tout ça en production… Voilà une piste !

Sauvegarder la base de données avec pg_dump ou pg_dumpall

docker exec -t your-db-container pg_dumpall -c -U postgres > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql

ou si la base existe déjà (et que vous ne voulez pas vous soucier des « owner » et « privileges »)

docker exec -t your-db-container pg_dump -d fs_gis -U postgres > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql

Envoyer le dump dans le conteneur de production

cat your_dump.sql | docker exec -i your-db-container psql -d dbname -U postgres

Le `|` est utilisé pour envoyer les information « lut » par le `cat` au fur et à mesure dans psql !

Source :

ODD song

SMA,

Dans le monde de la modélisation individu centré, l’un des formalismes attendus pour publier une description de modèles s’appelle ODD pour Overview, Design
concepts, and Details. La description de ce formalisme a été publiée en 2006 dans Ecological Modelling.

Grimm, V., U. Berger, F. Bastiansen, S. Eliassen, V. Ginot, J. Giske, J. Goss-Custard, et al. 2006. « A Standard Protocol for Describing Individual-Based and Agent-Based Models ». Ecological Modelling 198 (1–2): 115‑26. doi:10.1016/j.ecolmodel.2006.04.023.
Et bien voila la chanson de l’ODD !

Un conteneur pour postgreSQL et postgis

geekeries, , ,

Il arrive des moments dans la vie où on a besoin d’un petit serveur de base de données rapidement, là tout de suite. Si ça vous est déjà arrivé, vous savez que c’est parfois se lancer dans une aventure … qui si elle n’est pas périlleuse, peut s’avérer longue et douloureuse.

Alors, pourquoi ne pas en profiter pour passer à docker ? Parce qu’avec le principe de dockerfiles, l’installation ne prend pas plus longtemps que de télécharger les packages.

Installation docker sur Ubuntu

Source : docker.com

Le site de docker est très bien fait. Sur Ubuntu 16.04, il suffira de lancer les lignes de commandes suivantes.

sudo apt-get install -y --no-install-recommends apt-transport-https ca-certificates curl software-properties-common
 curl -fsSL https://apt.dockerproject.org/gpg | sudo apt-key add - apt-key fingerprint 58118E89F3A912897C070ADBF76221572C52609D
 sudo add-apt-repository "deb https://apt.dockerproject.org/repo/ \
 ubuntu-$(lsb_release -cs) \
 main"
 sudo apt-get update
 sudo apt-get -y install docker-ce

Si tout s’est déroulé sans accrocs, vous pouvez vérifier que docker fonctionne avec :

sudo docker run hello-world

Il ne reste enfin quelques petits ajustements à faire, notamment configurer votre utilisateur dans le groupe docker pour s’abstraire de l’utilisation de sudo par exemple. Vous trouverez ces choses-là sur cette page.

Installation de postGIS et postgreSQL

Source : postgis dockerfile

Pour créer un conteneur docker il suffit de lancer la commande docker run. Docker va vérifier si vous disposez d’une « image » du service que vous souhaitez lancer. Si c’est le cas, un conteneur sera créé, sinon les différentes composantes de l’image seront téléchargées et le conteneur sera créé dans la foulée.

On commence ici par créer un conteneur postGIS qui s’appellera psql-futurSahel (C’est l’étiquette du conteneur et cela n’aura pas d’influence sur la base de données). On définit le mot de passe de postgreSQL et on spécifie que l’on veut utiliser l’image postgis fournie par l’utilisateur mdillon.

docker run --name psql-futurSahel -e POSTGRES_PASSWORD=postgres -d -p 5432:5432 mdillon/postgis

Pour que cela fonction, il faut également installer un postgreSQL et le lier à l’image de postGIS. Ce qui nous permettra ensuite d’accéder à l’interface de base de données et de nous connecter avec psql

docker run -it --link psql-futurSahel:postgres --rm postgres \
 sh -c 'exec psql -h "$POSTGRES_PORT_5432_TCP_ADDR" -p "$POSTGRES_PORT_5432_TCP_PORT" -U postgres'

Dans Postgre

Si tout s’est passé comme il faut, suite à la dernière commande, et après téléchargement des différents constituants de l’image, vous êtes rentré dans le conteneur et vous avez en face de vous un prompt psql.

Vous pouvez donc utiliser les commandes habituelles de postgre. Il faut, une fois connecté à psql, créer une base de données

CREATE DATABASE fs_gis;

On peut ensuite se connecter à la base de données

\connect fs_gis;

Et lancer la commande

CREATE EXTENSION postgis;

La base est donc créée en utilisant le template postGIS.

Peupler la base de données

Vous avez maintenant un serveur de base de données spatiales qui tourne et auquel vous pouvez accéder depuis la machine hôte.

Pour connaître l’IP du conteneur :

docker inspect idconteneur

Vous pouvez alors configurer vos outils de gestion de base de données en utilisant l’IP du conteneur et/ou votre propre IP (ifconfig).

Dans Qgis vous pouvez configurer la gestion de la base de la manière suivante :

Et vous pouvez utiliser l’extension Base de données > Gestionnaire de base de données > Gestionnaire de base de données, pour importer dans postgreSQL vos données en cliquant sur ‘importer une couche ou un fichier’. Cet outil va utiliser le script shp2psql de manière transparente pour l’utilisateur.