Développer en C# sur Debian 8 / Linux Mint 18

Bonjour,

Aujourd’hui nous allons voir comment mettre en place un environnement permettant de réaliser des application en C#.NET sur un environnement GNU/Linux. J’utilise actuellement Linux Mint 18 mais cela fonctionne également avec d’autres distributions basées sur Debian / Ubuntu.

Installation du framework

Il faut dans un premier temps ajouter le dépôt dans les sources d’APT. Ce dépot est en HTTPS, il faut donc installer le paquet apt-transport-https au préalable.

Il faut ensuite ajouter le dépôt en question via la ligne de commande suivante :

echo "deb [arch=amd64] https://apt-mo.trafficmanager.net/repos/dotnet-release/ xenial main" > /etc/apt/sources.list.d/dotnetdev.list  # Ajout du dépot
apt-key adv --keyserver apt-mo.trafficmanager.net --recv-keys 417A0893 # Ajout de la clé
apt-get update # On met à jour la liste des paquets.

Puis on installe la dernière version disponible (voir https://www.microsoft.com/net/core#ubuntu).

sudo apt-get install dotnet-dev-1.0.0-preview2-003131

Ensuite, on peut normalement créer un projet pour vérifier que tout fonctionne via les commandes suivantes :

mkdir application # création du dossier
cd application # se rendre dans le dossier
dotnet new # initialiser le projet
dotnet restore # installer les différentes dépendances nécessaires au projet
dotnet run # Enjoy !

Si tout ce passe bien vous devriez avoir ceci :

croangels$ dotnet run
Project test (.NETCoreApp,Version=v1.0) will be compiled because expected outputs are missing
Compiling test for .NETCoreApp,Version=v1.0

Compilation succeeded.
0 Warning(s)
0 Error(s)

Time elapsed 00:00:01.2626472

Hello World!

Installation / Configuration avec Visual Studio Code

Pour travailler avec visual studio code aucune configuration de l’IDE n’est nécessaire. Néanmoins, on peut installer le générateur aspnet de yeoman pour pouvoir avoir des templates de projets facilement.

Pour l’installer, il faut dans un premier temps avoir nodejs (https://nodejs.org/en/download/) et yeoman (npm install -g yo) d’installé.

Il faut ensuite installer le bon générateur :

npm install -g generator-aspnet

Développer en C#.NET sur Mac OS X !

Bonjour,

Aujourd’hui nous allons voir comment mettre en place un environnement permettant de réaliser des application en C#.NET sur Mac OS X. J’utilise actuellement Mac OS Sierra mais cela fonctionne également avec Mac OS ElCapitan.

Installation du framework

Il faut dans un premier temps avoir HomeBrew d’installer :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Ensuite on peut installer les librairies openssl pour permettre au gestionnaire de package nuget de fonctionner :

brew update
brew install openssl
ln -s /usr/local/opt/openssl/lib/libcrypto.1.0.0.dylib /usr/local/lib/
ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/

On récupère ensuite le framework .NET Core pour MacOS sur le site de microsoft.

Ensuite, on peut normalement créer un projet pour vérifier que tout fonctionne via les commandes suivantes :

mkdir application # création du dossier
cd application # se rendre dans le dossier
dotnet new # initialiser le projet
dotnet restore # installer les différentes dépendances nécessaires au projet
dotnet run # Enjoy !

Si tout ce passe bien vous devriez avoir ceci :

croangels$ dotnet run
Project test (.NETCoreApp,Version=v1.0) will be compiled because expected outputs are missing
Compiling test for .NETCoreApp,Version=v1.0

Compilation succeeded.
0 Warning(s)
0 Error(s)

Time elapsed 00:00:01.2626472

Hello World!

Installation / Configuration avec Visual Studio Code

Pour travailler avec visual studio code aucune configuration de l’IDE n’est nécessaire. Néanmoins, on peut installer le générateur aspnet de yeoman pour pouvoir avoir des templates de projets facilement.

Pour l’installer, il faut dans un premier temps avoir nodejs (https://nodejs.org/en/download/) et yeoman (npm install -g yo) d’installé.

Il faut ensuite installer le bon générateur :

npm install -g generator-aspnet

Installation / Configuration avec Xamarin Studio

Il faut le télécharger ici.

Authentification facebook – Symfony3 et les bundles FOSUserBundle et HWIOAuthBundle

Afin de rajouter l’authentification Facebook sur votre site sous Symfony3 vous aurez besoin de 2 bundles :

  • FOSUserBundle (vous permettant de gérer les utilisateurs facilement)
  • HWIOAuthBundle

Je considère que vous avez déjà mis en place FOSUserBundle, si ce n’est pas le cas il est relativement facile à mettre en place et je vous conseille le tuto de sensiolabs suivant : http://symfony.com/doc/current/bundles/FOSUserBundle/index.html

 

Une fois le bundle FOSUserBundle installé et configuré vous aurez besoin d’installer HWIOAuthBundle.

On commence par récupérer le bundle via composer :

composer require hwi/oauth-bundle

Ensuite il faut activer le bundle via le fichier AppKernel.php

// app/AppKernel.php

public function registerBundles()
{
    $bundles = array(
        // ...
        new HWI\Bundle\OAuthBundle\HWIOAuthBundle(),
    );
}

Le bundle est maintenant installé. Nous allons maintenant passer à la configuration du bundle afin d’intégrer l’authentification Facebook.

Avant cela il faut que vous ayez créé une application dans Facebook Developers (https://developers.facebook.com/apps/).

Pensez à bien renseigner les URLs de callback sinon vous ne parviendrez jamais à vous authentifier.

 

Pour bien configurer le bundle avec Facebook il vous faudra dans un premier temps éditer votre fichier config.yml afin d’y rajouter un section :

hwi_oauth:
    connect:
        account_connector: my_user_provider
    firewall_names: [main]
    resource_owners:
        facebook:
        type: facebook
        client_id: <id de votre app>
        client_secret: <cle secrete de votre app>
        scope: "email"
        infos_url: "https://graph.facebook.com/me?fields=id,first_name,last_name,email,picture.type(square)"
        paths:
            email: email
            firstname: first_name
            lastname: last_name
        options:
            display: popup #dialog is optimized for popup window
            auth_type: rerequest # Re-asking for Declined Permissions
    fosub:
        username_iterations: 30
        properties:
            facebook: facebook_id

Attention, si vous regardez des tutos sur internet, la plupart indique une ligne « firewall_name: main », celle-ci est dépréciée et il faut maintenant utiliser « firewall_names: [main« .

Ensuite il vous faudra surcharger le provider du bundle FOSuser.

Pour ce fait vous devez créer une arborescence dans votre bundle (ici dans AppBundle) : AppBundle/Security/Core/User

Dans le dossier User précédemment créé il faut y créer un fichier FOSUBUserProvider.php :

<?php

namespace AppBundle\Security\Core\User;

use HWI\Bundle\OAuthBundle\OAuth\Response\UserResponseInterface;
use HWI\Bundle\OAuthBundle\Security\Core\User\FOSUBUserProvider as BaseFOSUBProvider;
use Symfony\Component\Security\Core\User\UserInterface;

class FOSUBUserProvider extends BaseFOSUBProvider
{
    /**
     * {@inheritDoc}
     */
    public function connect(UserInterface $user, UserResponseInterface $response)
    {
        $username = $response->getUsername();

        $service = $response->getResourceOwner()->getName();
        $setter = 'set' . ucfirst($service);
        $setterId = $setter . 'Id';
        $setterToken = $setter . 'AccessToken';

        //disconnect previously connected user
        if (null !== $previousUser = $this->userManager->findUserBy(array($this->getProperty($response) => $username))) {
            $previousUser->$setterId(null);
            $previousUser->$setterToken(null);
            $this->userManager->updateUser($previousUser);
        }

        //connect current user
        $user->$setterId($username);
        $user->$setterToken($response->getAccessToken());

        $this->userManager->updateUser($user);
    }

    /**
     * {@inheritdoc}
     */
    public function loadUserByOAuthUserResponse(UserResponseInterface $response)
    {
        $username = $response->getUsername();
        $email = $response->getEmail();

        $user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
        if (null === $user) {
            $user = $this->userManager->findUserByEmail($email);

            $service = $response->getResourceOwner()->getName();
            $setter = 'set' . ucfirst($service);
            $setterId = $setter . 'Id';
            $setterToken = $setter . 'AccessToken';

            if (null === $user) {
                $user = $this->userManager->createUser();
                $user->$setterId($username);
                $user->$setterToken($response->getAccessToken());

                $user->setUsername($username);
                $user->setEmail($email);
                $user->setPassword($username);
                $user->setEnabled(true);
                $this->userManager->updateUser($user);

                return $user;
            } else {
                $user->$setterId($username);
                $user->$setterToken($response->getAccessToken());

                $this->userManager->updateUser($user);

                return $user;
            }
        }

        //if user exists - go with the HWIOAuth way
        $user = parent::loadUserByOAuthUserResponse($response);

        $serviceName = $response->getResourceOwner()->getName();
        $setter = 'set' . ucfirst($serviceName) . 'AccessToken';

        //update access token
        $user->$setter($response->getAccessToken());

        return $user;
    }
}

Une fois ce fichier créé vous devez modifier votre fichier routing.yml :

#app/config/routing.yml

#FosUserBundle Routes
fos_user_security:
 resource: "@FOSUserBundle/Resources/config/routing/security.xml"

fos_user_profile:
 resource: "@FOSUserBundle/Resources/config/routing/profile.xml"
 prefix: /profile

fos_user_register:
 resource: "@FOSUserBundle/Resources/config/routing/registration.xml"
 prefix: /register

fos_user_resetting:
 resource: "@FOSUserBundle/Resources/config/routing/resetting.xml"
 prefix: /resetting

fos_user_change_password:
 resource: "@FOSUserBundle/Resources/config/routing/change_password.xml"
 prefix: /profile

#HWIOAuthBundle routes
hwi_oauth_security:
 resource: "@HWIOAuthBundle/Resources/config/routing/login.xml"
 prefix: /login

hwi_oauth_connect:
 resource: "@HWIOAuthBundle/Resources/config/routing/connect.xml"
 prefix: /login

hwi_oauth_redirect:
 resource: "@HWIOAuthBundle/Resources/config/routing/redirect.xml"
 prefix: /login

facebook_login:
 pattern: /login/check-facebook

Ensuite vous devez modifier le fichier security.yml

  main:
      pattern: ^/
      form_login:
          provider: fos_userbundle
          csrf_token_generator: security.csrf.token_manager
          login_path: /login
          check_path: /login_check
      oauth:
          resource_owners:
              facebook: "/login/check-facebook"
          login_path: /login
          failure_path: /login
          oauth_user_provider:
              service: my_user_provider
     logout: true
     anonymous: true

 login:
     pattern: ^/login$
     security: false

Ensuite modifiez votre fichier security.yml

parameters:
    my_user_provider.class: AppBundle\Security\Core\User\FOSUBUserProvider

services:
    my_user_provider:
    class: "%my_user_provider.class%"
    arguments: [@fos_user.user_manager,{facebook: facebook_id}]

Et enfin il vous faudra modifier votre entité afin de récupérer les token Facebook :

 /** @ORM\Column(name="facebook_id", type="string", length=255, nullable=true) */
 protected $facebook_id;
 /** @ORM\Column(name="facebook_access_token", type="string", length=255, nullable=true) */
 protected $facebook_access_token;

 

 

ATTENTION !!!!!
Penser à télécharger le certificat cacert.pem et ajouter son chemin d’accès au fichier php.ini

Voir l’article suivant : http://m2mdas.github.io/blog/2013/11/21/integrate-hwioauthbundle-with-fosuserbundle/

Ajouter un htpasswd à votre site grace au proxy nginx Docker

Il est parfois important de sécuriser l’accès (du moins le restreindre) à l’aide d’un httaccess et d’un htpasswd.

Si vous utilisez le proxy nginx c’est relativement simple.

Pour commencer il vous faudra créer un dossier dans lequel se trouverons vos fichiers htpasswd. Dans ce tutoriel nous les placerons dans le dossier /var/run/htpasswd/

Ensuite, dans ce dossier, il va falloir créer les fichiers htpasswd pour chacun de vos site.

Les noms des fichiers sont extrêmement importants car ils vont permettre de lier le container contenant votre site et celui-ci. Ainsi si vous lancez un container avec le VHOST test.fr il vous faudra créer un fichier test.fr contenant vos identifiants et mots de passe.

Attention !!! Si vous passez plusieurs VHOST à votre container (par exemple test.fr et www.test.fr) vous devrez créer 1 fichier par VHOST (donc pour le même exemple un fichier test.fr et un fichier www.test.fr).

Les mots de passe dans les fichiers htpasswd doivent être chiffrés.

Voici un exemple de génération de fichier :

htpasswd -c /var/run/htpasswd/test.fr alexandre

Vous devrez ensuite lancer le proxy nginx en rajoutant le dossier contenant les fichiers htpasswd :

docker run -d -p 80:80 -p 443:443 \
     --name nginx-proxy \
    -v /var/run/certs:/etc/nginx/certs:ro \
    -v /etc/nginx/vhost.d \
    -v /usr/share/nginx/html \
    -v /var/run/docker.sock:/tmp/docker.sock:ro \
    -v /var/run/htpasswd/:/etc/nginx/htpasswd \
    --restart=always \
arideau/proxy

(exemple incluant let’s encrypt : voir article précédent ==> ici )

 

Sécuriser un site web avec authentification d’utilisateurs UNIX.

Bonjour,

Aujourd’hui je vais présenter comment je sécurise un site web au travers d’une authentification via les groupes UNIX présent sur le serveur web.

 

Avant de commencer il faut créer le groupe. Pour cela, on exécute la commande Shell suivante :

# addgroup group-name

Il faut ensuite installer le plugin permettant l’authentification par méthode externe.
On installe ensuite le plugin permettant la connexion au travers d’un groupe unix.
Enfin, on active les nouveaux module.

sudo apt-get install libapache2-mod-authnz-external pwauth
sudo apt-get install libapache2-mod-authz-unixgroup
sudo a2enmod authnz_external authz_unixgroup

Ensuite, dans la configuration du virtualhost, vous devez définir un ensemble d’option supplémentaire.

AddExternalAuth pwauth /usr/sbin/pwauth
SetExternalAuthMethod pwauth pipe
AddExternalGroup unixgroup /usr/sbin/unixgroup
SetExternalGroupMethod unixgroup environment

Puis on protége le / les dossier(s) souhaité(s) avec l’élement suivant. En remplaçant l’élement en gras par le nom du group en question.

Require valid-user
AuthType Basic
AuthName "Restricted Area"
AuthBasicProvider external
AuthExternal pwauth
GroupExternal group-name

Voilà il suffit maintenant de redémarrer le serveur web après avoir tester la configuration.
Bonne journée.

Source :

http://icephoenix.us/linuxunix/apache-and-http-authentication-with-pam/

ArangoDB dans un container Docker

AragoDB est une base de données de type NoSQL qui inclue :

NoSQL / Graph / Key-Value

Il est possible de l’installer dans un container Docker et ce très facilement et rapidement.

docker run -dti \
-e VIRTUAL_HOST=URL,ALIAS \
-e ARANGO_RANDOM_ROOT_PASSWORD=1 \
-p 8529:8529 \
arangodb/arangodb

En détail :

La ligne suivante permet de spécifier l’url à laquelle va répondre Arango, car le container dispose d’une interface d’administration pré-installée.

-e VIRTUAL_HOST=URL,ALIAS \

La ligne suivante va permettre de demander au container Arango de générer un mot de passe aléatoire.

-e ARANGO_RANDOM_ROOT_PASSWORD=1 \

A noter que nous pouvons spécifier un mot de passe personnel en remplaçant la ligné précédente par celle-ci.

-e ARANGO_ROOT_PASSWORD=MOTDEPASSE \

On peut également ne pas activer l’authentification.

-e ARANGO_NO_AUTH=1 \

Cependant cette option n’est recommandée que pour faire des test et si votre base n’est pas directement accessible car elle expose vos données.

Enfin, la ligne suivante va exposer le port que Arango va utiliser.

-p 8529:8529 \

https://www.arangodb.com/

https://docs.arangodb.com/cookbook/Cloud/DockerContainer.html


Si vous souhaitez tester Arango :

http://arangodb.lapetiteboitequimonte.fr/

utilisateur : votre prénom

Mot de passe : votre prénom

Let’s Encrypt pour vos sites Docker avec le proxy nginx

Let’s Encrypt va vous permettre de sécuriser un minimum vos sites en rajoutant un certificat SSL.

Cela permet de passer vos sites en HTTPS. (Let’s Encrypt fait une redirection automatique du port 80 vers le port 443)

  • Dans un premier temps « tuer » le proxy nginx (docker kill docker_id)
  • Récupérer via GIT le dépôt let’s encrypt pour le proxy nginx Docker
git clone https://github.com/JrCs/docker-letsencrypt-nginx-proxy-companion.git
  • Se placer dans le dossier du proxy docker
  • Relancer le proxy avec les bonnes options (détails à venir)

Attention !!! : Bien faire attention au nom (option –name) car celui-ci sera réutilisé dans la commande d’après !

docker run -d -p 80:80 -p 443:443 \
    --name nginx-proxy \
    -v /var/run/certs:/etc/nginx/certs:ro \
    -v /etc/nginx/vhost.d \
    -v /usr/share/nginx/html \
    -v /var/run/docker.sock:/tmp/docker.sock:ro \
    --restart=always \
    arideau/proxy
  • Se placer dans le dossier créé via le git clone
  • Builder le container :
docker build -t arideau/lets-encrypt .
  • Lancer le container :
docker run -d \
    -v /var/run/certs:/etc/nginx/certs:rw \
    --volumes-from nginx-proxy  \
    -v /var/run/docker.sock:/var/run/docker.sock:ro \
    --restart=always \
arideau/lets-encrypt
    Enfin lancer le container du site à passer en HTTPS :
docker run -dti \
    -e "LETSENCRYPT_HOST=ADDRESS,ALIAS" \
    -e "LETSENCRYPT_EMAIL=EMAIL" \
    --restart=always \
arideau/sf-1c1m

 

Après ça, les certificats seront régénérés automatiquement.

Toute les heures le container Let’s Encrypt vérifie les certificats et va renouveler ceux qui expirerons dans les 30 prochains jours. 

Vous pouvez tester la qualité du certificat à cette adresse : https://www.ssllabs.com/ssltest/

 

 

https://github.com/jwilder/docker-letsencrypt-nginx-proxy-companion

Faire le ménages dans les containers et images

Chaque commande docker build génère une image qui reste sauvegardée indéfiniment.

La liste des images existantes est visible avec la commande :

docker images

Supprimer tous les containers arrêtés.

Afin d’effacer ces images, il faut au préalable détruire les containers les utilisant grâce à la commande :

docker rm $(docker ps -a -q)

Cette commande efface tout les containers arrêtés en faisant une liste de tous les containers avec docker ps -a -q et renvoie leurs ids à docker rm. Les containers en fonctionnement ne seront pas effacés.

Supprime les images sans nom

Pour les supprimer, il faut utiliser la commande :

docker rmi $(docker images | grep "^<none>" | awk "{print $3}")

Cela fonctionne en utilisant rmi avec une liste d’ids. Afin d’obtenir les ides nous appellons docker images et la transmet à grep "^<none>". le commande greg va filtrer les lignes avec la valeur “<none>” dans la colonne « repository ». Puis pour extraire les ids depuis la 3ème colonne on la transmet à awk "{print $3}" qui affichera la 3ème colonne de chaque ligne.

Héberger plusieurs sites web simplement avec Docker

Pré-requis

  • Avoir Docker
  • Avoir au moins un nom de domaîne

Point techniques

Chaque site doit être dans un conteneur (ou un groupe de conteneurs) LAMP.
Prenons pour exemple le conteneur tutum/lamp.

Celui-ci prévoit un ensemble avec un apache écoutant sur le port 80.

Nous allons avoir un ensemble de conteneurs correspondant à divers sites. C’est pourquoi nous devons utiliser un reverse proxy qui s’occupera de faire la correspondance DNS <–> Container

On pourrait installer un nginx sur la machine hôte mais il faudrait pour çà créer un vhost pour chaque site. Bref çà serait casse couille.

Donc à la place de çà on peut utiliser le conteneur jwilder/nginx-proxy qui utilise la socket de docker et l’utilise pour ajouter automatiquement les vhosts nginx en fonction d’une variable d’environnement VIRTUAL_HOST et / ou VIRTUAL_PORT.

Ensuite c’est automatiquement disponible en moins d’une minute.

Démarrage Manuel

Commençons par lancer le reverse proxy nginx :

docker pull jwilder/nginx-proxy
docker run -d -p 80:80 -p 443:443 -v /var/run/docker.sock:/tmp/docker.sock:ro jwilder/nginx-proxy

Ensuite lançons pour example un LAMP :

docker pull tutum/lamp
docker run -d -e VIRTUAL_HOST=example.com,www.example.com tutum/lamp

Et voilà on a un service qui tourne 😉

Démarrage continu

On rajoute l’option --restart=always et c’est tout 🙂