C# 9 – Introduction

Les nouveautés du C# 9

Microsoft nous a récemment parlé du C# 9 durant la Build 2020, les experts INFEENY vont donc vous détailler et vous expliquer les nouveautés du C# 9.

Le Target typed

Ce que nous attendions depuis longtemps est enfin arrivé : le type ciblé (target typed). Il s’agit d’utiliser le mot-clé new() et seulement celui-ci pour instancier une class. Nous n’avons plus besoin de nous soucier du type à la création d’un objet à condition qu’il puisse être déduit par le compilateur.

Avant :


Classname objet =  new Classname(param1, param2) ;

Devient


Classname objet = new(param1, param2) ;

Comme nous pouvons le voir, dans la deuxième partie, le nom de la class avant le mot-clé new n’est plus utile.

Les propriétés Init-only

Avant C# 9 il fallait que des propriétés soit modifiables pour que l’initialisation de l’objet fonctionne. Cependant C# 9 introduit les accesseurs init qui permettent de set une valeur à une propriété qu’à l’instanciation de notre class.

Exemple :


public class Players
{
public int X { get; init; }
public int Y { get; init; }
}

Avec cette class l’utilisateur pourra donc modifier X et Y seulement pendant l’instanciation de la class sinon il renverra une erreur.

Le type record

Avant le C# 9, nous devions créer une class avec toutes propriétés déclarées dans celle-ci, ainsi que de surcharger (override) l’opérateur Equals et le GetHashCode. Enfin, créer un constructeur si besoin pour chaque propriété que l’on voulait set. Cela est de même pour le destructeur. Ce qui était fastidieux pour finalement peu d’utilité.

Aujourd’hui, C# 9 nous permet de faire cela en une simple ligne de code grâce au mot-clé data. Les propriétés crées seront en init-only. L’avantage du type record est donc sa simplicité. Cependant, sachez que vos propriétés seront immuables (const).

Avant :


class Players 
{
private int X {get;}
private int Y {get;}

public Players(int x, int y) 
{
this.X = x;
this.Y = y;
}
}

Devient


public data class Players(int X, int Y); // ici les propriétés sont en init-only,

si vous vouliez faire de l’héritage


public data class Mage : Players{int Mana} ; // cette class contiendra les propriétés X, Y, Mana

L’expression With

Si nous voulions modifier les valeurs des propriétés de notre class nous devrions donc créer une copie de cette classe en modifiant la valeur qui nous intéresse. C# 9 introduit donc une nouvelle expression : with. Cette expression clone l’objet d’origine, en remplaçant les valeurs des propriétés spécifiées entre les accolades. Pour cet exemple nous allons utiliser la class créer au-dessus avec data. Exemple :


Players player1 = new(1, 2) ;
Players player2 = player1 with {Y = 42};

La gestion des paramètre NULL

En plus du mot-clé with, C# 9 introduit une syntaxe simple pour vérifier automatiquement si des paramètres de fonction sont null. Cette syntaxe est représentée par un ‘ !’ après le nom du paramètre de votre fonction à vérifier. Si la variable a pour valeur null, il throw une exception du type ArgumentNullException.

Avant :


public string saysomethings(string somethings) 
{
if (somethings == null)

throw new ArgumentNullException(nameof(somethings));

return $"you say {somethings}";
}

Devient


public string saysomethings(string somethings!) => $"you say {somethings}";

L’égalité basé sur les valeurs

C# 9 a introduit une nouvelle fonctionnalité à l’opérateur Equals. Cette fonctionnalité permet donc de comparer deux objets selon les valeurs des propriétés et non pas l’objet en lui-même. Equals va donc comparer champs par champs et renvoyer true s’ils sont tous égaux.

La covariance du type de retour (modification)

Un nom bien compliqué qui vous simplifiera beaucoup la vie. Avant C# 9, en héritant d’une class, si nous voulions Override une méthode nous devions avoir le même type de retour que la méthode mère. C# 9 introduit le fait de pouvoir modifier ce type de retour. Exemple:


public class anyClass
{
public virtual anyClass Clone() => new anyClass();
}

public class SpecificAnyClass : anyClass
{
// Override with a more specific return type
public override SpecificAnyClass Clone() => new SpecificAnyClass();
}

Top level Programs ( Programmation au niveaux supérieur)

C#9 simplifie aussi l’écriture de code en permettant de le rédiger au niveau supérieur de votre fichier.

Avant :


using System;

class Program
{
static void Main()
{
Console.WriteLine("Hello World!");
}
}

Devient


using System; Console.WriteLine("Hello World!");

Pour finir, C# 9 ajoute aussi un dernier mot-clé : not. Il fonctionne de la même manière que « != ».

Exemple


if (player is not Mage) { … }

Pour conclure :

Nous avons balayé les principales fonctionnalités de C# 9

Project Réunion

Qu’est ce que Le Projet Réunion nous apporte ?

Projet Réunion nous apporte trois nouvelles fonctionnalités dans lesquelles vos applications pourront piocher:

  1. De nouvelles API
  2. Un sous-ensembles D’API
  3. Des API convergentes

Les nouvelles API (new) : 

De nouvelles fonctionnalités Windows seront fournies dans le projet Réunion, celles-ci seront transparentes dans leurs identités, leurs packagings et leurs isolations. De plus elles partageront une interface commune ce qui vous permettra de l’utiliser peu importe le type de votre application (MSIX, MSI, Setup.exe, Desktop Bridge, AppContainer).

New APIs

Ces API sont autonomes et ont pour but de répondre à des problèmes spécifiques que vos applications peuvent rencontrer, elles vous aideront aussi à mettre en place des fonctionnalités supplémentaires.

Voici une liste potentielle des différents types d’API qui ne seront pas forcément pressent le premier jour :

  • Stockage et gestion des données dans un seul endroit pour garder en ordre le système de l’utilisateur
  • Cloud app support pour la gestion de l’identité ainsi que de la connectivité afin d’utiliser Azure
  • Packaging et système intégration pour que Windows comprenne ce que fait votre application
  • Aide de communication entre différentes applications (app-To-app) pour que vos applications fonctionnent ensemble.
  •  API d’accès aux ressources pour les caméras, les microphones et la localisation qui respectent la vie privée.

