Un café sans Prince sur la crête

Un café sans Prince sur la crête
Voie lacté au dessus de Lélex

Je vais faire aujourd’hui quelque chose que je repousse depuis si longtemps. Poser des mots les uns derrière les autres sans qu’il ne soit question de technique, d’informatique, de mettre des Dockers dans des Dockers ou encore d’empiler des Kubes. Si vous ne comprenez rien à Docker ou à Kubernetes, cela n’a aucune importance ici.

Lors de mes temps perdus je photographie, tout et rien. J’apprends l’art de composer, cadrer, déclencher, pour raconter une histoire, figer un moment dans l’éternité. C’est un peu comme la programmation, mais en beaucoup plus subjectif… Un jour je suis tombé sur des images d’astrophotographie. Celles faites dans un désert inconnu, ou de rares arbres fossilisés donnent le change à la voie lactée. Ces images sont sublimes, elles nous offrent une facette de notre environnement que nous avons rarement la chance de pouvoir observer. J’ai eu envie d’essayer, moi aussi, attraper la voie lactée.

Si trouver des explications techniques sur comment réaliser ce genre de photo est facile, trouver le bon emplacement est une autre paire de manche.

Par un chaud samedi après-midi d’Août Bourguignon, avec risques d’orages, nous sommes partis à Lélex dans le Jura pour un « Trek » d’un weekend. Juste une nuit au-dessus de la montagne.

Quand je dis « nous », c’est que cette expérience je ne l’aurais jamais réalisé seul. Car partir en « Trek » (je le mets entre guillemets car je ne suis pas certain que l’on puisse appeler cette excursion un Trek, je vous laisse donc seul juge) quand on ne là jamais fait auparavant, ça me semblait assez suicidaire. C’est donc avec mon ami de longue date, Joe, que nous avons pris le chemin pour gravir cette montagne. Et le moins que je puisse dire, c’est que je n’étais pas prêt, mais pas du tout…

Si Joe a été élevé dans la pratique de la marche en montage et des joies du camping sauvage, ce n’est pas mon cas. Je suis un informaticien sédentaire en surcharge pondérale (c’est une amusante litote pour ne pas dire que je suis gros…), habitué au confort douillet d’un logement avec toutes commodités. Alors partir comme cela, pour une nuit dans un environnement inconnu sans la sécurité d’un point d’eau constant en plein été, oui, cela peu être considéré comme partir à l’aventure.

Sur la route jusqu’à Lélex, le temps était nuageux, menaçant, mais un Joe confiant ne cessait de me répéter « T’inquiète on va par là-bas, y aura pas de nuage ! »

Et effectivement, à Lélex, pas un seul gros nuage, rien que quelques Cirrus s’attardant mollement dans le ciel.

Mon cher ami, qui a tout organisé, que ce soit le contenu de notre paquetage ou notre itinéraire, a dans son infinie bonté choisi un démarrage en douceur pour m’épargner la déconvenue d’une ascension trop épuisante.

Télécabine Catheline
Télécabine

La première partie nous l’avons faite confortablement assis dans la télécabine de la ligne Catheline accessible près de l’office de tourisme du village de Lélex.

C’est après que ça se corse (aucun lien avec l’île de beauté…). Nous avons commencé à suivre Anémones, une piste verte lorsque la neige recouvre ce chemin large et peu pentu. Nous avons ensuite croisé la piste rouge Asters et suivit sa courbe. Puis nous nous sommes engouffrés dans des petits chemins forçant la marche à la queuleuleu. La pente n’est pas difficile, enfin, si vous êtes équipés d’un sac à dos fait pour votre morphologie, pas comme moi qui est emprunté celui de ma chère et tendre… ça frotte au niveau des épaules et le poids du sac devient de plus en plus inconfortable et insupportable à chaque pas. Ajouter à cela une condition physique déplorable, un trépied studio (pas fait pour la rando), du matériel photos qui pèse un âne mort et un Joe qui avance comme un cabri, vous obtenez une jolie recette pour faire souffrir l’homme que je suis.

Cela aurait pu sonner le glas de cette excursion. Mais la nature a un charme fou pour lequel je suis prêt à endurer beaucoup.