Comment utiliser ces nouvelles API ?

Pour utiliser ces API il vous suffit d’ajouter dans un premier temps le package NuGet « Project Reunion » et dans un second temps d’en faire appelle dans votre code. Les API seront disponibles dans toutes les versions de Windows ainsi que pour toutes les applications. Si certaines API se comportent autrement (du a son identité, d’un isolement particulier ou d’un cycle de vie différents) vos applications sont en mesures de le détecter grâce aux contrôles du type « TheType.IsSupported ».

Les API convergentes (converged):

Projet Réunion propose des Api de surface qui permettent de faire la liaisons entre Win32 et les fonctionnalités UWP/AppContainer déjà présentes dans la plate-forme. Les auteurs de comme partagé (Frameworks ou autre) peuvent avoir recours a une seule méthode afin d’éviter leurs propres verifications  » if (AppContainer) { x } else { y } ». Projet Reunion fournit des implémentations « polyfill » des API lorsque c’est nécessaire pour que votre application puisse fonctionner sur d’autres versions de Windows sans vérification supplémentaires.

Converged APIs

Voici quelque exemple d’API convergentes :

  • Window Content Frame abstraction entre WIn32 et UWP
  • Application lifecycle behaviors pour le démarrage, la déconnexion , ‘intégration du gestionnaire de redémarrage, le redémarrage pour la mise à jour
  • Assistance au démarrage et aux tâches de fond pour réduire la puissance et les performances de votre
  • Gestion des ressources d’application pour les chaîne de caractères(strings), les images, les résolution d’affichages et localisation

Une fois que vous avez ajouté les références a Projet Réunion l’application pourras commencer à migrer des blocs de fonctionnalités vers L’utilisation de ces API convergentes  entièrement prises en charge. Vous pouvez donc migrer autant de fonctionnalités que nécessaire, en conservant le style ainsi que le comportement de votre application. Ces API seront similaires a celles du SDK ce qui facilitera la transition. En ce qui concerne les API Win32 « Flat C » existantes, une API convergente sera ajoutée puis envoyer dans votre langage et votre runtime.

Lorsque les applications aurons migré pour Projet Réunion il sera plus facile d’alterner entre déploiement et isolation. En effet Projet Réunion gère l’accès au ressources à partir d’un processus avec un faible niveau d’intégrité (LOWIL) ou AppContainer pour que votre application puisse référencer les ressources tout en respectant le choix de l’utilisateur ainsi que les contrôles de confidentialité.

Converged APIs

Les sous-ensembles d’API (Subset Family):

Les sous-ensembles API vous permettent de commencer a utiliser les fonctionnalités de Project Reunion avec des changements minimaux de votre code déja existant. Cela fonctionne en utilisant un ensemble d’en-têtes et de mises en œuvre mis à jour et rationalisés.

Le Projet Réunion aide a rester dans l’ensemble des API que des Windows peu prendre en charge dans toutes les editions and les points de terminaison (endpoints).

Projet Reunion définit un sous-ensemble d’API prises en charge dans toutes les versions Windows. Si votre code cible ce sous-ensemble et utilise les Project reunion new API avec les Project Converged API il fonctionnera partout où Windows fonctionne sans ajout supplémentaire.

Les fonctionnalités prises en charge par le sous-ensemble de Project Reunion comprennent des sous-ensembles de :

  • Windowing, Input, Messaging, GDI, and GUI subsystem functionality
  • Filesystem and storage access
  • Networking
  • Printing
  • Process, threading, memory management, basic application services
  • DirectX, D3D, DirectML

Comment migrer vers l’ensemble d’API de Projet Reunion Subset ?

Pour migrer votre application il vous suffit de supprimer toute les références aux headers de Windows Kit (windows.h, kernel32.lib, user32.lib, winsock.h, etc) puis ajouter les références au header principal de Projet Reunion Subsete et aux lib d’importation.

Point important, malgres que de nombreuses API font parties du Kit WIndows ainsi que du sous-ensemble de Projet Réunion, il se peut que vous ayer quelques changements a effectuer dans votre code ou dans le comportement de votre application.

Composantes du Projet Réunion (Project Reunion Family Components) ?

Ce qui est disponible dès maintenant

Ces composants sont à votre disposition dès maintenant et respectent la « promesse de la famille du projet Réunion », à savoir qu’ils disposent d’une API unique pour toutes sortes d’applications.

  • WinUI 3 pour XAML vous aide à créer des UX fluides pour toutes sortes d’applications grâce à la puissance de XAML. Ce composant {lien vers repo} fait partie de la famille de fonctionnalités de Project Reunion, s’appuyant sur l’identité + le packaging + les idées transparentes de déploiement que Project Reunion prend également en charge pour votre application.
  • C++/WinRT, RUST/WinRT et C#/WinRT fournissent des projections en langage natif de Windows, de Project Reunion et de vos propres types personnalisés définis dans les métadonnées. Consommez les API du kit Windows, produisez-les pour les utiliser avec d’autres projections prises en charge et créez vos propres nouvelles projections de langage.
  • MSIX-Core vous permet de conditionner votre application pour la distribuer sur les machines Windows Desktop via le magasin ou votre propre pipeline de livraison. MSIX-Core vous permet d’utiliser les parties réutilisées de l’histoire du packaging MSIX sur les anciennes versions de Windows.

Ce qui est bientôt disponible

Bien que nous pensions qu’elles soient intéressantes pour les candidatures, c’est à vous de nous le dire ! Le travail au grand jour consiste en partie à apprendre ensemble les besoins des développeurs d’applications. Vous trouverez ci-dessous un ensemble de fonctionnalités qu’il semble intéressant de mettre à disposition dans le cadre d’un modèle convergent ou nouveau, mais c’est à vous de nous le dire ! Certaines sont liées à un fil de discussion proposant la fonctionnalité. +1 celles que vous aimez, commentez la conception détaillée et la direction, et aidez-nous à déterminer où nous allons.

  • WebView2, qui s’appuie sur Edge/Chromium, vous permet de créer facilement votre application en HTML+JS une fois et de la réutiliser sur toutes les plateformes. L’utilisation par WebView2 de technologies du Projet Réunion comme WinUI3 comme cadre d’hébergement vous permet d’exécuter un UX moderne basé sur le web sur toutes les éditions de Windows.
  • Modern Lifecycle helpers permettent à votre application d’être sensible à la consommation d’énergie et de réagir aux changements dans la gestion de l’énergie du système d’exécution et dans l’état de l’utilisateur. Elles aident également votre application à redémarrer après le redémarrage de l’utilisateur, enregistrent votre application pour qu’elle puisse être redémarrée et réduisent les redémarrages liés aux mises à jour.
  • Startup tasks donnent vie à votre application lorsque l’utilisateur se connecte pour se reconnecter, commencer à travailler sans surutiliser les ressources ou être prêt à une utilisation rapide. Les fonctions de choix de l’utilisateur et de gestion de l’énergie vous permettent de réduire votre impact sur le chemin critique de la connexion.
  • Update Scan Integration permet de maintenir votre application à jour automatiquement pendant son exécution, en même temps que d’autres tâches de maintenance du système.
  • Accès aux ressources utilisateur même à partir d’AppContainer et d’applications isolées. Vos applications AppContainer peuvent accéder à de puissantes technologies Win32 comme le presse-papiers, la communication entre processus et l’espace de nommage Windows Shell avec le consentement de l’utilisateur par le biais d’un courtage.
  • Modern Resource Tooling pour que vous puissiez utiliser la puissance de ResX/ResW dans vos applications Win32 au lieu de MUI.

Orientation future

Nous avons pour objectif de développer le Projet Réunion afin de fournir une version moderne, simple et accessible d’une grande partie de la puissance de la plate-forme d’application Windows. Le fait de travailler au grand jour avec notre communauté de développement garantit que nous faisons d’abord les bonnes choses pour résoudre les problèmes auxquels vos applications sont confrontées sur les versions actuelles et futures de Windows.

Certaines fonctionnalités seront d’abord livrées en tant que composants du projet Reunion. Lorsque nous pensons à faire évoluer la plate-forme, il est important de s’assurer que les nouvelles fonctionnalités et caractéristiques sont disponibles pour notre communauté de développeurs dès qu’elles sont prêtes à être utilisées. Les nouvelles fonctionnalités de la plate-forme vous aideront à les adopter dès qu’elles seront disponibles, sans que vous ayez à les cibler ou à les réécrire.

À mesure que votre application utilisera davantage de fonctionnalités de Project Reunion, elle sera prête pour des cibles supplémentaires telles que le packaging, l’identité, l’AppContainer et d’autres futures éditions Windows. Dépendre des API de Project Reunion signifie que nous prenons en charge le travail pour que ces API continuent à fonctionner au fur et à mesure de l’évolution de Windows. En restant dans la surface de l’API du Projet Réunion, vous vous assurez que votre application peut répondre à la plus large gamme d’éditions et de versions de Windows tout en utilisant des fonctionnalités à jour.

Comment nous procédons

Travailler au grand jour

Le Projet Réunion s’appuie sur la puissance de l’open-source et les fonctionnalités de GitHub pour vous livrer du code aussi vite que nous pouvons l’imaginer. Vous devez vous sentir libre de bifurquer, de créer des demandes de retrait, d’ouvrir des problèmes, de proposer des résolutions aux problèmes. Vous pouvez voir et influencer toutes nos fonctionnalités via le « issue tracker ». Vous devez vous attendre à ce que nous vous écoutions et que nous vous fournissions un retour d’information constructif.

Constructions et artifacts

Le code dans le cadre du projet Réunion GitHub repo s’appuie sur une boucle CI/CD et produit des DLL et des métadonnées fraîchement construites sur chaque demande de retrait. Le résultat comprend un paquet NuGet contenant les métadonnées pour le projet Reunion et un MSIX prêt à être livré pour être inclus dans votre demande comme redistribuable ou comme référence de paquet. Ajoutez une référence au paquet de Project Reunion et commencez à construire. Pour vous aider à déployer vos applications, nous inclurons un MSIX Framework Package ainsi que des instructions sur la façon de déployer ce MSIX à partir de votre installateur existant.

Versionnement
Le projet Reunion utilisera des définitions d’API basées sur des métadonnées fortement typées sur lesquelles vos applications peuvent prendre une dépendance à long terme suivant le cycle de vie de notre support publié. Nous utiliserons SemVer 2 pour identifier clairement les niveaux de forme des API qui permettent à ces API d’évoluer vers de nouvelles fonctionnalités sans compromettre les applications existantes. Project Reunion aide à maintenir les applications à jour grâce à des Framework Packages qui sont mis à jour avec des changements non cassants le cas échéant.

Extension des API
Une partie de ce que le Projet Réunion fournit est l’accès à des fonctionnalités qui se trouvent dans Windows, mais pour lesquelles il n’y a pas d’API publique. Nous travaillons sur les détails, mais notre plan est de fournir un paquet secondaire de code qui fournit une API publique sur ces composants précédemment non exposés. Ces composants seront mis en œuvre en tant que source fermée, mais ils seront accompagnés d’une surface d’API basée sur les métadonnées, pouvant être appelée et prise en charge par le public, et seront inclus dans les paquets du cadre du projet Reunion pour être utilisés par les applications.

Courtage
Les processus UWP (AppContainer, Low-IL) sont destinés à protéger à la fois l’utilisateur et l’application elle-même contre d’autres applications. L’accès aux ressources de l’utilisateur et du système est limité à l’ensemble des courtiers pris en charge pour ces ressources. Le projet Reunion comprend également un paquet principal qui fonctionne au niveau d’intégrité de l’utilisateur (moyen-IL, parfois appelé « full trust ») et peut fournir un accès approuvé par l’utilisateur à des ressources auparavant non disponibles pour les processus AppContainer et Low-IL.
Ce modèle est aujourd’hui disponible pour les applications AppContainer en tant que « composant de confiance totale » – le projet Reunion vise à fournir un modèle et une plate-forme communs pour ces composants personnalisés.