À la vue de ma détresse physique (en nage, tout rouge, chemise trempée, haletant comme un chien qui aurait oublié le goût de l’eau), Joe pose son sac et déclare que ce bout de montagne sera notre gîte pour ce soir. Nous nous sommes arrêtés à mi-chemin du crêt de la Neige.

C’est beau. Difficile d’exprimer ce que l’on ressent lorsque l’on parvient à la crête. Cette vue sur les vallées qui nous entourent, Genève et son lac en contrebas. Il n’y a que nous. Pas un bruit. Seul le vent s’exprime à travers les branches des conifères et sa caresse sur l’herbe. Je revis. Loin de la technologie omniprésente, loin du bruit incessant des villes et de ses odeurs indésirables, loin des autres.

Je profite de l’instant présent sans plus penser à l’après.  

Une fois la tente bien ancrée au sol, on s’assoit au sol, sur l’herbe, et partageons un saucisson bienvenu. Ma crainte de manquer d’eau fait que je bois peu. J’ai peur que trois litres par personne soit trop peu. Je me trompe et cela me jouera des tours, mais je ne le sais pas encore.

(Instant réclame) Le soir venu nous sortons des plats de bolognaises déshydratés proposés par Décathlon. C’est agréable de manger chaud avec le vent qui, lui, nous refroidi. Contre toute attente, un sachet suffit à nous rassasier, et nous avons été agréablement surpris par la qualité gustative du produit. (Fin de la réclame)

Un petit somme avant l’arrivée de la nuit. Car c’est surtout pour elle que je me suis donné tant de mal à gravir cette montagne. Cela faisait plusieurs mois que je rêvais de cette nuit. Pouvoir tutoyer les étoiles en espérant capturer la voie lactée.

La nuit a été froide. Pas de gant, une polaire et en guise de bonnet une simple casquette. Quand je pense à ma famille qui elle doit avoir trop chaud. Mais être seul debout face à l’obscurité englobante et avoir comme spectacle ces lumières scintillantes accrochées au ciel, ça motive et permet de rester éveillé, tard. Suffisamment pour pouvoir photographier celle que j’étais venu chercher. Elle s’est montrée dans toute sa splendeur et nous a offert ce tableau à contempler.

Sans le savoir, lors de mes déclenchements acharnés pour ne pas en perdre une miette, le filé d’étoiles filantes est venu impressionner le capteur de mon appareil photo. C’est une des joies que procure la photographie, découvrir après coup que la nature nous a offert plus que nous le pensions.

J’étais venu pour la nuit et Joe pour le lever du soleil. Autant dire le repos n’a pas été suffisant. Je vous ai dit que j’avais peur de manquer d’eau. Et bien, le manque d’eau provoque de violentes crampes aux muscles qui ont été sollicités. Les jambes dans mon cas. Des crampes à en rester bloqué à quatre pattes dans la tente à me faire pousser dehors pour pouvoir décrisper ses satanés muscles… Maintenant, contrairement à John Snow, je sais. !

Le lever de soleil sur Genève est un spectacle aux saveurs douces et diffuses. La lumière orangée du soleil matinal se reflète sur le lac, elle glisse dessus comme une Felouque sur le Nil. Toute la montagne baigne dans cette douce clarté et teinte chaque plante d’une lumière nouvelle.

Levé du soleil sur le lac de Genève

C’est aussi pour nous le moment de prendre le petit déjeuner. Et aussi le moment de se rendre compte que le paquet de gâteau que je devais emmener (la seule nourriture que j’aurais dûe porter), est resté à la maison. Je pense que dans dix ans ou plus j’en entendrais encore parler…

Quoi qu’il en soit, une cafetière Bialetti (Ho ! Non, par Torvald ! Encore une réclame !) sur un réchaud et ensuite pouvoir apprécier un bon café, chaud, entouré de toute cette nature, ça n’a pas de prix. Cela vaut vraiment la peine de souffrir pour voir ce que la nature possède de si beau.