Ce que le Project Reunion n’est pas

Le Projet Réunion n’est pas un nouveau modèle d’application ou une nouvelle plate-forme de Windows. Il n’y aura pas de « nouvelle application Project Reunion » pour Visual Studio, VSCode ou d’autres environnements de développement.
Vous aurez toujours un accès complet au SDK Windows et aux kits associés. Au fil du temps, les fonctionnalités offertes par Project Reunion iront au-delà de la simple fusion des modèles Win32 et UWP existants et fourniront des fonctionnalités supplémentaires à toutes les applications à utiliser.

Project Reunion n’est pas un nouveau modèle d’empaquetage ou d’isolation des applications. Il n’est pas nécessaire de modifier votre application pour accéder à la fonctionnalité de Project Reunion, si ce n’est en utilisant la nouvelle fonctionnalité elle-même. Si les API que vous utilisez ont besoin d’une identité ou d’un packaging, ces exigences seront indiquées.

Le Projet Réunion n’est pas un nouveau modèle de sécurité ou de confidentialité pour les applications. Les histoires de sécurité, de confidentialité, de fiabilité et d’identité de votre application continuent de fonctionner avec Project Reunion. Il y a peut-être des endroits où le Projet Réunion aide votre application à être plus consciente des préoccupations des clients en matière de sécurité ou de confidentialité. Le Projet Réunion vous aide à utiliser des fonctionnalités modernes de sécurité et de confidentialité qui évoluent en fonction des besoins de votre application.

Le Projet Réunion n’est pas un moyen d’exécuter votre application dans le cloud. L’utilisation de la technologie de Project Reunion vous permettra d’intégrer votre application dans des familles d’API modernes qui sont prêtes pour le cloud. Des composants clés comme le cycle de vie moderne et l’isolation des états permettent de préparer votre application à fonctionner où que soient vos clients.

Project Réunion – Overview

Qu’est-ce que Le Projet Réunion ?
Project Reunion est la vision Microsoft pour unifier et faire évoluer la plate-forme de développeur Windows pour faciliter la génération d’applications formidables qui fonctionnent sur toutes les versions et appareils Windows 10 que les gens utilisent.

Project Reunion facilite la construction d’une grande application Windows en fournissant une plate-forme unifiée pour les applications Win32 et les applications UWP nouvelles et existantes. Il unifiera l’accès aux API Win32 et UWP existantes et les rendra disponibles découplés à partir du système d’exploitation, via des outils comme NuGet.

Project Reunion vous aidera à mettre à jour et à moderniser vos applications existantes avec les dernières fonctionnalités, qu’elles soient C++, .NET (y compris WPF, Windows Forms et UWP) ou React Native. Au fur et à mesure que Microsoft découple les API existantes et ajoute de nouvelles API, un travail pour polyfiller est réalisé, au besoin, de sorte que les API fonctionnent à un niveau bas entre les versions prises en charge de Windows.

Comment utiliser ?
WinUI 3 Preview 1 est l’un des premiers composants du voyage Project Reunion : c’est le cadre d’interface utilisateur natif moderne pour Windows, maintenant disponible pour tous les développeurs d’applications Windows dans les applications UWP et Bureau. À l’aide de WinUI, vous pourrez créer de nouvelles applications avec interface utilisateur moderne qui s’adapte et scalent à tous les appareils, ou moderniserez progressivement l’interface utilisateur des applications de bureau existantes, y compris C++, WPF et WinForms.

 

WinUI 3 – L’avenir du développement UI pour les devices Windows 10

La conférence BUILD nous annonce WinUI 3 : c’est l’avenir du développement UI sous les devices Windows 10.

Depuis l’apparition de Windows 10, de nouveaux contrôles graphiques sont apparus au sein du système d’exploitation. Les applications Accessoires comme la calculatrice, courrier, paint 3D ou le panneau de configuration ont un nouveau look, plus épuré, plus « Fluent ».

Les nouveaux contrôles graphiques sont implémentés en C++ et mis à disposition dans System32 via la librairie dynamique Microsoft.UI.Xaml.dll. Vous allez me dire Xaml ? Mais je connais, c’est WPF ? Et bien oui mais non… La Division qui fait Windows n’est pas très fan de WPF et de NET en général donc il n’y en a pas dans Windows. Par contre, il existe une implémentation Xaml en C++ ! Et la syntaxe/technologie Xaml est commune entre Windows et WPF.

Avec WinUI, il est possible de mettre des contrôles XAML Windows 10 et ce même pour les premières versions de Windows 10 dans des applications Win32, WinForms ou WPF.

Introduction au monde Fluent

Voici le look Fluent Design. Cela vous rappelle le panneau de configuration Windows 10 ?

C’est du XAML. L’écran est entièrement configuré en XML de type XAML.

Introduction aux contrôles natif C++

Le module se nomme Microsoft.UI.Xaml.dll et il contient tous les contrôles Xaml Windows 10. Il utilise les API WinRT du mode UWP.

Rappel des repo github utiles:

La Direction Technique et les Experts Infeeny vous préparent une série de contenus sur WinUI. A suivre.

 

 

7 astuces pour améliorer le télétravail et juguler la profusion de contenu dans Teams

Vous retrouverez dans cet article, l’ensemble des Questions/Réponses du webinar Infeeny x Avepoint du 12 mai 2020.

1 – A partir de Teams Corporate peut-on interagir avec un contact hors entreprises (consumer) ?

Il est tout à fait possible d’interagir avec un contact externe sur le Teams de votre entreprise. Pour cela, votre administrateur Office 365 doit :

  1. Autoriser l’accès aux personnes externes sur Microsoft Teams, ces derniers se verront donc attribuer le statut « d’invités ».
  2. Avoir activé les fonctionnalités de conversations et de réunions sur Teams. Une fois ces 2 conditions remplies, vous pourrez interagir avec les personnes externes (créer une nouvelle conversation, les inviter dans une équipe et collaborer avec elles, etc …). Il faut bien-sûr que le contact externe ait déjà un compte Microsoft afin de pouvoir aller sur Teams.

 

2 – En mode vidéo calls, on est limité à 20 personnes. Cependant, nous ne voyons que 4 intervenants. Est-il possible de modifier cela ?

Avec la recrudescence des logiciels de visioconférence depuis le Covid-19, Microsoft a décidé d’améliorer cet élément. Vous pourrez bientôt (à partir de mai) afficher 9 flux vidéo à la fois.

 

3 – Comment faciliter le travail entre différents environnements ? Je veux dire dans Teams de différentes sociétés ?

Vous pouvez facilement interagir avec un contact externe à votre entreprise via Teams. Pour cela, votre administrateur Office 365 doit autoriser l’accès aux personnes externes sur Teams, ces derniers se verront donc attribuer le statut « d’invités ». Il faut que l’une des deux sociétés invite les membres de la deuxième dans une équipe et vous pourrez ensuite interagir et collaborer ensemble.

 

4 – Pour vos Webinar, pourquoi utiliser GotoWebinar au lieu de Teams ?

Nous utilisons GoToWebinar plutôt que Microsoft Teams selon les directives de Microsoft, de utiliser les plateformes d’hébergement tierces pour les événements virtuels.

 

5 – Où trouver des ressources (templates) d’organisations / d’équipes déjà fait ? Genre un coworking space, ou une école, ou un bureau d’avocats ?

Vous trouverez plus d’informations sur les modèles de Teams de base (Ex: Standard (default), Éducation (3), Commerce de détails (2) et Santé (2)). Cependant, il est important de noter que ces modèles demandent des configurations globales pour être disponibles dans votre environnement.

 

6 – Dans la roadmap de MS, il est prévu d’interagir les conversations Skype avec Teams avant la fin avril, avez-vous des infos ?

L’interopérabilité entre Skype et Teams est déjà disponible, voici quelques articles techniques qui pourront vous aiguiller sur ce sujet et qui nous l’espérons vous donnera les éléments de réponses que vous recherchez:

https://docs.microsoft.com/fr-fr/microsoftteams/teams-and-skypeforbusiness-coexistence-and-interoperability

https://docs.microsoft.com/fr-fr/microsoftteams/teams-skype-interop

 

7 – Est-ce que Teams fonctionne avec web Outlook ? Merci

Vous pouvez créer une réunion et insérer un lien de conférence Teams à partir du web app Outlook, à condition d’avoir Office 365. Pour cela, il vous suffit créer un « Nouvel événement » et au lieu d’insérer une salle de réunion, choisissez l’option « Réaliser une réunion en ligne » puis « Teams ». Une fois que votre invitation est prête, vous n’avez plus qu’à l’envoyer !

 

8 – Peut-on empêcher l’utilisation des Apps dans Teams ?

Oui… De plusieurs façons, cet élément est contrôlé par l’administrateur de votre environnement Teams.

Vous pouvez bloquer l’utilisation des Apps :

– Premièrement, par la nature de l’App (Microsoft, Tierce-partie ou par App tenant).

– Deuxièmement, par App individuelle et, finalement, par utilisateurs/employés de votre environnement.

 

9 – Comment créer des équipes (Teams) ?

Si activé par votre société, à même l’interface Teams, vous serez en mesure de créer une nouvelle équipe Teams (voir démo). Si cette option n’est pas activée, il se peut que votre société utilise une autre approche via, par exemple, la soumission d’une demande précise par mail ou encore via une application tierce tel que ou similaire à AvePoint MyHub.

 

10 – Pour une réunion de 50 minutes, il faut planifier 50 minutes ou 1 heure ?

Effectivement, tout comme Outlook le permet, Teams permet de planifier des durées de réunions en dehors du standard 30 ou 60 minutes comme, par exemple 50 minutes :

Réunion Teams Infeeny

 

11 – Comment fonctionne la traduction ? Je ne la retrouve pas dans mon environnement.

Le responsable de votre environnement Teams doit dans un 1er temps l’activer via PowerShell ou via le Centre d’Administration de Microsoft Teams.

Si votre administrateur opte pour la seconde option, il devra aller dans les « Stratégies de messagerie » et créer ou modifier une stratégie, puis activer l’option « Messaging Policies » (on/off) > « Activé par défaut ».

Cette fonctionnalité n’est pas disponible pour les communités gouvernementales et en Allemagne.

Pour information, la fonctionnalité utilise le « Translator Text API » basé sur le moteur de traduction machine Microsoft.

 

Abonnez-vous à notre page LinkedIn et retrouvez toutes nos actualités autour de l’univers Modern Workplace. 

 

 

 

Comment sécuriser son Azure Virtual WAN avec Azure Firewall et Azure Firewall Manager (preview)

Azure Firewall Manager (preview)

Introduction

Pour pouvoir suivre cet article sereinement, il faut avoir un minimum de connaissances en matière de SD-WAN/Azure virtaul WAN. L’une des dernières mises à jour de vWAN et qui rend l’outil encore plus intéressant, est la possibilité de déployer une instance d’Azure Firewall sur le Hub. Cette fonctionnalité est fournie avec un autre service, Azure Firewall Manager, sur lequel je voudrais me concentrer aujourd’hui.

Azure Firewall Manager a été publié très récemment, lors du dernier Ignite. Le service permet aux utilisateurs de déployer de manière centralisée des instances d’Azure Firewall sur différents vHubs, sur plusieurs régions et souscriptions. Une fois provisionnées, ces instances peuvent être gérées de manière centralisée en ce qui concerne les règles de pare-feu. Les règles peuvent désormais être déployées de manière hiérarchique, ce qui signifie que l’équipe informatique centrale (global admin) peut fournir une politique globale, en plus de laquelle les organisations locaux peuvent implémenter leurs propres politiques de règles plus spécifiques. Un seul niveau d’héritage est cependant autorisé.