Avant 8h, la tente repart dans son sac, les affaires sont rangées, le campement laissé vierge de tout résidu de notre présence. Puis, nous prenons le chemin du retour jusqu’aux télécabines, fatigués. Il faut faire attention à chaque pierre sur lesquelles nos pas se posent, pour ne pas tomber, trébucher. L’herbe est encore humide de la fraicheur de la nuit, mais le soleil la sèche bien vite. Plus bas, entre les hauts épicéas, la terre est boueuse et le chemin glissant. Nous déplorons, avec sourires et grandes claques dans le dos, quelques glissades qui ont laissées des traces de boue à l’arrière de nos pantalons. Mais, c’est heureux, avec l’envie de recommencer, que cette aventure se termine avec des croissants et encore du café.

Si ces photos ou textes vous ont donné envie d’essayer et partir à l’aventure, voici avec quoi nous sommes partis (c’est donc un inventaire pour deux personnes et le moment de faire de la publicité de façon complètement désintéressée (non, Décathlon ne nous sponsorise pas, ils font juste du bon matériel)).

Pour la marche

  • Sac à dos 70L et 40L (40L c’est trop petit…)
  • Bâtons de randonnée, ça peut paraitre superflu mais c’est super utile !
  • Chaussures de randonnée, à sérieusement préférer aux tongs, vos chevilles vous remercierons. Je suis parti avec celle-là – Chaussures de randonnée nature NH500 kaki/orange homme QUECHUA – elles coûtent max 40€ alors ne vous privez pas. Certes ce ne sont pas les meilleures, surtout au niveau maintien de la cheville, mais elles sont confortables et sèchent très rapidement (ce qui est pratique quand on fait l’andouille dans l’eau avec). Joe lui est mieux équipé – Chaussures de trekking montagne TREK700 homme FORCLAZ – et les siennes sont anti-dérapantes.

Pour le campement

Pour faire la cuisine

  • Un petit et léger réchaud de ce genre
  • Une Cartouche de gaz à vis power gas 100 grammes pour réchaud PRIMUS et Joe ne jure que par ça ! Car selon lui, elle contient plus de gaz et permet de chauffer plus efficacement, donc dure plus longtemps. Et je confirme, ça chauffe fort…
  • Gamelle pour faire chauffer de l’eau, de ce genre (pas moyen de retrouver le produit que nous avons utilisé…)
  • Bialetti Moka Expresse 3 tasses (je l’aime cette cafetière ❤)

De quoi manger

  • Un saucisson sec pour son apport en sel
  • Un melon pour sa fraicheur et son eau
  • 6 litres d’eau dans des gourdes de 1 litre, soit 3 par personnes. C’est suffisant, pour un campement d’une nuit, mais gare au gaspi.
  • Pâtes à la bolognaise, deux sachets. Ça parait un peu léger à première vue comme repas, mais cela tient au ventre.

Le matériel photo, sans donner de marque, comme cela vous faite avec celle que vous aimez

  • Réflex plein format
  • Téléobjectif 28-300mm f/3.5-5.6
  • Deux batteries (les photos nocturnes sont gourmandes en énergie)
  • Cartes mémoires vides, de quoi mitrailler tranquillement
  • Trépied solide et capable de supporter votre appareil photo sans broncher !
  • Télécommande sans fil pour déclencher sans provoquer d’effet de bougé
  • Du ruban adhésif (Arnaud Thierry du « Studio de poche », vous explique à quoi il sert)
  • Une lampe de poche ou frontale avec lumière rouge
  • Un smartphone avec un logiciel de cartographie du ciel (Sky Map pour Android par exemple)

Ce qui nous a manqué

  • Les gâteaux Prince de LU (mea culpa)
  • Des gants simples
  • Un bonnet
  • Une coupure électrique de l’éclairage public de la ville de Genève…

Convertir un volume vhdx Hyper-V pour l’utiliser avec KVM ou Proxmox VE

Ou comment migrer une machine virtuelle d’une plateforme Hyper-V à une plateforme Proxmox VE.

Hyper-V et Proxmox VE sont deux outils fantastiques pour faire fonctionner des machines virtuelles.
Ici pas de débat sur lequel est le mieux, ni sur les fonctionnalités de chacun (vous savez utiliser Google ?).
Ici nous allons nous contenter d’une bonne grosse procédure qui va nous permettre de réussir la migration d’une machine virtuelle d’une plateforme Hyper-V à Proxmox VE.

Lire la suite ›