Dans le format actuel, le service offre la possibilité de déployer des pare-feu sur des vHUB créés dans un Azure virtuel WAN. Firewall Manager propose également une gestion centralisée des itinéraires. Cette fonctionnalité est fantastique à mon avis – avec un seul commutateur, nous pouvons forcer le trafic via le pare-feu, sans avoir à créer des itinéraires définis par l’utilisateur.

Objectif de cet article

Dans cet article, nous allons voir comment déployer des vSecure HUB dans un environnement Azure WAN afin de tester les fonctionnalités d’Azure Firewall Manager. Pour cela, nous utiliserons Azure CLI, à ce jour, il n’est toujours pas possible de le faire en Powershell/Terraform.

Notre exemple portera sur les ressources suivantes :

  • 1 Azure Virtual WAN
  • 3 vHUB
    • un virtual HUB pour la region west-us
    • un virtual HUB pour la region east-us
    • un virtual HUB pour la region west-europe
  • 1 VPN Gateway (branch onpremise)
  • 4 Azure Firewall Policy (preview)
    • root-policy (global admin)
    • westus-region-policy (local admin)
    • eastus-region-policy (local admin)
    • westeurope-region-policy (local admin)

Let’s Go !

Pour avoir une image de l’infrastructure cible, voici un schéma récapitulatif.

Virtual Azure WAN

Commençons par créer le Azure Virtual WAN.

az group create --location eastus  --name demo-rg-vwan


# Virtual WAN
az extension add --name virtual-wan

az network vwan create --name demo-virtual-wan --resource-group demo-rg-vwan --branch-to-branch-traffic true --location eastus --type Standard  --vnet-to-vnet-traffic true

Azure Virtual HUB

Créez les Azure Virtual HUB.

# the west-us hub region
az network vhub create --address-prefix 10.100.0.0/16  --name demo-hub-westus  --resource-group demo-rg-vwan  --vwan demo-virtual-wan  --location westus  --sku  Standard

# the east-us hub region
az network vhub create --address-prefix 10.200.0.0/16  --name demo-hub-eastus  --resource-group demo-rg-vwan --vwan demo-virtual-wan  --location eastus  --sku  Standard

# the west-europe hub region
az network vhub create --address-prefix 10.255.0.0/16  --name demo-hub-westeurope  --resource-group demo-rg-vwan  -vwan demo-virtual-wan  --location westeurope --sku  Standard

Créez une Firewall-Policies et sécurisez les hub

Créez les Firewall-Policies.

# vSecure HUB policy

az extension add --name azure-firewall

az network firewall policy create --name fw-policy-root  --resource-group demo-rg-vwan   --location eastus    --threat-intel-mode Alert

az network firewall policy create --name fw-policy-westeurope   --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert  --base-policy fw-policy-root
                                                                              

az network firewall policy create --name fw-policy-westus  --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert --base-policy fw-policy-root
                                                                               

az network firewall policy create --name fw-policy-eastus  --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert --base-policy fw-policy-root

Connectez les Vnets/Branch

# VPN Gateway site-to-site (onpremise branch of east-us region)

az network vpn-gateway create --name demo-vpn-gateway   --resource-group demo-rg-vwan  --vhub demo-hub-eastus  --location eastus

az network vpn-site create --ip-address 137.117.35.59  --name demo-vpn-site  --virtual-wan demo-virtual-wan  --resource-group demo-rg-vwan --address-prefixes 10.5.0.0/16  --device-model firewall --device-vendor paloalto  --link-speed 20  --location eastus
                           
az network vpn-gateway connection create --gateway-name demo-vpn-gateway --name demo-vpn-gateway-connection --remote-vpn-site demo-vpn-site --resource-group demo-rg-vwan --connection-bandwidth 50 --protocol-type IKEv2 --shared-key ######################

# Virtual Hub to VNET connection (VNET Branch west us gerios)

az network vhub connection create --name  vnet-westus-prod-to-hub --remote-vnet "remote-vnet-id" --resource-group demo-rg-vwan --vhub-name  demo-hub-westus --internet-security true 

# Virtual Hub to VNET connection (VNET Branch west europe gerios)

az network vhub connection create --name  vnet-westeurope-prod-to-hub --remote-vnet "remote-vnet-id" --resource-group demo-rg-vwan  --vhub-name  demo-hub-westeurope --internet-security true --remote-vnet-transit   true --use-hub-vnet-gateways true

n’oubliez pas de configurer le tunnel IPSEC sur votre Appliance onpremise.

Creez vos Rules/Collections

# Policies

az network firewall policy rule-collection-group create --name rule-collection-westeurope --policy-name fw-policy-westeurope --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-nat-collection --collection-priority 100 --name nat-collection --policy-name fw-policy-westeurope --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westeurope --action DNAT --destination-addresses 51.124.93.205 --destination-ports 22 --ip-protocols TCP --rule-name nat-ssh --source-addresses *  --translated-address 10.0.1.4  --translated-port 22 

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-westeurope --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westeurope --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/16 --destination-addresses 10.0.0.0/16



az network firewall policy rule-collection-group create --name rule-collection-westus --policy-name fw-policy-westus --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-nat-collection --collection-priority 100 --name nat-collection --policy-name fw-policy-westus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westus --action DNAT --destination-addresses 13.83.64.91  --destination-ports 22 --ip-protocols TCP --rule-name nat-ssh --source-addresses *  --translated-address 10.0.0.4  --translated-port 22 

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-westus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westus --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/16 --destination-addresses 10.0.0.0/16
                                                                                                                        

az network firewall policy rule-collection-group create --name rule-collection-eastus --policy-name fw-policy-eastus --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-eastus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-eastus --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/8 --destination-addresses 10.0.0.0/8
 

Et enfin acheminer le trafic vers votre hub

Vous devez maintenant vous assurer que le trafic réseau est acheminé via votre vSecure Hub. Cette étape n’étant toujours pas disponible en Cli/Powershell/Terraform, on le fera directement sur le portail.

  1. depuis l’interface Firewall Manager, select Secured virtual hubs.
  2. Select the Hub.
  3. Under Settings, select Route settings.
  4. Under Internet trafficTraffic from Virtual Networks, select Send via Azure Firewall.
  5. Under Azure private trafficTraffic to Virtual Networks, select Send via Azure Firewall.
  6. Select Edit IP address prefix(es).
  7. Select Add an IP address prefix.
  8. Under Settings, select Connections.
  9. Select the spoke (VNETs/VPN site-site) connection, and then select Secure internet traffic and then select OK.

Conclusion

Je n’ai pas encore effectué de tests plus poussés, mais jusqu’à présent, je suis très satisfait de ce nouveau service. Une fois qu’il aura atteint la disponibilité générale, il pourrait rejoindre facilement notre Azure Virtual WAN pour former « Le » meilleure package d’outils pour le déploiement de réseaux de types Hub & Spoke natif Azure, et je vous laisse imaginez à quel point cette manière de faire facilitera la manipulation des pipelines CI / CD par rapport à notre façon de faire actuelle. 

Comment automatiser le déploiement des ressources Azure avec Terraform à l'aide des Pipelines Azure DevOps.

TERRAFORM

Terraform est un outil open-source développé par HashiCorp, et utilisé pour provisionner et gérer des infrastructures IT dans le Cloud. Écrit en Go et fonctionnant en mode Infrastructure as a Code (IAC), il permet d’administrer une infrastructure grâce à du code au lieu de procéder à un ensemble d’opérations manuelles.

La force de Terraform est de reposer sur un langage de description d’infrastructure simple et lisible, on parle ici de HCL. L’approche IAC de Terraform permet de gérer le versioning d’une infrastructure en lui ajoutant ou retirant des composants.

Objectif

Dans cet article, nous allons voir :

  1. Comment définir une stack Terraform simple
  2. Comment utiliser conjointement Terraform et Azure DevOps dans l’optique de déployer l’infrastructure Azure, de manière automatique et continue.

Initialisation du projet

Voici la structure de fichier que nous allons adopter :

|– src\
|– terraform\
|– README.md

|– src\ will contain the sources of the Ansible Config,
|– terraform\ will contain all the deployment files.

1- Azure service principal

Rendons-nous dans Azure Active Directory et allons dans la partie App registrations.

  • Connectez-vous à votre compte Azure sur https://portal.azure.com
  • Cliquez sur le bouton Cloud Shell pour lancer le Cloud Shell.
  • La commande ci-dessous créera un principal de service avec le nom « SPName ». Remplacez la valeur et exécutez la commande dans le cloud shell.
az ad sp create-for-rbac --name SPName
  • À l’issu de cette commande, Azure CLI retournera un block JSON contenant les informations nécessaires a l’authentification du SP (client-id, client-secret)
abd###@Azure:~$ az ad sp create-for-rbac --name SPName
Changing "SPName" to a valid URI of "http://SPName", which is the required format used for service principal names
Creating a role assignment under the scope of "/subscriptions/##########-c1b3-####-8b7a-####9578ebf0"
  Retrying role assignment creation: 1/36
  Retrying role assignment creation: 2/36
  Retrying role assignment creation: 3/36
{
  "appId": "########-4611-4c09-9728-6ec9284314de",
  "displayName": "SPName",
  "name": "http://SPName",
  "password": "########",
  "tenant": "########-d76d-45cf-a7d2-ae98f73067ee"
}
  • Complétez le formulaire. Cliquez sur Vérifier la connexion pour vous assurer que les valeurs fonctionnent comme prévu. Cliquez sur OK une fois vérifié. Vous pourrez désormais référencer cette connexion à partir des tasks du pipeline.

2- TERRAFORM / INFRASTRUCTURE

|– src\
|– terraform\
____|– main.tf
____|– outputs.tf
____|– provider.tf
____|– variables.tf
____|– variables.tfvars
|– README.md

MAIN.tf file

data "azurerm_client_config" "current" {
}

locals {
  resource_group_name = "rg-${var.env}"

  tags = {
    env = "${var.env}"
  }
}

# ======================================================================================
# Resource Group
# ======================================================================================

resource "azurerm_resource_group" "resource_group" {
  location = "${var.location}"
  name     = "${var.env}-rg"
  tags     = "${local.tags}"
}

# ======================================================================================
# KeyVault
# ======================================================================================

resource "azurerm_key_vault" "key_vault" {
  name                        = "${var.env}-keyvault"
  location                    = "${azurerm_resource_group.app_resource_group.location}"
  resource_group_name         = "${azurerm_resource_group.app_resource_group.name}"
  tenant_id                   = "${data.azurerm_client_config.current.tenant_id}"
  enabled_for_disk_encryption = true

  sku {
    name = "standard"
  }

  access_policy {
    tenant_id = "${data.azurerm_client_config.current.tenant_id}"
    object_id = "${data.azurerm_client_config.current.object_id}"

    secret_permissions = [
      "get",
      "list",
      "set",
      "delete"
    ]
  }

  tags = "${local.tags}"
}

# ======================================================================================
# Network
# ======================================================================================

resource "azurerm_virtual_network" "vnet" {
  name                = "${var.vnet-name}"
  address_space       = "${var.address_space}"
  dns_servers         = [
           "192.168.0.1",
           "168.168.25.1",
        ]
  location            = "${azurerm_resource_group.resource_group.location}"
  resource_group_name = "${azurerm_resource_group.resource_group.name}"

  tags     = "${local.tags}"
}

resource "azurerm_subnet" "subnet" {
  name                 = "${var.subnet-name}"
  resource_group_name  = "${azurerm_resource_group.resource_group.name}"
  virtual_network_name = "${azurerm_virtual_network.vnet.name}"
  address_prefix       = "${var.address_prefix}"
  tags     = "${local.tags}"
}