Tagués avec : , , ,

.Net Core exécuter des commandes Bash/Shell

Maintenant que .Net Core fonctionne sur Linux, on est tenté d’utiliser la puissance de cette OS mais aussi des applications qui y fonctionnes.
Mais n’oublions pas non plus les utilisateurs de Windows.

Je vous propose ici un code très légèrement remanié dont la source se trouve ici : https://loune.net/2017/06/running-shell-bash-commands-in-net-core/.
Dans le cas où vous voulez faire fonctionner des appels à Bash sous Windows, pensé à installer Git.
Car c’est sur lui que je me repose pour avoir l’exécutable du Bash.

    public static class ShellHelper
    {
        public static string Bash(this string cmd)
        {
            string bashPath = System.Runtime.InteropServices.RuntimeInformation.OSDescription.ToLower().Contains("windows")
                ? "C:\\Program Files\\Git\\bin\\bash.exe"
                :"/bin/bash";

            if (!File.Exists(bashPath))
            {
                throw new System.Exception("Bash n'est pas installé sur ce système");
            }

            var escapedArgs = cmd.Replace("\"", "\\\"");
            
            var process = new Process()
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = bashPath,
                    Arguments = $"-c \"{escapedArgs}\"",
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                }
            };

            process.Start();

            string result = process.StandardOutput.ReadToEnd();

            process.WaitForExit();

            return result;
        }
    }
}

Comme expliquer pas son auteur original, ce code est une méthode d’extension. Donc après avoir importé le namespace, vous pouvez l’utiliser comme suit :

var output = "ps aux".Bash(); 

output va contenir le STDOUT résultant. Le STDERR n’est pas capturé par la méthode. Mais cela peut être fait de manière simple en changeant la propriété RedirectStandardOutput et en lisant le contenu de process.StandardError

.Net Core application console comment cacher la saisie d’un mot de passe

Je travaillais sur une application console (CLI) faite en .Net Core et je me suis demandé :
Mais comment faire pour que la saisie d’un mot de passe dans la console soit comme sur Linux, c’est-à-dire que la saisie ne s’affiche pas dans la console ?

En fait c’est d’une simplicité déconcertante

private string AskForPassword()
{
    Console.Write("Veuillez saisir votre mot de passe : ");

    string password = "";
    ConsoleKeyInfo info = Console.ReadKey(true);
    while (info.Key != ConsoleKey.Enter)
    {
        if (info.Key != ConsoleKey.Backspace)
        {
            password += info.KeyChar;
            info = Console.ReadKey(true);
        }
        else if (info.Key == ConsoleKey.Backspace)
        {
            if (!string.IsNullOrEmpty(password))
            {
                password = password.Substring
                (0, password.Length - 1);
            }
            info = Console.ReadKey(true);
        }
    }

    return password;
}

Source du code

How to create Nuget Package for .Net Core

Yep! Another article about Nuget package creation. And you know why? It’s a pain in the ass (hou rude words for a shiny morning…).

When I discover Nuget packages I was really enthusiast. It’s look like Composer package. But not really…

You have to manage by hand all the dependencies. And that’s make me angry!

I’m a lazy developer, so how can I make easily a Nuget package, with just only one command line?

Follow me, I show you.

This article is based on my work on the GST.Library that is a .Net Core solution who hold some libraries. I’ve faced the problem of building multi Nuget package from one solution. We need to automate the build of each package and we need something to manage dependencies and cross dependencies of each project.

The solution file organisation:

| GST.Library.sln
|
+---artifacts
| GST.Library.API.REST.1.0.0.nupkg
| GST.Library.API.REST.1.0.0.symbols.nupkg
|
+---src
| +---GST.Library.API.REST
| | | GST.Library.API.REST.nuspec
| | | project.json
| | |
| | +---Annotations
| | \---Pagination
| |
| +---GST.Library.Data
| | | GST.Library.Data.nuspec
| | | project.json
| | |
| | \---Extentions
| |
| +---GST.Library.Helper
| | | GST.Library.Helper.nuspec
| | | project.json
| | |
| | \---Type
| |
| \---GST.Library.StoredProcedureHelper
| | GST.Library.StoredProcedureHelper.nuspec
| \ project.json
|
+---test
\---tools