resource "azurerm_network_interface" "vm-network-interface" {
  name                = "${var.vm-name}"
  location            = "${azurerm_resource_group.resource_group.location}"
  resource_group_name = "${azurerm_resource_group.resource_group.name}"
  
  ip_configuration {
    name                          = "vm-ipconfig"
    subnet_id                     = "${azurerm_subnet.subnet.id}"
    private_ip_address_allocation = "Dynamic"
  }
}
# ======================================================================================
# VM
# ======================================================================================

resource "azurerm_virtual_machine" "virtual-machine" {
  name                  = "${var.vm-name}"
  location              = "${azurerm_resource_group.resource_group.location}"
  resource_group_name   = "${azurerm_resource_group.resource_group.name}"
  network_interface_ids = ["${azurerm_network_interface.vm-network-interface.id}"]

  vm_size               = "DS3V2"

  storage_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2016-Datacenter"
    version   = "latest"
  }
  storage_os_disk {
    name              = "vm-os-disk"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
    
  }

  os_profile {
    computer_name  = "${var.computer-name}"
    admin_username = "${var.AdminUsername}"
    admin_password = "${var.AdminPassword}"
  }

}

PROVIDER.TF file

provider "azurerm" {
  version = "1.44.0"
}

terraform {
  required_version = "0.11.21"
  backend "azurerm" {
    storage_account_name = "shared$$_application_$$tfsa"
    container_name       = "terraform"
    key                  = "terraform-$$_environment_$$.tfstate"
    access_key           = "$$_tf_storage_account_key_$$"
  }
}

VARIABLES.TF file

data "azurerm_client_config" "current" {
}

provider "azurerm" {
    version = "=1.44.0"
    subscription_id  = "${data.azurerm_client_config.current.subscription_id}"               
    client_id        = "${data.azurerm_client_config.current.client_id}"                  
    tenant_id        = "${data.azurerm_client_config.current.tenant_id}"
    client_secret    = "$$_client_secret_$$"                 
    }

variable "env" {
  type = "string"
}
variable "location" {
  type = "string"
}
variable "address_space" {
  type = "string"
}
variable "subnet-name" {
  type = "string"
}
variable "address_prefix" {
  type = "string"
}

VARIABLES.TFVARS file

env = "$$_env_$$"
location = "$$_location_$$"
address_space = "$$_0.0.0.0/0_$$"
subnet-name = "$$_subnet-name_$$"
address_prefix = "$$_0.0.0.0/24_$$"

3- PIPELINE

Prérequis

Un compte GitHub, où vous pouvez gérer vos repository. Si vous n’en avez pas, vous pouvez créer un gratuitement.

Une organisation Azure DevOps. Si vous n’en avez pas, vous pouvez en créer une gratuitement. (Une organisation Azure DevOps est différente de votre organisation GitHub. Par best-practices, donnez-leur le même nom)

Commençons par créer notre premier pipeline !

1- Azure DevOps – BUILD

Créons un nouveau Build Pipeline, puis cliquer sur Use the visual designer pour avoir le mode visuel.

Pour ce lab, nous utiliserons la branche master.

commencer par un Empty job

Ensuite, ajoutez Publish Artifact. Cette étape est utilisée pour incorporer les fichiers Terraform dans l’artifact.

Ensuite, spécifiez le dossier ou le chemin du fichier à publier. Il peut s’agir d’un full path ou d’un chemin relatif à la racine du repository.

Enfin, procédons au lancement de notre première build. Si tout se passe bien, nous obtenons l’artifact suivant :

2- Azure DevOps – RELEASE

Créons maintenant un nouveau Release Pipeline, pour ce faire, nous allons commencer à partir d’un modèle de travail vide Empty job template.

Renommons la première étape DEV.

Pour utiliser Terraform, nous avons besoin de :

  1. créer son backend sur Azure Storage (Blob),
  2. récupérer la Key de ce Storage et de l’injecter dans les variables pour pouvoir écrire/lire dans le Blob.

Première étape, ajoutons une étape de type Azure CLI pour la création du backend :

az group create --location $(location) --name "rg-$(env)-tfstate" 

az storage account create --name "sa$(env)tfstate$(location)" --resource-group "rg-$(env)-tfstate" --location $(location) --sku Standard_LRS  --tags 

az storage container create --name "terraform" --account-name "sa$(env)tfstate$(location)"

Next, add a second job Azure Powershell to get the storage account access_key

$key = (Get-AzStorageAccountKey -ResourceGroup "rg-$(env)-tfstate" -Name "sa$(env)tfstate$(location)").Value[0]

Write-Host "##vso[task.setvariable variable=tf_storage_account_key]$key"

The following two steps allow you to replace the tokens ($$_value_$$) present in the Terraform files.

Ensuite, ajoutons les tasks terraform:

  • install terrafrom ()
  • init
  • validate
  • plan
  • apply

Add Pipiline variables

Link a KeyVault to your DevOps pipeline project

prochains articles :

  1. Configurer une ressource (AD serveur) a l’aide d’Ansible-DevOps en one shot
  2. Configurer une ressource (AD serveur) a l’aide du DSC-DevOps en one shot

L&L Kubernetes et AKS

Retrouvez notre Expert Christophe, dans une vidéo sur Kubernetes et AKS. La vidéo est Level 100, accessible à tous. URL sur Youtube: ici

Contenu: Il s’agit de prendre un projet Web API sous Visual Studio 2019 avec support Docker (container Linux) et de construire l’image Docker en local. Ensuite on pousse cette image dans une registry ACR afin de faire un déploiement dans un cluster AKS. Ensuite, on aborde kubectl, l’outil console de Kubernetes.

Pour réaliser toutes les opérations techniques, un HOWTO est à télécharger sur https://infeeny.com/net-core-sous-aks/

Infeeny est dans le magazine Programmez de Mars 2020

Retrouvez nos experts Infeeny dans le numéro 238 du magazine Programmez de Mars 2020.

On y trouve un article sur le monde du développement selon Microsoft avec un focus sur NET 5, la plateforme unifiée qui va sortir en Novembre 2020. C’est la fusion entre NET Framework 4.8 et NET Core 3.1.

Les experts Infeeny qui ont participé à cet article sont Timothé LARIVIERE et Christophe PICHAUD.