First of all, we are using Cake (for once cake is not a lie)! Cake is a task runner like Grunt, but made for Windows stuff, like building .Net Core application or C# DSL. What is nice with Cake, that it is cross platform application (you can use it on Linux).

To use Cake, we have to copy two (or one file) from their Github repo https://github.com/cake-build/example.

Take `build.ps1` for running with Powershell or `build.sh` for running with bash.

These two files contains the code for installing Cake, if it’s not, and running the `build.cake` file who will contain all our needed tasks to build Nuget packages.

Now you have to create a `build.cake` file and put this code inside :

#tool "nuget:?package=xunit.runner.console"
//////////////////////////////////////////////////////////////////////
// ARGUMENTS
//////////////////////////////////////////////////////////////////////

var target = Argument("target", "BuildPackages");
var configuration = Argument("configuration", "Release");

//////////////////////////////////////////////////////////////////////
// PREPARATION
//////////////////////////////////////////////////////////////////////

// Define directories.
var artifactsDir  = Directory("./artifacts/");
var rootAbsoluteDir = MakeAbsolute(Directory("./")).FullPath;

//////////////////////////////////////////////////////////////////////
// TASKS
//////////////////////////////////////////////////////////////////////

Task("Clean")
    .Does(() =>
{
    CleanDirectory(artifactsDir);
});

Task("Restore-NuGet-Packages")
    .IsDependentOn("Clean")
    .Does(() =>
{
	DotNetCoreRestore("src");
});

Task("BuildPackages")
    .IsDependentOn("Restore-NuGet-Packages")
    .Does(() =>
{
	var rootAbsoluteDir = "./build/bin";
    var nuGetPackSettings = new NuGetPackSettings
	{
		OutputDirectory = rootAbsoluteDir + @"\artifacts\",
		IncludeReferencedProjects = true,
		Properties = new Dictionary<string, string>
		{
			{ "Configuration", "Release" }
		}
	};

	var settings = new DotNetCoreBuildSettings
     {
         Framework = "netcoreapp1.1",
         Configuration = "Release",
         OutputDirectory = "./artifacts/"
     };

	DotNetCoreBuild("./src/**/project.json", settings);

	var packageSettings = new DotNetCorePackSettings
     {
         Configuration = "Release",
         OutputDirectory = "./artifacts/"
     };

    // For each project that we want to packaged
    DotNetCorePack("./src/GST.Library.API.REST/", packageSettings);
    DotNetCorePack("./src/GST.Library.Data/", packageSettings);
    DotNetCorePack("./src/GST.Library.Helper/", packageSettings);
    DotNetCorePack("./src/GST.Library.StoredProcedureHelper/", packageSettings);
});


//////////////////////////////////////////////////////////////////////
// EXECUTION
//////////////////////////////////////////////////////////////////////

RunTarget(target);

We have one more things to do. That’s the hard part. You have to install Nuget on your system (and add it to your environment variable) or just download the nuget.exe and put it in your project folder.
Now open a Terminal (Powershell console) and write : `nuget spec`
With this command line Nuget will create a ` Package.nuspec` file. This file is the manifest of your package.
Please take time to read the official documentation. But don’t waste time on the dependencies part. Our Cake script will take care to fill-up dependencies for us. We don’t have to do this manually, and that’s the real comfort to use automation.

You can take a look at our github repository https://github.com/GestionSystemesTelecom/gst-library , you will have a real world example. This repository is tie with Appveyor, and every time we push code on that repo, Appveyor compile and push nuget packages to nuget.org.

For the GST.Library, I wanted that each project would be a Nuget package. By putting in each project a “.nuspec” file and using Cake automation, I can easily create multi Nuget package.

Thanks to this blog post to show me the way: https://blog.codeinside.eu/2017/02/13/create-nuget-packages-with-cake/

What to Do When Visual Studio Debugger Won’t Attach to Docker

I use Docker since months to developpe ASP.Net Core applications. It’s really something to work with this kind of technologies.

But sometime, a glitch come around and drive you crazy (just a little bit, not more). Docker was running fine and you update your Nuget’s packages (because it’s a good thing to keep ours dependencies up-to-date). And now, Visual Studio start to yell at you that kind of error:

The target process exited without raising a CoreCLR started event. Ensure that the target process is configured to use Microsoft.NETCoreApp 1.0.0 or newer. This may be expected if the target process did not run .NET code.

Like said the book « Don’t Panic! »

Two step to check.

First, in one of your project.json (if you use it), check if in the dependency you have the right syntax for Microsoft.NETCore.App, like below

"Microsoft.NETCore.App": {
"version": "1.1.1",
"type": "platform"
}

Second step, reset to factory defaults your Docker setup, like explain in this post https://dzone.com/articles/what-to-do-when-visual-studio-2017-debugger-wont-a (Yes I’m lazy, I use the same title with no shame ;) ).

If this two steps don’t resolve your problem, now you panic…

Configuration d’un Linux derrière un serveur proxy

Voici comment configurer pleinement un pc sous Linux (Ubuntu, Linux Mint) pour passer à travers un serveur proxy d’entreprise.

Cet article est donc un tutoriel pour configurer Linux pour l’utilisation de cette merveilleuse chose qu’est un serveur proxy d’entreprise.

Pour commencer il vous faut l’adresse IP et le port du serveur proxy. Pour notre article, le serveur proxy aura l’adresse 192.0.0.1, avec le port 8181.

Puis suivez les étapes ci-dessous :
Étape 1 – Configuration du nsswitch
Étape 2 – Configuration WPAD
Étape 3 – Configuration d’APT
Étape 4 – Configuration des variables d’environnements
Étape 5 – Configuration de la commande sudo
Étape 6 – Autres applications

Lire la suite ›

Symfony2 et jQuery Datatable

Nous avons tous eu, un jour, le besoin d’afficher un tableau de données dans nos pages Web. Quand c’est un tableau de données figées et peu nombreuses, nous le réalisons à la main. Quand elles sont dynamiques, mais toujours peu nombreuses, nos outils de templating, comme Twig, sont amplement suffisants.
Par contre, quand les données sont dynamiques, très nombreuses, qu’il faut gérer une pagination et si en plus ce tableau doit proposer la manipulation de ces données, là ça commence à être vraiment complexe.

Datatable est un plugin pour jQuery qui permet de réaliser simplement des tableaux de données (aussi appelé datagrid) dynamiques et paginables, avec chargement des données asynchrones, qui trie par colonne, filtre des données affichées et/ou filtre côté serveur. Il propose de nombreuses fonctionnalités ce qui le rend vraiment indispensable. Lire la suite ›

Tagués avec : , ,

Plan d’auto-formation à Symfony2 et les concepts associés

Voici un plan d’auto formation à Symfony2 et ses concepts associés. Cet article comporte beaucoup de liens vers différentes documentations qui vous permettrons d’appréhender simplement Symfony2 et le monde de la qualité de code de PHP.

Sommaire

Lire la suite ›

Tagués avec :

Extension Doctrine pour la fonction Match Against

Voici un tutorial Symfony2 pour ajouter la fonction Match Againts à Doctrine pour l’utiliser dans vos requêtes DQL.

Le serveur de base de données Mysql gère la fonction Match Againts uniquement avec le moteur MyISAM. Cela est vrais pour les versions inférieur à la 5.6. Dans la version 5.6 cette fonction sera aussi géré par le moteur innoDB. Ce tutorial est donc à adapter si vous bénéficier d’une version 5.6 ou plus.

Lorsque l’on créé une base de données avec Doctrine, il utilise par défaut le moteur innoDB car il gère les relations entre les tables. On va donc être obligé de s’adapter.

Dans ce tutorial, nous cherchons à faire une recherche Full Text sur certain champ d’une entité Fiche. Pour cela nous allons devoir coder un peu.
Dans un premier temps nous allons ajouter la fonction Match Againts à Doctrine (avec ses tests unitaires).
Nous devrons créer ensuite une classe qui servira uniquement à la recherche Full Text. C’est contraignant, mais si vous tenez à réduire le nombre de requête SQL émise par votre application, c’est un mal nécessaire.
Enfin nous ajouterons un écouteur pour synchroniser notre classe d’indexation avec notre fiche.
Lire la suite ›

Tagués avec : , ,
Top