Die vergangene Folge hat das Entwurfsmuster CQRS vorgestellt, das die Trennung von Schreib- und Leseseite einer Anwendung beschreibt. Das verbessert nicht nur die Struktur, sondern führt auch zu einer unkomplizierten Skalierbarkeit. Der Preis dafür ist die erforderliche Synchronisation – einschließlich ihrer Nebenwirkungen.
Kürzlich haben wir für unsere Trainer in der co-IT.eu nach Workshops gesucht, um diesen neue Werkzeuge zur Optimierung ihrer Seminare an die Hand zu geben. Die ein oder andere Stellschraube lässt sich bekanntlich immer noch drehen, um das Wissen noch effizienter zu vermitteln. Dabei stellt Fachliche nicht die Herausforderung,vielmehr ist es eine Kunst komplexes Wissen möglichst einfach zu vermitteln, sodass der Teilnehmer das Neue im Alltag auch reproduzieren kann.
Daher waren wir v.a. an Erkenntnissen aus Lernpsychologie und der Pädagogik interessiert. Wie funktioniert das Gedächtnis, wie erzeuge ich Bilder oder erzähle ich meinen Themenstoff als Story (Storytelling). Darüber hinaus warum uns Themen wie Auftreten, Charisma, Schlagfertigkeit oder aber Kritikfähigkeit wichtig, da diese den fruchtbaren Boden für Wissensvermittlung darstellen.
In einer Workshopprofil Präsentationstechniken haben wir brainstormartig alles notiert, was wir in irgendeiner Form gerne in dem Workshop sehen und hören wollten. Zu dem Zeitpunkt war bereits klar: Wir werden jährlich ein solches Training absolvieren. Demzufolge war nicht das Ziel möglichst viel in kurzer Zeit abzudecken, sondern dedizierte zusammenhängende Themen in einer notwendigen Tiefe. Mit der Wunschliste und der Bitte um eine Konzeptausarbeitung schrieb ich dann mehrere Unternehmen an. Natürlich nicht ohne über Facebook und Twitter nach Empfehlungen zu fragen. Danke Daniel an dieser Stelle für deine Rückmeldung.
Folgende Unternehmen haben wir kontaktiert:
Mit jedem der Unternehmen habe ich telefoniert, um die Konstellation und den Rahmen sauber abzustecken. Nachdem aufgrund terminlicher Konflikte zwei Anbieter weggefallen waren, haben wir demokratisch in der Gruppe der Teilnehmer die persönlichen Rankings erfasst. Weil ohnehin alle die Rhetorikhelden auf Platz 1 gelistet hatten, war die Sache schnell geklärt.
Der Beitrag soll dem Leser ein paar Anlaufstellen vermitteln und mit der oben verlinkten Wunschliste einen schnelleren Einstieg ermöglichen.
Einsortiert unter:CIO Topics, Events, German Tagged: Beratung, Firmenkontakt, Retrospektive 
Microsoft HoloLens ist ein faszinierendes Gerät. Diese Faszination konnten wir sowohl in den unzähligen Demonstrationen als auch in unseren Kundenprojekten vielfach erfahren. Leuchtende Augen und kindliche Begeisterung sind häufig das Ergebnis der Nutzung von Microsoft HoloLens. Aber wo Licht ist, da ist auch Schatten.
Eine dieser Schattenseiten ist der Schließmechanismus des Kopfbandes, mit dem die HoloLens auf dem Kopf befestigt wird. Bereits nach kurzem Einsatz war uns klar, dass dieser nicht für die Ewigkeit konstruiert ist. Nach ca. einem Jahr im Einsatz bemerkten wir, dass der Schließmechanismus immer öfter festhängt. Durch das regelmäßige Aufsetzten und Absetzten beim Entwickeln von HoloLens Anwendungen oder beim Vorstellen der HoloLens auf Messen und Konferenzen ist das Plastik ermüdet und schließlich gebrochen. Daraufhin war das Rädchen, welches die Größe des Kopfbandes reguliert ohne Funktion.
Da die HoloLens eine Entwicklerversion ist, bietet Microsoft keine Reparatur oder Erstattung an. Unsere Lösung gewinnt zwar keinen Designpreis, ist dafür aber preiswert und einfach umzusetzen. Dabei wird der Schließmechanismus der HoloLens durch ein Ersatzteil eines Fahrradhelms ersetzt.
Benötigt werden:
- Fahrradhelm Ersatzteil, welches den Schließmechanismus der HoloLens ersetzt. Wir haben einen alten Fahrradhelm recycelt. Die Ersatzteile gibt es aber auch einzeln zu kaufen, zum Beispiel hier.
- Seitenschneider oder eine stabile Schere zum Kappen der Bänder.
- Nietenzange und Nieten zum Verbinden des HoloLens Kopfbandes mit dem neuen Schließmechanismus.
Nachteilig an diesem Ansatz ist die geringere Spanne des neuen Kopfbandes. Das Ersatzteil sollte deshalb so montiert werden, dass es komplett ausgefahren gerade so über den Kopf passt. So hat man noch genug Spiel die HoloLens festzuziehen.
Wer Software unter einer Open-Source-Lizenz veröffentlicht, erhält gelegentlich Beiträge von der Community. Was zunächst nach einem Gewinn für beide Seiten klingt, kann später unter Umständen zu rechtlichen Problemen führen. Wie lässt sich das vermeiden?
Im letzten Beitrag habe ich die Grundlagen von ARM Templates und dem Azure Resource Manager behandelt. Im nun folgenden Artikel möchte ich auf einige weitere Möglichkeiten eingehen, wie man in einem ARM Template größere Infrastrukturen inklusive Abhängigkeiten deployen kann.
Die Beispiel-Infrastruktur, die hier aufgebaut werden soll, besteht aus den folgenden Komponenten:
Alles in allem eine typische Landschaft für das Backend einer modernen Web-/Mobile Application. Was in diesem Beispiel nicht behandelt wird, ist der Bereich Continuous Integration / Deployment für die API bzw. die Datenbank. Das Augenmerk liegt vollkommen auf der Infrastruktur und der entsprechenden „Verdrahtung“ der Komponenten. Zur Veranschaulichung der Abhängigkeiten, hier ein Schaubild:
Ich werde nicht auf alle Einzelheiten des Templates eingehen, jedoch auf die wichtigen Stellen verweisen, die z.B. die WebApp mit Azure Search verbinden, Content Delivery Network anlegen, den Staging-Slot kreieren usw.
Kommen wir zu den einzelnen Komponenten…
Die WebAPI
Die Erstellung der WebAPI weicht marginal vom Standard Template, welches man über Visual Studio erzeugen kann, ab. Da in der WebApp ausschließlich eine API laufen und .NET Code ausgeführt werden soll, sind einige Einstellungen darauf angepasst. Unter anderem sind PHP (Line 65) und ARR (Line 18) deaktiviert, das AlwaysOn-Feature enabled (Line 64), die 64bit-Umgebung aktiviert (Line 63), die Default Page entfernt (Line 66). Zusätzlich sind alle Connection Strings (ab Line 20) und Properties, die zur Laufzeit für die Kommunikation mit anderen Services im Template notwendig sind (ab Line 38), eingetragen.
Deployment Slot / Staging
Ein Deployment Slot stellt einen zusätzlichen Endpunkt / eine zusätzliche WebApp innerhalb des App Service Plans bereit, in den die eigentliche App deployt werden kann. Deployment Slots sind ein beliebtes Feature, um eine neue Version einer Applikation mit nahezu „zero-downtime“ auszurollen. Man deployt die neue Version in einen Slot, testet die Funktionalität, erzeugt Last um die App „aufzuwärmen“ und tauscht dann den Production Slot mit dem Staging Slot („Swapping“ – entspricht einem IP-Switch am enthaltenen Loadbalancer) aus. Dies kann entweder über das Portal, Powershell oder z.B. Visual Studio Team Services durchgeführt werden.
Das Template für den hier zu erstellenden „Staging Slot“ sieht folgendermaßen aus:
Storage Account und Content Delivery Network
Nahezu jede Web-Applikation / API muss mit Dateien und dem zugehörigen „Ausliefern“ umgehen können. Für die Ablage von Dateien wird ein Storage Account (Blob Storage) erzeugt. Im Anschluss daran wird ein Content Delivery Network erstellt, welches als Quelle den entsprechenden Storage Account hat. Wichtig ist hierbei, dass der Container, der für die Ablage der Dateien im Storage Account zuständig ist, mindestens mit der Berechtigung „Blobs (anonymous read access for blobs only)“ angelegt wird. Leider kann man Container momentan nicht per ARM Template anlegen (siehe hierzu: Let me define preconfigured Blob Containers, Tables, Queue in ARM template).
Wichtig in diesem Abschnitt des Tempaltes ist schlussendlich die „Verknüpfung“ des CDN mit dem Storage Account (ab Line 31).
Azure Redis Cache und Azure Search
Um Usern die bestmögliche Performance einer Applikation zur Verfügung zu stellen, werden häufig Caches (allgemeine Anforderungen/Caching) bzw. Such-Engines (speziell für die Suche im jeweiligen Datenbestand) verwendet. Azure hat auch hier mit dem Azure Redis Cache und Azure Search entsprechende Angebote im Service Portfolio. Die Erstellung der Services ist relativ simple, wie man im folgenden Template Abschnitt sehen kann.
Das Interessante an den beiden erstellten Ressourcen ist das Auslesen der entsprechenden Admin Keys, damit die Web App Zugriff auf den jeweiligen Dienst bekommt. Analog dem Connection String des SQL Servers müssen Connections Strings / Properties erstellt werden, mit denen die Verbindung aus der Web App aufgebaut werden kann. Die Zugriffe auf die Keys von Redis Cache und Azure Search befinden sich in der Web App Ressource (Line 33 und 49), zur Vollständigkeit hier noch einmal:
Die beiden Funktionen listKeys und listAdminKeys sind sogenannte Resource Functions, die vom zugrundeliegenden Resource Provider zur Verfügung gestellt werden. Theoretisch kann jeder Resource Provider derartige Functionen bereitstellen. Um zu erfahren, welche Funktionen ein Provider besitzt, gibt es die Möglichkeit per Powershell (oder CLI, REST Api) am gewünschten Provider „anzufragen“. Für Azure Storage, Redis bzw. Azure Search würden die Aufrufe folgendermaßen aussehen:
Get-AzureRmProviderOperation -OperationSearchString "Microsoft.Storage/*" | where {$_.Operation -like "*list*"} | FT Operation
Get-AzureRmProviderOperation -OperationSearchString "Microsoft.Cache/*" | where {$_.Operation -like "*list*"} | FT Operation
Get-AzureRmProviderOperation -OperationSearchString "Microsoft.Search/*" | where {$_.Operation -like "*list*"} | FT Operation
Die offizielle Dokumentation zu den Template Funktionen, im speziellen zu den Resource Functions, findet man unter Resource functions for Azure Resource Manager templates.
Sonstige Ressourcen
Im hier verwendeten Template befinden sich weitere Ressourcen, wie Application Insights, Scale Settings und Alerts für die Web Applikation, SQL DB usw., die jedoch „straight forward“ angelegt werden und für welche keine großen Erklärungen notwendig sind.
Schlussendlich werden Einstellungen / Informationen, wie der Instrumentation Key von AppInsights oder der Connection String der Datenbank in der verwendenden Ressource (überwiegend die WebApp) automatisch eingetragen.
Deployment
Um das Template zu deployen, stehen verschiedene Möglichkeiten zur Verfügung, welche ich bereits im vorherigen Artikel kurz beleuchtet habe. Deshalb stelle ich hier lediglich das Powershell-Skript zur Verfügung:
# Login to Azure
Login-AzureRmAccount
# Resource Group
$rg = "myappinfra-rg"
New-AzureRmResourceGroup -Name $rg -Location westeurope
# Deploy via Resource Group Deployment
New-AzureRmResourceGroupDeployment -ResourceGroupName $rg -Mode Complete -TemplateFile ".\azuredeploy.json" -TemplateParameterFile ".\azuredeploy.parameters.json"
Abschluss
Das Template inkl. Parameter File und Deployment Skript stehen auf GitHub zur Verfügung. Viel Spaß damit 
Wer das am 14. August 2017 erschienene .NET Core 2.0 nutzen will, braucht Visual Studio 2017 Update 3 (interne Versionsnummer: 15.3) und zusätzlich das .NET Core 2.0 SDK.
Das Verarbeiten von Kommandos und Erzeugen der fachlichen Ereignisse ist seit der vergangenen Folge in semantisch sinnvollem Code abgebildet. Auf dem Weg lassen sich die Konsistenz und Integrität effizient sicherstellen, auch das Speichern der Ereignisse passt dank Event Sourcing konzeptionell dazu. Wie steht es um das Lesen der Daten?
In dem Post IEC 61131-3: Weitere Spracherweiterungen bin ich kurz auf die UNION eingegangen. Ein Leserkommentar hat mich auf die Möglichkeit hingewiesen, dass auch eine UNION per EXTENDS erweitert werden kann. Da dieses die Handhabung einer UNION vereinfacht und die Norm auch nicht darauf hinweist, will ich diese Möglichkeit in einem (sehr) kurzen Post vorstellen.
Wie schon zuvor in einem Post beschrieben, ist es mit einer UNION möglich, eigene Datentypen zu definieren, deren Elemente alle denselben Speicherplatz belegen.
TYPE U_Test :
UNION
nVar1 : WORD;
nVar2 : BYTE;
END_UNION
END_TYPE
Hier nochmal das Beispiel, bei dem auf eine 16-Bit Variable auch jeweils einzeln auf das Low-Byte und auf das High-Byte zugegriffen werden kann. Dazu wird zuerst eine Struktur angelegt, die aus zwei Bytes besteht.
TYPE ST_Bytes :
STRUCT
nLSB : BYTE;
nMSB : BYTE;
END_STRUCT
END_TYPE
Dieses Beispiel zeigt, wie ohne Bit-Operationen aus einer Variablen vom Typ WORD das niedrigere Byte (LSB) und das höherwertige Byte (MSB) ermittelt werden.
PROGRAM MAIN
VAR
uVar : U_Test;
nA, nB : BYTE;
END_VAR
uVar.nVar1 := 16#1234;
nA := uVar.stVar2.nLSB; // Wert: 16#34 (LSB)
nB := uVar.stVar2.nMSB; // Wert: 16#12 (MSB)
EXTENDS bei UNION
Etwas eleganter kann die gleiche Aufgabe auch mit Vererbung gelöst werden. Hierbei erbt der Verbund U_Test von ST_Bytes.
TYPE U_Test EXTENDS ST_Bytes :
UNION
nVar1 : WORD;
// stVar2 : ST_Bytes; // kann entfallen, wird von ST_Bytes geerbt.
END_UNION
END_TYPE
Der Zugriff auf nLSB und nMSB muss jetzt nicht mehr über eine explizit deklarierte Variable in der UNION erfolgen.
uVar.nVar1 := 16#1234;
nA := uVar.nLSB; // Wert: 16#34 (LSB)
nB := uVar.nMSB; // Wert: 16#12 (MSB)
Today, I've released a new version of the angular library angular-oauth2-oidc, which allows for implementing token-based Security using OAuth2/ OpenId Connect and JWTs with Angular.
This new major version comes with some breaking changes. You find a list at the beginning of the updated readme. I think they won't affect everyone and even when you are affected you should be able to deal with them quite quickly.
Silent Token Refresh
Silent Refresh was the most requested feature for this library. It is a standard compliant way to refresh your tokens when/ before they expire using implicit flow.
If the application is prepared for it, performing a silent refresh is as easy as this:
this
.oauthService
.silentRefresh()
.then(info => console.debug('refresh ok', info))
.catch(err => console.error('refresh error', err));
By leveraging the new events observable, an application can automatically perform such a refresh when/ sometime before the current tokens expire:
this
.oauthService
.events
.filter(e => e.type == 'token_expires')
.subscribe(e => {
this.oauthService.silentRefresh();
});
More information about this can be found within the updated readme.
Validating the signature of id_tokens
The library can now directly validate the signature of received id_tokens. For this, just assign a ValidationHandler:
import { JwksValidationHandler } from 'angular-oauth2-oidc';
[...]
this.oauthService.tokenValidationHandler = new JwksValidationHandler();
The JwksValidationHandler shown here uses the JavaScript library jsrasign to validate the signature directly in the browser without the need to call the server.
You can also hook in an own ValidationHandler by implementing an interface.
More Security Checks
Some additional security checks have been added. The library insists on using https now and only makes an exception for localhost. It also validates the received discovery document.
Feedback
If you are using it or if you are trying it out, don't hesitate to send me some feedback -- either directly via my blog or via GitHub.
Bindings gegen Mengen
In zahlreichen Anwendungen besteht die Anforderung, andere Anwendungen als Child-Prozesse zu starten. Zu dem Zweck enthält Node.js das Modul child_process. Allerdings ist Vorsicht geboten, denn das Modul führt rasch zu plattformabhängigem Code. Wie lässt sich das Problem anders lösen?
Auch im Sommer sind Roman und Patrick aktiv und haben für Euch die folgenden Infos gesammelt. Was also war im Juli los in der PowerShell Community in Österreich ?
Kommende Events:
Vergangene Events:
Blogeinträge:
Newsletter - die “Schnipseljagd”
Die wöchentlichen Newsletter beinhalteten die folgende Themen:
Powershell Schnipseljagd Woche 27
Netzwerkkarten Hardwarehersteller auslesen anhand der MAC Adresse
E-Mails mit G-Mail SMTP settings und Powershell versenden
Fehlende Patches auf Remote-Servern finden
Ein PS-Script zu einer DSC Konfiguration konvertieren
Mit PowerShell ein Zertifikat anfordern
Powershell Schnipseljagd Woche 28
Den Helpdesk mit PowerShell verbessern
Mit PowerShell den Ärger mit WSUS verringern
Vererbung in DSC Ressourcen verwenden
PowerShell mit VMWare vCenter
DBA Tools mit VSCode
PowerShell Einsteigerbuch
Sichere Passwörter in PowerShell
Powershell Schnipseljagd Woche 29
Get-Location, [Environment] und [System.IO.Path], was man darüber wissen sollte
Mit lokalen Accounts arbeiten
Software mit PowerShell installieren und verteilen
Wie lange ist es bis Weihnachten
Speicherplatz freimachen indem man temporäre Dateien löscht.
Passwörter auf der Befehlszeile erzeugen.
Powershell Schnipseljagd 30
Security - Einige Security Überlegungen zum Thema PowerShell.
Bösartige Makros generieren mit LuckyStrike:
PowerShell Community. Die gibt es auch in Deutschland. Hier ein aktueller Überblick.
File / Folder Owner
Daten verschlüsselt speichern & lesen
Graph Explorer (nur wenig PowerShell)
Visual Studio Code – weil man sich das ansehen sollte
PowerShell Schnipseljagd 31
Wie werde ich zum Powershell Profi.
Übersicht von interessanten Modulen für PowerShell Profis
PowerShell Module PlatyPS - Ein Module zum Erzeugen von Hilfeseiten in Markdown für PowerShell.
Forschung: Automatisierte Fehlersuche Wie weit ist die Forschung bei der automatisierten Fehlersuche?
ARM Templates - Hier gibt es ein paar Serverless ARM Templates.
Style Sheets and PowerShell Reports - Verwendung von Style Sheets in PowerShell Reports
PowerShell Style Guide
PowerShell Security - Using PowerShell without PowerShell.exe
Die PowerShell UserGroup Austria
www.powershell.co.at
Die Domäne ist modelliert, gespeichert werden Events. Wie lässt sich das Ganze nun von der Theorie in die Praxis überführen? Wie könnte Code aussehen, der die fachliche Modellierung widerspiegelt? Ein Entwurf.
Parameterlisten sind eine interessante Variante, Parameter an SPS-Bibliotheken zu übergeben. Genaugenommen handelt es sich um globale Konstanten (VAR_GLOBAL CONSTANT), deren Initialisierungswerte im Library Manager editierbar sind.
Bei der Deklaration von Arrays müssen dessen Grenzen Konstanten sein. Zum Zeitpunkt der Compilierung muss bekannt sein, wie groß das Array anzulegen ist. Der Versuch die Arraygrenzen durch eine Variable zu definieren, wird mit einer entsprechenden Fehlermeldung abgelehnt.
PROGRAM MAIN
VAR
nUpperBound : INT := 5;
aTest : ARRAY [1..nUpperBound] OF INT;
END_VAR
// Compiler error: Border 'nUpperBound' of array is no constant value
Erst die Verwendung von Konstanten löst das Problem.
PROGRAM MAIN
VAR
aTest : ARRAY [1..nUpperBound] OF INT;
END_VAR
VAR CONSTANT
nUpperBound : INT := 5;
END_VAR
Gerade in SPS-Bibliotheken kann dieses zu Problemen führen. Soll durch ein Array z.B. ein Datenpuffer abgebildet werden, so ist nicht unbedingt zum Zeitpunkt der Bibliotheksentwicklung bekannt, wie groß dieser Datenpuffer in den jeweiligen Anwendungen zu sein hat.
Abhilfe schafft hier eine Parameterliste, die bei der Erstellung einer SPS-Bibliothek eingefügt wird.
Eine Parameterliste kann an beliebiger Stelle des SPS-Projektes (das SPS-Projekt, aus der die SPS-Bibliothek entsteht) hinzugefügt werden. Üblicherweise werden Parameterlisten bei den globalen Variablenlisten (GVLs) angelegt.
Deklariert werden die Parameter wie konstante, globale Variablen.
{attribute 'qualified_only'}
VAR_GLOBAL CONSTANT
cUpperBound : INT := 3;
cString : STRING := 'Hello';
cIntArray : ARRAY [1..cUpperBound] OF INT := [1, 2, 3];
cStructArray : ARRAY [1..3] OF ST_Test := [3( (nValue := 1,
fValue := 3.1,
wsValue := "abc") )];
cEnum : E_Test := E_Test.eValue02;
cStruct : ST_Test := (nValue := 1, fValue := 3.1, wsValue := "abc");
END_VAR
Durch Initialisierungswerte können die Variablen vorinitialisiert werden. Auch komplexere Variablenstrukturen können so mit Werten initialisiert werden.
In der Anwendung, in der die Bibliothek eingebunden wurde, können diese Parameter im Library Manager editiert werden. Der Library Manager wird durch einen Doppelklick auf der jeweiligen Bibliotheks-Referenz geöffnet.
Die Felder in der Spalte Value (editable) können jetzt beliebig verändert werden. Die so veränderbaren Konstanten können innerhalb der jeweiligen SPS-Bibliothek oder auch in der Anwendung, die diese referenziert, verwendet werden.
FUNCTION F_AddArrayValues : INT
VAR_INPUT
aTest : REFERENCE TO ARRAY[1..Param.cUpperBound] OF INT;
END_VAR
VAR
nIndex : INT;
END_VAR
FOR nIndex := 1 TO Param.cUpperBound DO
F_AddArrayValues := F_AddArrayValues + aTest[nIndex];
END_FOR
Abgespeichert werden die geänderten Initialisierungswerte in der jeweiligen SPS-Projektdatei (*.plcproj). Jede Anwendung, die eine Bibliothek mit einer Parameterliste referenziert, besitzt somit seine eigenen Werte. Die Bibliothek an sich bleibt unverändert.
Die so eingestellten Werte überleben auch einen SPS-Reset, sowohl einen Kaltreset, als auch das Zurücksetzen auf die Ursprungswerte. Zurückgesetzt werden die Werte erst dann, wenn die Bibliothek entfernt und wieder eingefügt wird. Somit können Parameterlisten auch zur Übergabe von allgemeinen Parametern genutzt werden.
Alle Parameter einer Parameterliste sind i.d.R. per ADS erreichbar. Die Tatsache, dass Parameter immer mit CONSTANT deklariert werden müssen, verhindert nicht, dass diese per ADS beschreibbar sind.
Dient ein Parameter als Arraygrenze, so wird eine Änderung dieser Variablen schwerwiegende Folgen haben. Insbesondere dann, wenn der Wert des Parameters vergrößert wird.
aTest : ARRAY [1..MyLibrary.Param.cUpperBound] OF INT;
Auch wenn der Parameter zur Laufzeit des SPS-Programms vergrößert wird, so behält das Array seine ursprüngliche Größe bei. Wird dieser Parameter aber auch in Schleifen eingesetzt, so können Zugriffe außerhalb der erlaubten Arraygrenzen entstehen.
FOR nIndex := 1 TO MyLibrary.Param.cUpperBound DO
aTest[nIndex] := nValue;
END_FOR
Um dieses zu verhindern, kann mit dem Attribut tc_no_symbol die ADS-Symbolerzeugung verhindert werden. Ein Zugriff per ADS über den Symbolnamen ist dann für diesen Parameter nicht mehr möglich.
VAR_GLOBAL CONSTANT
{attribute 'tc_no_symbol'}
cUpperBound : INT := 5;
END_VAR
Visual Studio bietet umfangreiche Funktionen im Bereich Architektur und Code Analyse über die nicht häufig berichtet wird. Diese Funktionen sind aber ungerechtfertigter Weise "hinter dem Vorhang" und haben auch mit Visual Studio 2017 einige Neuerungen und Weiterentwicklung bekommen.
Echtzeitüberprüfung von Architekturabhängigkeiten: Der Editor überprüft während Änderungen im Code vorgenommen werden ob Architekturvorgaben verletzt werden. Unerwünschte Abhängigkeiten werden vermieden und in der Fehlerliste angezeigt bzw. mit Wellenlinien im Text-Editor angezeigt.
Live Unit Tests: Live Unit Tests geben direktes Feedback zur Testabdeckung und Ergebnissen der Testausführung. Dazu werden bei Änderungen im Code permanent Unit Tests (MSTest, xUnit, NUnit) ausgeführt und in der Codezeile das Feedback angezeigt (erfolgreich, nicht erfolgreich, keine Abdeckung). Live Unit Testing ist für C# und VB (.NET Framework) verfügbar sowie auch für das .NET Core Framework (ab 2.0 und Visual Studio 2017 Update 3).
Ergänzung (9. Aug.): Live Unit Tests und die Echtzeitüberprüfung von Architekturabhängigkeiten sind Funktionen von Visual Studio Enterprise.
Code Maps: Die Visualisierung von Abhängigkeiten im Code hilft bei der Einarbeitung in ein Projekt und beim Erkennen von Abhängigkeiten ohne den gesamten Code lesen zu müssen. Die grafische Darstellung kann sowohl mit Visual Studio Professional sowie auch Visual Studio Enterprise gelesen werden aber nur mit Visual Studio Enterprise erstellt werden. Der Schwerpunkt bei der Sprachunterstützung liegt im managed .NET Bereich:
Codeabhängigkeiten können in folgenden Sprachen durch Code Maps dargestellt werden:
- Visual C# .NET oder Visual Basic .NET in einer Projektmappe oder in Assemblys (.dll oder .exe)
- Den systemeigenen oder verwalteten C oder C++-Code in Visual C++-Projekten, Headerdateien (.h oder #include) oder Binärdateien
- Aus .NET-Modulen für Microsoft Dynamics AX erstellte X++-Projekte und X++-Assemblydateien
Hinweis: Für andere als C#- oder Visual Basic .NET-Projekte sind weniger Optionen zum Starten einer Code Map oder zum Hinzufügen von Elementen zu einer vorhanden Code Map verfügbar. Beispielweise können Sie nicht mit der rechten Maustaste auf ein Objekt im Text-Editor eines C++-Projekts klicken, es einer Code Map hinzuzufügen. Sie können jedoch einzelne Codeelemente oder Dateien per Drag & Drop aus dem Projektmappen-Explorer, der Klassenansicht und dem Objektbrowser verschieben.
Speziell im Bereich der grafischen Darstellung von Codeabhängigkeiten gibt es auch außerhalb von .NET Erweiterungen und cross-Plattform Partnerlösungen. Ein Anbieter aus Österreich (Salzburg) ist neu in den Visual Studio Marktplatz gekommen: Sourcetrail
Sourcetrail ist ein corss-Plattform Werkzeug für C/C++/Java und bietet eine intelligente Suche, grafische Darstellung und Anzeige des dazugehörigen Codes an. Visual Studio wird dabei als Editor nicht ersetzt und eine JSON-basierte Compilation DB rundet den cross-Plattform Gedanken ab.
Visual Studio sowie auch Microsoft Azure richtet sich an Entwickler aller Plattformen und Sprachen: Ein spezielle Webseite hat Informationen zu Visual Studio für Java Entwickler zusammengefasst. Mit Azure können Sie Java-Apps ganz leicht bereitstellen und skalieren - mit den Tools Ihrer Wahl.
Gastartikel von unserem MVP Thomas Gölles, Fa. Solvion
Hallo MoCaDeSyMo!
Wie vermutlich in jedem Unternehmen in Österreich gibt es auch bei Solvion unterschiedliche Möglichkeiten zur Gestaltung der Mittagspause. Vom schnellen Weg zur Cafeteria bis zum bestellen bei unterschiedlichen Lieferservices spannt sich ein breiter Bogen verschiedener lukulischer Genüsse. Wir sind dann noch zusätzlich in der glücklichen Lage das täglich ein Jausenwagen vom Imbiss Rainer bei uns in der Einfahrt seine Waren anbietet. In den letzten Jahren war die letzte Option fast ein täglicher Weg. Ich hab direkt von meinem Arbeitsplatz direkt auf die Einfahrt gesehen und wurde quasi täglich vom Jausenwagen an die Mittagspause erinnert. Letzten Oktober aber haben wir intern Büro gewechselt und seit dem sitze ich am anderen Ende des Gebäudes ohne Sicht auf die Einfahrt. In der modernen Arbeitswelt kein Problem, einfach gegen 11:00 den Kollegen in Skype for Business pingen und fragen „Is da Rainer schon da?“ und die Sache ist erledigt. Da die Kollegen mit freier Sicht rar sind und ich auch nicht täglich zwecks der Jause anklopfen will musste eine andere Lösung her.
Der erste Gedanke drehte sich um eine mobile App, die der Fahrer des Vertrauens des geliebten Jausenwagens einfach auf seinem Phone installiert und welche dann mittels GPS und Azure einen Push sendet wenn er in unsere Nähe kommt. Eigentlich eine coole Lösung, aber jemanden fremden eine App installieren damit man selber weiß wann die Jause da ist, dass hat sich einfach nicht richtig angefühlt. Gut weiter im Brainstorming, vor Jahren auf der Uni gab es mal eine Übung in Computer Vision. Ein Foto von der Einfahrt mit dem Jausenwagen oben, ein klein wenig Kantendetektion vielleicht noch eine Histogrammverschiebung dazu und dieser Wagen müsste sich doch erkennen lassen. Die Idee galt es zu verfolgen.
Spätestens mit der Build 2017 und allen Announcments rund um Cognitive Services und die Custom Vision API war klar, ein Raspberry Pi muss her und der Jausenwagen muss erkannt werden. Ohne viel weiter Einleitung, ich darf vorstellen, MoCaDeSyMo:
MoCaDeSyMo (mobile carbohydrate delivery system monitor) ist der rote Kollege am linken Bild Rand und das jüngste Mitglied der Solvion Familie.
An Wochentagen versucht er zwischen 10:45 und 11:30 minütlich anhand eines Fotos der Firmeneinfahrt zu erkennen ob nun der bereits viel zitierte Jausenwagen zum Plündern bereit steht.
Um auch wirklich sicher zu gehen nutzt MoCaDeSyMo Azure Cognitive Services um den Jausenwagen zu erkennen und informiert danach mittels Microsoft Teams unterschiedliche Gruppen innerhalb der Firma. Aktuell bekommen wir die Info über die Wahrscheinlichkeiten und einen Link des Fotos in einen speziellen Teams Channel.
Der Output hier ist von der Marke „von Entwickler für Entwickler“ und muss für Business User sicher angepasst werden, aber für uns passt es genau so.
In weiterer Folge des Posts wird in einem kurzen Überblick das Zusammenspiel der verschiedenen Teile der Gesamtarchitektur vorgestellt.
Was läuft am Rasbperry Pi?
Basis unseres MoCaDeSyMo ist ein Raspberry Pi 3 mit dem Pi Kamera Modul. Als Betriebssystem läuft ein standard Raspbian Jessie image, in der Server Variante. Wenn schon Linux, dann richtig also ohne GUI. (Außerdem ein guter Grund die durchaus eingerosteten Linux Kenntnisse wieder auf zu frischen und wieder lieben zu lernen, Stichwort cron job) Man hätte dafür natürlich auch Windows 10 IoT verwenden können, eine schnelle Recherche hat aber ergeben, dass das default Kamera Modul in Linux weit besser anzusprechen ist, daher viel die Entscheidung pro Raspbian. Und hier nun der gesamte Code der auf dem Pi läuft:
PATH=$PATH:/home/pi/bin
export AZURE_STORAGE_ACCOUNT='%YOUR_STORAGE_ACCOUNT%'
export AZURE_STORAGE_ACCESS_KEY='%YOUR_ACCESS_KEY'
container_name='%YOUR_CONTAINER%'
today=`date '+%Y-%m-%d-%H-%M-%S'`;
filename="$today.png"
echo "taking the picture..."
raspistill -o $filename
echo "croping the picture ..."
mogrify -crop 1487x619+907+904 $filename
echo "logging into azure..."
az login --service-principal -u %USER_GUID% --password "%YOUR_STRONG_PWD%" --tenant %TENANT_GUID%
echo "uploading image"
az storage blob upload --container-name $container_name --file $filename --name $filename
echo "deleting the image"
rm $filename
echo "logging out from azure"
az logout
echo "triggering azure function ..."
image_param='image=https://%YOUR_STORAGE_ACCOUNT%.blob.core.windows.net/%YOUR_CONTAINER%/'
function_url='%YOUR_FUNCTION-URL'
curl -G $function_url -d $image_param$filename
echo ""
Diese 35 Zeilen sind die Basis, direkt am Pi. Dieses Skript wird mittels cron job gestartet und bedient sich einiger Linux Bibliotheken.
Um das Foto zu schießen reicht ein Aufruf von raspistill. Dieses Tool hat eine Menge an Features an Board, unteranderem eine Methode von selbst in einer Art Timer Job konstant Fotos zu machen:
raspistill -t 30000 -tl 2000 -o image%04d.jpg
Hier wird im Zeitraum von 30 Sekunden alle zwei Sekunden ein Foto gemacht und im aktuellen Verzeichnis abgelegt. Diese Methode ist sehr nützlich wenn es darum geht Trainingsbilder für die image recognition zu erzeugen, dazu aber später mehr.
Nach den ersten Testaufnahmen war klar, dass die 8 Megapixel Auflösung des Pi sehr viel „statischen“ Content des Bereichs der Firmeneinfahrt einfängt. Daher wird im zweiten Schritt das Bild auf eine gewisse Größe zusammen geschnitten um auch wirklich nur den Bereich weiter zu verarbeiten der die gewünschte Information hält.
Das „fertige“ Bild wird anschließend in einen Azure Blob Storage hochgeladen. Dazu wurde am Pi die Azure CLI 2.0 (https://azure.github.io/projects/clis/) installiert und verwendet. Um auch gleich Richtung Security vorbildlich zu agieren wird statt der Authentifizierung mittels User/Passwort auf einen Service Principal gesetzt. Diesen kann man auch gleich direkt am Pi mit der CLI erstellen und anschließend verwenden. Kleiner Hinweis, wer die Skripte gerne am Windows Rechner erstellt und nur auf den Pi überträgt, sollte zwei Befehle im Hinterkopf haben. Erstens chmod +x um das Skript auch wirklich ausführbar zu machen und ganz wichtig dos2unix um etwaige Probleme in den Textformaten zwischen Windows und Linux glatt zu bügeln.
Zum Abschluss wird am Pi noch mittels curl eine Azure Function aufgerufen und die URL des Fotos im Blob Storage übergeben.
Die Power aus der Cloud
In der Azure Function wird nun der Custom Vision API Endpoint aufgerufen. Nach der Übergabe des predicition keys des eigenen Custom Vision Projekts kann der Endpoint mit der URL zum Bild aufgerufen werden. Den Schlüssel und die Definition des Endpoints erhält man unter https://www.customvision.ai Hier legt man ein neues Projekt an und kann auch gleich Fotos hochladen und kategorisieren. Wir haben dazu schon ohne fix fertige Lösung Fotos vom Pi hochgeladen und die image recognition getestet. Um es kurz zu machen, schon die ersten Eindrücke waren der pure Wahnsinn. Rund 80 Fotos von der Einfahrt mit dem Jausenwagen und rund 160 ohne diesen reichten aus um bereits Wahrscheinlichkeiten über 90% zu bekommen. Diesen Test kann man auch direkt im Portal durchführen.
Hier kann man direkt eine URL zu einem Bild eintragen oder eben auch ein Foto von der lokalen Maschine hochladen und dann testen lassen. Man sieht hier auch schön einen Denkfehler meinerseits. Um die Kategoriesierung möglichst einfach zu machen, habe ich einfach False und True als Werte für die Tags verwendet. Das ist prinzipiell nicht falsch, führt aber dazu, dass man wie im Foto unten sieht bei der Konstellation von Wahrscheinlichkeiten die in Summe über 100% gehen verwirrt ist. Der Trugschluss ist, dass True und False eindeutig und völlig unabhängig von einander sind. Die image recognition hier kategorisiert aber nur, sprich es sieht den Fall False als losgelöstes Einzelereignis und gibt dafür die Wahrscheinlichkeit an. Daher ist es auch klar, dass es in Summe durchaus über 100% gehen kann.
Als Antwort schickt die Custom Vision API ein Json Objekt das wie folgt aussieht:
{\"Id\":\"%ID%\",\"Project\":\"%PROJECT_ID%\",\"Iteration\":\"%ITERATION_ID%\",\"Created\":\"2017-06-26T16:07:48.1746322Z\",\"Predictions\":[{\"TagId\":\"7c24f243-ed2c-4f20-b35f-88b7b96b1711\",\"Tag\":\"False\",\"Probability\":1.0},{\"TagId\":\"9721bc40-c00c-460d-97e4-67a269ce543a\",\"Tag\":\"True\",\"Probability\":3.00917918E-07}]}
Um diesen Json String wieder in ein C# Objekt zu bekommen reicht eine kleine Suche im Internet um auf fertige Klasse wie diese zu stossen:
public class CustomVisionResponse
{
public string Id { get; set; }
public string Project { get; set; }
public string Iteration { get; set; }
public string Created { get; set; }
public List<Prediction> Predictions { get; set; }
}
public class Prediction
{
public string TagId { get; set; }
public string Tag { get; set; }
public string Probability { get; set; }
}
Zu finden hier: http://aihelpwebsite.com/Blog/EntryId/1025/Microsoft-Cognitive-Custom-Vision-Service-ndash-A-Net-Core-Angular-4-Application-Part-One)
Mit Hilfe dieses Objektes ist es ein leichtes für die einzelnen Tags die Wahrscheinlichkeit auszulesen und damit fest zu stellen mit eben welcher Wahrscheinlichkeit es richtig wäre auf zu stehen und sich sein Mittagessen zu holen.
Fehlt noch ein Schritt, wie informieren wir die Benutzer? Dazu nutzen wir im konkreten Fall den Connector eines Microsoft Teams Channels. Diesen kann man sich direkt in Teams erstellen lassen und ist praktisch eine URL an die man seine Message schickt welche dann in Teams angezeigt wird.
using (var teams_client = new HttpClient())
{
var json_ = "{\"text\":\""+output+ link_to_img+"\"}";
log.Info(json_);
var response_ = await client.PostAsync("%YOUR_TEAMS_CONNECTOR_URL%", new StringContent(json_, System.Text.Encoding.UTF8, "application/json"));
var result_ = await response_.Content.ReadAsStringAsync();
}
Zusammenfassung
Das hier gezeigte Projekt ist binnen weniger Stunden vom eingepackten Raspberry Pi bis zur fertigen Meldung im Teams Client entstanden. Der Raspberry Pi schießt periodisch Fotos, lädt die in einen Azure Blob Storage und triggert eine Azure Function. Diese schickt das Bild zur Custom Vision API und informiert mittels Microsoft Teams die Benutzer. Das alles in ca 8-9 Stunden. Natürlich ist der Code nicht production ready sondern nur ein Prototyp und natürlich ist auch der Use Case ein sehr einfacher und simpler Fall der konkret im Business Umfeld sich nicht in Millionen an Gewinn niederschlägt. Es zeigt aber sehr schön auf was mit ein wenig Kreativität und den Mitteln der Azure Cloud möglich ist und das ganze mit nicht mal 200 Zeilen Code.
Node.js wird in der Regel als Laufzeitumgebung für Webanwendungen verwendet. Doch es eignet sich auch für andere Arten von Anwendungen wie Konsolenprogramme. Das wirft jedoch eine Reihe von Problemen auf, von der Analyse der Parameter bis zur Ausgabe der Hilfe. Wie lässt sich das bewerkstelligen?
This is kinda off-topic, because it's not about ASP.NET Core, but l really like it to share. I recently needed to import some additional user data via a nightly run into a SQL Server Database. The base user data came from a SAP database via an CSV bulk import. But not all of the data. E.g. the telephone numbers are maintained mostly by the users itself in the AD. After SAP import, we need to update the telephone numbers with the data from the AD.
The bulk import was done with a stored procedure and executed nightly with an SQL Server job. So it makes sense to do the AD import with a stored procedure too. I wasn't really sure whether this works via the SQL server.
My favorite programming languages are C# and JavaScript, and I'm not really a friend of T-SQL, but I tried it. I googled around a little bit and found a solution quick solution in T-SQL.
The trick is map the AD via an LDAP provider as a linked server to the SQL Server. This can even be done via a dialogue, but I never got it running like this, so I chose the way to use T-SQL instead:
USE [master]
GO
EXEC master.dbo.sp_addlinkedserver @server = N'ADSI', @srvproduct=N'Active Directory Service Interfaces', @provider=N'ADSDSOObject', @datasrc=N'adsdatasource'
EXEC master.dbo.sp_addlinkedsrvlogin @rmtsrvname=N'ADSI',@useself=N'False',@locallogin=NULL,@rmtuser=N'<DOMAIN>\<Username>',@rmtpassword='*******'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'collation compatible', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'data access', @optvalue=N'true'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'dist', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'pub', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'rpc', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'rpc out', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'sub', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'connect timeout', @optvalue=N'0'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'collation name', @optvalue=null
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'lazy schema validation', @optvalue=N'false'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'query timeout', @optvalue=N'0'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'use remote collation', @optvalue=N'true'
GO
EXEC master.dbo.sp_serveroption @server=N'ADSI', @optname=N'remote proc transaction promotion', @optvalue=N'true'
GO
You can to use this script to set-up a new linked server to AD. Just set the right user and password to the second T-SQL statement. This user should have read access to the AD. A specific service account would make sense here. Don't save the script with the user credentials in it. Once the linked server is set-up, you don't need this script anymore.
This setup was easy. The most painful part, was to setup a working query.
SELECT * FROM OpenQuery (
ADSI,
'SELECT cn, samaccountname, mail, mobile, telephonenumber, sn, givenname, co, company
FROM ''LDAP://DC=company,DC=domain,DC=controller''
WHERE objectClass = ''User'' and co = ''Switzerland''
') AS tblADSI
WHERE mail IS NOT NULL AND (telephonenumber IS NOT NULL OR mobile IS NOT NULL)
ORDER BY cn
Any error in the Query to execute resulted in an generic error message, which told me that there was an problem to built this query. Not really helpful.
It took me two hours to find the right LDAP connection string and some more hours to find the right properties the query.
The other painful thing are the conditions. Because the where clause outside the OpenQuery couldn't be run inside the OpenQuery. Don't ask me why. My Idea was to limit the result set completely with the query inside the OpenQuery, but was only able to limit to the objectType "User" and to the country. Also the AD need to be maintained in a proper way: e.g. the field company btw. didn't return the company (which should be the same in the entire company) but the company units.
BTW: the column order in the result set is completely the other way round, than defined in the query.
Later, I could limit the result set to existing emails (to find out whether this is a real user) and existing telephone numbers.
The rest is easy: Wrap that query in a stored procedure, iterate threw all of the users, find the related ones in the database (previously imported from SAP) and update the telephone numbers.
Wer eine Anwendung mit DDD modelliert, braucht für die Implementierung einen Ansatz zum Umsetzen der Persistenz. Dafür lässt sich eine herkömmliche CRUD-Datenbank verwenden, doch es gibt einen besseren Ansatz: Event Sourcing. Wie funktioniert das?
The requirements are simple: You will need the .cer with the corresponding .key file and need to download OpenSSL.
If you are using Windows without the awesome Linux Subsystem, take the latest pre-compiled version for Windows from this site
Otherwise with Bash on Windows you can just use OpenSSL via its “native” environment. Thanks for the hint @kapsiR
After the download run this command:
openssl pkcs12 -export -out domain.name.pfx -inkey domain.name.key -in domain.name.crt
This will create a domain.name.pfx. As far as I remember you will be asked to set a password for the generated private .pfx part.
If you are confused with .pfx, .cer, .crt take a look at this nice description blogpost.
Hope this helps!
Das Verschlüsseln von Daten gewinnt zunehmend an Bedeutung. Node.js greift zu dem Zweck auf OpenSSL zurück und unterstützt sowohl die symmetrische als auch die asymmetrische Verschlüsselung. Darüber hinaus weiß es auch mit digitalen Signaturen, Hashfunktionen & Co. umzugehen. Wie funktioniert das?
Thanks to Filipe Silva who reviewed this article and to Rob Wormald for a lot of insights regarding this technology.
In my last article, I've shown that the Angular Build Optimizer transforms the emitted JavaScript Code to make tree shaking more efficient. To demonstrate this, I've created a simple scenario that includes two modules of Angular Material without using them. After using the Bundle Optimizer, the CLI/ webpack was able to reduce the bundle size by about the half leveraging tree shaking:
If you are wondering how such amazing results are possible, you can find some answers in this article.
Please note that when writing this the Angular Build Optimizer is still experimental. Nethertheless, the results show above are very promising.
Tree Shaking and Side Effects
The CLI uses webpack for the build process and to make tree shaking possible, webpack marks exports that are not used and can therefore be safely excluded. In addition to this, a typical webpack configuration uses UglifyJS for removing these exports. Uglify tries to be on the safe side and does not remove any code that could be need at runtime. For instance, when Uglify finds out that some code could produce side effects, it keeps it in the bundle. Look at the following (artificial and obvious) example that demonstrates this:
(function(exports){
exports.pi = 4; // Let's be generous!
})(...);
Unfortunately, when transpiling ES2015+/TypeScript classes down to ES5, the class declaration results in imperative code and UglifyJS as well as other tools cannot make sure that this code isn't producing side effects. A good discussion regarding this can be found here on GitHub. That's why the code in question stays in the bundle even though it could be removed.
To assure myself about this fact, I've created a simple npm based Angular Package using the Jurgen Van de Moere's Yeoman generator for Angular libraries as well as a CLI based application that references it.
The package's entry point exports an Angular module with an UnusedComponent that -- as it's name implies -- isn't used by the application. It also exports an UnusedClass. In addition to that, it exports an other UnusedClass as well as an UsedClass from the same file (ES Module).
export {UnusedClass} from './unused';
export {OtherUnusedClass, UsedClass} from './partly-used';
export {SampleComponent} from './sample.component';
export {UnusedComponent} from './unused.component';
@NgModule({
imports: [
CommonModule
],
declarations: [
SampleComponent,
UnusedComponent
],
exports: [
SampleComponent,
UnusedComponent
]
})
export class SampleModule {
}
When building the whole application without the Angular Build Optimizer, none of the unused classes are tree shaken off. One reason for this is that -- as mentioned above -- Uglify cannot make sure that the transpiled classes don't introduce side effects.
Marking pure Code Blocks
To compensate for the shown issue, the Angular Build Optimizer marks transpiled class declarations that are not producing side effects with a special /*@__PURE__*/ comment. UglifyJS on the other side respects those comments and removes such code blocks if not referenced.
Using this technique, we can get rid of unused classes but not of the unused component. The reason for this is, as the next section shows, Angular's module system.
Removing Angular Decorators
As the NgModule-Decorator defines an Array with its Components, Directives, Pipes and Services, there is always a reference to them when importing the module. This prevents tools from tree shaking unused building blocks off.
But we are lucky, because after AOT compilation Angular's decorators are not needed anymore and therefore the Angular Bundle Optimizer removes them all. This leads to code that isn't referencing unneeded stuff anymore and allows to shake it off.
Static Members
For static members transpiled code is often introducing side effects preventing tree shaking too. For instance, look at the following example taken from the samples of the Optimizer's Readme on GitHub. It shows the transpiled version of a class with a static member:
// Taken from the Angular Build Optimizer repo
var Clazz = (function () { function Clazz() { } return Clazz; }());
Clazz.prop = 1;
To prevent the introduced side effect, the Angular Build Optimizer rewrites such sources as follows:
var Clazz = (function () { function Clazz() { } Clazz.prop = 1; return Clazz; }());
Importing tslib
There's another optimization, the optimizer performs: Depending on the compiler settings, the TypeScript compiler places some lines of helper functions at the beginning of the emitted files. Because these few lines are repeated quite often, this can lead to appreciable overhead. For instance, think about RxJS which comes with one file per operator. Each of this files contain these helpers. The good message is that the Optimizer replaces them with an import for the package tslib. Even though this does not help with tree shaking, it allows us to further shrink our bundles.
Using the Bundle Optimizer
Because of the three mentioned transformations the Angular Bundle Optimizer performs, the above mentioned unused classes and the unused component can be shaken off by the CLI and webpack. You can try it out yourself: Just download the example from my GitHub repository and create a production build with and without the Bundle Optimizer. For the latter build, you need to use the command line option -bo:
ng build --prod -bo
Please make sure that you have a current CLI version. When writing this, I've used version 1.3.0-rc.0 which was the first one coming with the Optimizer. After this, look into the generated bundles. While the one that has been created without the Optimizer contains all the unused classes, the other one doesn't.
Thanks to Filipe Silva who reviewed this article and to Rob Wormald for a lot of insights regarding this technology. Also thanks to Sander Elias who gave important feedback.
Beginning with version 1.3.0-rc.0, the Angular CLI makes use of the Angular Build Optimizer. This is a nifty tool that transforms the emitted JavaScript code to make tree shaking more efficient. This can result in huge improvements regarding bundle size. In this post I'm describing some simple scenarios that show the potential of this newly introduced tool. If you want to reproduce these scenarios, you find the source code used in my GitHub repository.
Please note that the Angular Build Optimizer was still experimental when writing this. Therefore, it is subject to change. Nevertheless, as shown below, it comes with a high potential for shrinking bundles.
Scenario 1
To demonstrate the power of the Angular Build Optimizer, I'm using a simple Angular Application I've created with the Angular CLI. After scaffolding, I've added the MdButtonModule and the MdCheckboxModule from Angular Material as well as Angular's NoopAnimationsModule and FormsModule:
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppComponent } from './app.component';
import { MdButtonModule, MdCheckboxModule } from '@angular/material';
import { NoopAnimationsModule } from '@angular/platform-browser/animations';
import { FormsModule } from "@angular/forms";
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
FormsModule,
NoopAnimationsModule,
MdButtonModule,
MdCheckboxModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Please note that I'm using none of the added modules. I've just added them to find out how good the CLI/ webpack is in combination with the Angular Build Optimizer when it comes to shake them off.
After this, I've created a production build without using the Build Optimizer and another one using it. For the latter one, I've leveraged the new -bo command line option:
ng build --prod -bo
The results of this are amazing:
As this figure shows, using the Angular Build Optimizer the bundle size after tree shaking is about the half. This fits to my observations I've written down here some months ago: There are situations that prevent tree shaking implementations from doing their job as well as they can. The Build Optimizer seems to compensate this.
Scenario 2
After this, I've added one component from each of the two included Angular Material modules to find out whether this is influencing tree shaking:
<!-- app.component.html -->
<button md-raised-button (click)="doIt()">Raised button</button>
<md-checkbox class="example-margin" [(ngModel)]="checked">Checked</md-checkbox>
This led to the following results:
Of course, both bundles are bigger, because now I'm using more parts of the bundles included. But, as before, using the Angular Build Optimizer our Bundles are about half as big.
Scenario 3
Perhaps you are wondering what's the overhead introduced by the two Angular Material modules in the scenarios above. To find this out, I've removed referenced to their Angular Modules and created two more build -- one with and one without the Angular Bundle Optimizer:
Compared to Scenario 1 this shows that when using the Build Optimizer, it is possible to shake off most parts of the Material Design Modules when they are imported but not used.
Current Limitations
As mentioned above, when writing this the Angular Build Optimizer was still experimental and therefore subject to change. Currently, it can introduce some issues when transforming the source code. For instance currently source maps are broken when creating a (production) build with the Optimizer. There is also an issue with rxjs operators and console logs. Another issue can arise when using getters with side effects as the optimizer leverages UglifyJS' pure_getters option. This option makes Uglify to remove unused calls to getters and this leads to problems if you depend on their side effects. Please also note, that these issues can also affect included packages you don't have under your control.
Nethertheless, as shown here, the Build Optimizer has a high potential.
Conclusion
The Angular Build Optimizer removed the issues that prevented tree shaking tools to do their job. This can result in a drastic reduction of bundle sizes.
Nachdem in den vergangenen Folgen die Kommandos und fachlichen Ereignisse definiert und in einem begrenzten Kontext untergebracht wurden, fehlt als letztes wichtiges Konzept von DDD noch das Aggregat.
Am 30.8. um 18:00 Uhr geht es bei der .NET User Group in Ratingen um Cross-Web- und Desktop-Anwendungen mit ASP.NET Core auf dem Server sowie TypeScript, Angular und dem Electron-Framework auf dem Client.
In the comments of my last post, I got asked to write about, how to create a email form using ASP.NET Core Razor Pages. The reader also asked about a tutorial about authentication and authorization. I'll write about this in one of the next posts. This post is just about creating a form and sending an email with the form values.
Creating a new project
To try this out, you need to have the latest Preview of Visual Studio 2017 installed. (I use 15.3.0 preview 3) And you need .NET Core 2.0 Preview installed (2.0.0-preview2-006497 in my case)
In Visual Studio 2017, use "File... New Project" to create a new project. Navigate to ".NET Core", chose the "ASP.NET Core Web Application (.NET Core)" project and choose a name and a location for that new project.
In the next dialogue, you probably need to switch to ASP.NET Core 2.0 to see all the new available project types. (I will write about the other ones in the next posts.) Select the "Web Application (Razor Pages)" and pressed "OK".
That's it. The new ASP.NET Core Razor Pages project is created.
Creating the form
It makes sense to use the contact.cshtml page to add the new contact form. The contact.cshtml.cs is the PageModel to work with. Inside this file, I added a small class called ContactFormModel. This class will contain the form values after the post request was sent.
public class ContactFormModel
{
[Required]
public string Name { get; set; }
[Required]
public string LastName { get; set; }
[Required]
public string Email { get; set; }
[Required]
public string Message { get; set; }
}
To use this class, we need to add a property of this type to the ContactModel:
[BindProperty]
public ContactFormModel Contact { get; set; }
This attribute does some magic. It automatically binds the ContactFormModel to the view and contains the data after the post was sent back to the server. It is actually the MVC model binding, but provided in a different way. If we have the regular model binding, we should also have a ModelState. And we actually do:
public async Task<IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return Page();
}
// create and send the mail here
return RedirectToPage("Index");
}
This is an async OnPost method, which looks pretty much the same as a controller action. This returns a Task of IActionResult, checks the ModelState and so on.
Let's create the HTML form for this code in the contact.cshtml. I use bootstrap (just because it's available) to format the form, so the HTML code contains some overhead:
<div class="row">
<div class="col-md-12">
<h3>Contact us</h3>
</div>
</div>
<form class="form form-horizontal" method="post">
<div asp-validation-summary="All"></div>
<div class="row">
<div class="col-md-12">
<div class="form-group">
<label asp-for="Contact.Name" class="col-md-3 right">Name:</label>
<div class="col-md-9">
<input asp-for="Contact.Name" class="form-control" />
<span asp-validation-for="Contact.Name"></span>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-md-12">
<div class="form-group">
<label asp-for="Contact.LastName" class="col-md-3 right">Last name:</label>
<div class="col-md-9">
<input asp-for="Contact.LastName" class="form-control" />
<span asp-validation-for="Contact.LastName"></span>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-md-12">
<div class="form-group">
<label asp-for="Contact.Email" class="col-md-3 right">Email:</label>
<div class="col-md-9">
<input asp-for="Contact.Email" class="form-control" />
<span asp-validation-for="Contact.Email"></span>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-md-12">
<div class="form-group">
<label asp-for="Contact.Message" class="col-md-3 right">Your Message:</label>
<div class="col-md-9">
<textarea asp-for="Contact.Message" rows="6" class="form-control"></textarea>
<span asp-validation-for="Contact.Message"></span>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-md-12">
<button type="submit">Send</button>
</div>
</div>
</form>
This also looks pretty much the same as in common ASP.NET Core MVC views. There's no difference.
BTW: I'm still impressed by the tag helpers. This guys even makes writing and formatting code snippets a lot easier.
Acessing the form data
As I wrote some lines above, there is a model binding working for you. This fills up the property Contact with data and makes it available in the OnPostAsync() method, if the attribute BindProperty is set.
[BindProperty]
public ContactFormModel Contact { get; set; }
Actually, I expected to have a model, passed as argument to the OnPost, as I saw it the first time. But you are able to use the property directly, without any other action to do:
var mailbody = $@"Hallo website owner,
This is a new contact request from your website:
Name: {Contact.Name}
LastName: {Contact.LastName}
Email: {Contact.Email}
Message: ""{Contact.Message}""
Cheers,
The websites contact form";
SendMail(mailbody);
That's nice, isn't it?
Sending the emails
Thanks to the pretty awesome .NET Standard 2.0 and the new APIs available for .NET Core 2.0, it get's even nicer:
// irony on
Finally in .NET Core 2.0, it is now possible to send emails directly to an SMTP server using the famous and pretty well known System.Net.Mail.SmtpClient():
private void SendMail(string mailbody)
{
using (var message = new MailMessage(Contact.Email, "me@mydomain.com"))
{
message.To.Add(new MailAddress("me@mydomain.com"));
message.From = new MailAddress(Contact.Email);
message.Subject = "New E-Mail from my website";
message.Body = mailbody;
using (var smtpClient = new SmtpClient("mail.mydomain.com"))
{
smtpClient.Send(message);
}
}
}
Isn't that cool?
// irony off
It definitely works and this is actually a good thing.
In previews .NET Core versions it was recommended to use an external mail delivery service like SendGrid. This kind of services usually provide a REST based API , which can be used to communicate with that specific service. Some of them also provide various client libraries for the different platforms and languages to wrap that APIs and makes them easier to use.
I'm anyway a huge fan of such services, because they are easier to use and I don't need to handle message details like encoding. I don't need to care about SMTP hosts and ports, because it is all HTTPS. I don't really need to care as much about spam handling, because this is done by the service. Using such services I just need to configure the sender mail address, maybe a domain, but the DNS settings are done by them.
SendGrid could be bought via the Azure marketplace and contains huge number of free emails to send. I would propose to use such services whenever it's possible. The SmtpClient is good in enterprise environments where you don't need to go threw the internet to send mails. But maybe the Exchanges API is another or better option in enterprise environments.
Conclusion
The email form is working and it is actually not much code written by myself. That's awesome. For such scenarios the razor pages are pretty cool and easy to use. There's no Controller to set-up, the views and the PageModels are pretty close and the code to generate one page is not distributed over three different folders as in MVC. To create bigger applications, MVC is for sure the best choice, but I really like the possibility to keep small apps as simple as possible.
Die vergangenen Folgen haben unter anderem HTTP/2 und Streams vorgestellt und gezeigt, wie Codeanalyse und Tests in Node.js funktionieren. Doch wie lassen sich die einzelnen Bausteine zu einem großen Ganzen kombinieren? Ein Praxisbeispiel zeigt das Zusammenspiel.
Statt PowerShell-Commandlets lässt sich bei der Entwicklung von .NET-Core-Projekten auch das plattformübergreifend verfügbare Kommandozeilenwerkzeug dotnet aus dem .NET Core SDK einsetzen.
I think, everyone who followed the last couple of ASP.NET Community Standup session heard about Razor Pages. Did you try the Razor Pages? I didn't. I focused completely on ASP.NET Core MVC and Web API. With this post I'm going to have a first look into it. I'm going to try it out.
I was also a little bit skeptical about it and compared it to the ASP.NET Web Site project. That was definitely wrong.
You need to have the latest preview on Visual Studio 2017 installed on your machine, because the Razor Pages came with ASP.NET Core 2.0 preview. It is based on ASP.NET Core and part of the MVC framework.
Creating a Razor Pages project
Using Visual Studio 2017, I used "File... New Project" to create a new project. I navigate to ".NET Core", chose the "ASP.NET Core Web Application (.NET Core)" project and I chose a name and a location for that project.
In the next dialogue, I needed to switch to ASP.NET Core 2.0 to see all the new available project types. (I will write about the other one in the next posts.) I selected the "Web Application (Razor Pages)" and pressed "OK".
Program.cs and Startup.cs
I you are already familiar with ASP.NET core projects, you'll find nothing new in the Program.cs and in the Startup.cs. Both files look pretty much the same.
public class Program
{
public static void Main(string[] args)
{
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
The Startup.cs has a services.AddMvc() and an app.UseMvc() with a configured route:
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
That means the Razor Pages are actually part of the MVC framework, as Damien Edwards always said in the Community Standups.
The solution
But the solution looks a little different. Instead of a Views and a Controller folders, there is only a Pages folder with the razor files in it. Even there are known files: the _layout.cshtml, _ViewImports.cshtml, _ViewStart.cshtml.
Within the _ViewImports.cshtml we also have the import of the default TagHelpers
@namespace RazorPages.Pages
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
This makes sense, since the Razor Pages are part of the MVC Framework.
We also have the standard pages of every new ASP.NET project: Home, Contact and About. (I'm going to have a look at this files later on.)
As every new web project in Visual Studio, also this project type is ready to run. Pressing F5 starts the web application and opens the URL in the browser:
Frontend
For the frontend dependencies "bower" is used. It will put all the stuff into wwwroot/bin. So even this is working the same way as in MVC. Custom CSS and custom JavaScript ar in the css and the js folder under wwwroot. This should all be familiar for ASP.NET Corer developers.
Also the way the resources are used in the _Layout.cshtml are the same.
Welcome back "Code Behind"
This was my first thought for just a second, when I saw the that there are nested files under the Index, About, Contact and Error pages. At the first glimpse this files are looking almost like Code Behind files of Web Form based ASP.NET Pages, but are completely different:
public class ContactModel : PageModel
{
public string Message { get; set; }
public void OnGet()
{
Message = "Your contact page.";
}
}
They are not called Page, but Model and they have something like an handler in it, to do something on a specific action. Actually it is not a handler, it is an an method which gets automatically invoked, if this method exists. This is a lot better than the pretty old Web Forms concept. The base class PageModel just provides access to some Properties like the Contexts, Request, Response, User, RouteData, ModelStates, ViewData and so on. It also provides methods to redirect to other pages, to respond with specific HTTP status codes, to sign-in and sign-out. This is pretty much it.
The method OnGet allows us to access the page via a GET request. OnPost does the same for POST. Gues what OnPut does ;)
Do you remember Web Forms? There's no need to ask if the current request is a GET or POST request. There's a single decoupled method per HTTP method. This is really nice.
On our Contact page, inside the method OnGet the message "Your contact page." will be set. This message gets displayed on the specific Contact page:
@page
@model ContactModel
@{
ViewData["Title"] = "Contact";
}
<h2>@ViewData["Title"].</h2>
<h3>@Model.Message</h3>
As you can see in the razor page, the PageModel is actually the model of that view which gets passed to the view, the same way as in ASP.Net MVC. The only difference is, that there's no Action to write code for and something will invoke the OnGet Method in the PageModel.
Conclusion
This is just a pretty fast first look, but the Razor Pages seem to be pretty cool for small and low budget projects, e. g. for promotional micro sites with less of dynamic stuff. There's less code to write and less things to ramp up, no controllers and actions to think about. This makes it pretty easy to quickly start a project or to prototype some features.
But there's no limitation to do just small projects. It is a real ASP.NET Core application, which get's compiled and can easily use additional libraries. Even Dependency Injection is available in ASP.NET Core RazorPages. That means it is possible to let the application grow.
Even though it is possible to use the MVC concept in parallel by adding the Controllers and the Views folders to that application. You can also share the _layout.cshtml between both, the Razor Pages and the VMC Views, just by telling the _ViewStart.cshtml where the _layout.cshtml is.
Don't believe me? Try this out: https://github.com/juergengutsch/razor-pages-demo/
I'm pretty sure I'll use it in some of my real projects in the future.
Mein Buch ist in einer neuen Auflage erschienen. Es ist auf rund 300 Seiten angewachsen und behandelt neben Version 1.1.2 auch schon die zweite Hauptversion des neuen objektrelationalen Mappers von Microsoft.
Das Ergebnis der vergangenen Folge war eine Definition der fachlichen Ereignisse für eine To-do-Liste. Verursacht werden sie in der Regel durch Aktionen des Anwenders, die seine Absichten und Wünsche ausdrücken. Wie lässt sich das modellieren?
Das Schreiben von Dokumentation gehört zu den eher wenig geliebten Aufgaben von Entwicklern. Trotzdem ist das Thema wichtig, denn eine gute Dokumentation erleichtert die Arbeit mit einer Komponente dramatisch. Wie funktioniert das im Kontext von Node.js?
PowerShell Core 6.0 soll erscheinen, wenn weitgehende Kompatibilität zur Windows PowerShell 5.1 erreicht ist. Gleichzeitig besiegelt Microsoft in der Roadmap das Ende der klassischen Windows PowerShell.
Until now it is pretty hard to move an existing more complex .NET Framework library to .NET Core or .NET Standard 1.x. More complex in my case just means, e. g. that this specific library uses reflection a little more than maybe some others. I'm talking about the LightCore DI container.
I started to move it to .NET Core in November 2015, but gave up halve a year later. Because it needs much more time to port it to NET Core and because it makes much more sense to port it to the .NET Standard than to .NET Core. And the announcement of .NET Standard 2.0 makes me much more optimistic to get it done with pretty less effort. So I stopped moving it to .NET Core and .NET Standard 1.x and was waiting for .NET standard 2.0.
LightCore is back
Some weeks ago the preview version of .NET Standard 2.0 was announced and I tried it again. It works as expected. The API of .NET Standard 2.0 is big enough to get the old source of LightCore running. Also Rick Strahl did some pretty cool and detailed post about it:
The current status
- I created .NET Standard 2.0 libraries for the most of the projects. I didn't change most parts of the code. The XAML configuration stuff was an exception.
- I also ported the existing unit tests to .NET Core Xunit test libraries and the tests are running. That means LightCore is definitely running with .NET Core 2.0.
- We'll get one breaking change: I moved the file based configuration from XAML to JSON, because the XAML serializer is not (maybe not yet) supported in .NET Standard.
- We'll get another breaking change: I don't want to support Silverlight anymore.
- Silverlight users should use the old packages instead. Sorry about that.
Roadmap
I don't really want to release the new version until the .NET Standard 2.0 is released. I don't want to have the preview versions of the .NET Standard libraries referenced in a final version of LightCore. That means, there is still some time to get the open issues done.
- 2.0.0-preview1
- End of July 2017
- Uses the preview versions of .NET Standard 2.0 and .NET Core 2.0
- 2.0.0-preview2
- End of August 2017
- Uses the preview versions of .NET Standard 2.0 and .NET Core 2.0. Maybe the finals, if they are released until that.
- 2.0.0
- September 2017
- depends on the release of .NET Standard 2.0 and .NET Core 2.0
Open issues
The progress is good, but there is still something to do, before the release of the first preview:
- We need to have the same tests in .NET Framework based unit tests to be sure
- We need to finalize the ASP.NET integration package to get it running again in ASP.NET 4.x
- We need to complete the ASP.NET Core integration package to get it running in ASP.NET Core
- Continuous integration and deployment using AppVeyor should be set-up
- Documentation should be set-up on GitHub
Contributions
I'd like to call for contributions. Try LightCore, raise Issues, create PRs and whatever is needed to get LightCore back to life and whatever is needed to make it a lightweight, fast and easy to use DI container.
Der .NET Stammtisch in Linz hat sein zweites Treffen angekündigt:
Event-URL (mit Details): https://www.facebook.com/events/1003694579733452/
Termin: Mittwoch, 26. Juli um 18:30
Location: Coworking Cube, Obere Landstr. 19 Pucking, Oberosterreich, Austria
Rainer Stropek spricht über "Dockerizing .NET Apps"
.NET und C# sind für sich schon tolle Werkzeuge, um moderne Softwareprodukte umzusetzen. Gibt man aber noch ein wenig Docker dazu, wird die Mischung noch attraktiver. In dem Vortrag erzählt Rainer Stropek, Microsoft MVP und Regional Director, was Microsoft in Sachen Docker-Unterstützung von .NET macht. Er stellt die fertigen Docker Images vor (für .NET Core und .NET Full Framework) und zeigt in Live Demos, wie man sie verwendet.
When upgrading from AngularJS 1.x to Angular (2/4/5 etc.), we usually prepare our AngularJS 1.x code base first:
This can involve leveraging new AngularJS 1.x techniques like components. Additionally, introducing TypeScript as well as module loaders like SystemJS or webpack are further tasks to prepare the existing code. The goal behind this is to draw near Angular in order to allow a better integration.
But in some situations preparing the existing code is too costly. For instance, think about situations where we just want to write new parts of the application with Angular without the need to modify much of the existing AngularJS 1.x code. When this holds true for your project, skipping the preparation phase could be a good idea:
This post shows step by step, how this approach can be accomplished. Like the official and well written upgrading tutorial which includes preparing the code base, it upgrades the popular AngularJS 1.x Phone Catalog Sample.
Even though this sample leverages AngularJS components introduced with AngularJS 1.5, everything shown here also works with more "traditional" AngularJS code using controllers and directives.
The whole sample can be found in my GitHub repository. In order to make following everything easier, I've also created one commit for each of the steps described here.
Step 1: Creating the new Angular Application
As a starting point this article assumes that we are scaffolding a new Angular application with the Angular CLI:
ng new migrated
To make the structure of this new solution clearer, create one folder for the existing AngularJS code and another one for the new Angular code within src. In the sample presented here, I've used the names ng1 and ng2:
After this, move every generated file except the shown tsconfig.app.json, tsconfig.spec.json, favicon.ico and index.html into the ng2 folder.
To inform the CLI's build task about this new structure, adopt the file .angular-cli.json. Using the assets section in this file, we can also tell the CLI to directly copy the ng1 folder to the output directory:
{
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"project": {
"name": "migrated"
},
"apps": [
{
"root": "src",
"outDir": "dist",
"assets": [
"ng1",
"assets",
"favicon.ico"
],
"index": "index.html",
"main": "ng2/main.ts",
"polyfills": "ng2/polyfills.ts",
"test": "ng2/test.ts",
"tsconfig": "tsconfig.app.json",
"testTsconfig": "tsconfig.spec.json",
"prefix": "app",
"styles": [
"ng2/styles.css"
],
"scripts": [],
"environmentSource": "ng2/environments/environment.ts",
"environments": {
"dev": "ng2/environments/environment.ts",
"prod": "ng2/environments/environment.prod.ts"
}
}
],
"e2e": {
"protractor": {
"config": "./protractor.conf.js"
}
},
"lint": [
{
"project": "tsconfig.app.json"
},
{
"project": "tsconfig.spec.json"
},
{
"project": "tsconfig.e2e.json"
}
],
"test": {
"karma": {
"config": "./karma.conf.js"
}
},
"defaults": {
"styleExt": "css",
"component": {}
}
}
Now copy the whole AngularJS 1.x application into the ng1 folder but omit it's index.html. To make the existing application work with the adopted folder structure, we have to update it. This involves updating every reference to a template as well as references to JSON files and images.
After this, we can merge the existing index.html with the new one in the folder src:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Migrated</title>
<base href="http://www.softwarearchitekt.at/">
<!-- ng1 -->
<link rel="stylesheet" href="ng1/bower_components/bootstrap/dist/css/bootstrap.css" />
<link rel="stylesheet" href="ng1/app.css" />
<link rel="stylesheet" href="ng1/app.animations.css" />
<script src="ng1/bower_components/jquery/dist/jquery.js"></script>
<script src="ng1/bower_components/angular/angular.js"></script>
<script src="ng1/bower_components/angular-animate/angular-animate.js"></script>
<script src="ng1/bower_components/angular-resource/angular-resource.js"></script>
<script src="ng1/bower_components/angular-route/angular-route.js"></script>
<script src="ng1/app.module.js"></script>
<script src="ng1/app.config.js"></script>
<script src="ng1/app.animations.js"></script>
<script src="ng1/core/core.module.js"></script>
<script src="ng1/core/checkmark/checkmark.filter.js"></script>
<script src="ng1/core/phone/phone.module.js"></script>
<script src="ng1/core/phone/phone.service.js"></script>
<script src="ng1/phone-list/phone-list.module.js"></script>
<script src="ng1/phone-list/phone-list.component.js"></script>
<script src="ng1/phone-detail/phone-detail.module.js"></script>
<script src="ng1/phone-detail/phone-detail.component.js"></script>
<!-- /ng1 -->
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" type="image/x-icon" href="favicon.ico">
</head>
<body ng-app="phonecatApp">
<!-- ng1 -->
<div class="view-container">
<div ng-view class="view-frame"></div>
</div>
<!-- /ng1 -->
<app-root></app-root>
</body>
</html>
Note that this merged index.html contains references to the CSS files and scripts the AngularJS 1.x application needs. It also bootstraps the AngularJS 1.x application using ng-app and provides its shell containing a div with the ng-view directive. This is where the router activates the configured templates.
In this file we can also find the root element for our Angular application. References to the generated Angular bundles are not necessary as they are generated by the build task.
When this application is started (ng serve), it loads both applications independently of each other into the browser. To see this, navigate to http://localhost:4200:
As those two applications are bootstrapped separately, they are not able to communicated with each other or to exchange services and components. To make this work, we have to bootstrap them together as a hybrid application. The next section show how to do this.
Step 2: Bootstrap an AngularJS+Angular Hybrid Application
To bootstrap one application with both, AngularJS 1.x and Angular, we can leverage ngUpgrade which is part of Angular:
npm install @angular/upgrade --save
As we don't want to bootstrap the Angular (2/4/5 etc.) application on its own, we remove it's root component within the index.html:
<!-- remove root component -->
<!--
<app-root></app-root>
-->
Now, we can bootstrap both applications together. For this, import the UpgradeModule into the Angular application's AppModule. Remove the AppComponent from bootstrap in order to bootstrap the hybrid application manually:
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { UpgradeModule, downgradeComponent } from '@angular/upgrade/static';
import { AppComponent } from './app.component';
import { Ng2DemoComponent } from "ng2/app/ng2-demo.component";
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
UpgradeModule
],
providers: [],
// bootstrap: [AppComponent] // No Bootstrap-Component
})
export class AppModule {
constructor(private upgrade: UpgradeModule) { }
ngDoBootstrap() {
this.upgrade.bootstrap(document.body, ['phonecatApp'], { strictDi: true });
}
}
As you can see here, this example bootstraps the hybrid application within ngDoBootstrap using the injected UpgradeModule. To prevent bootstrapping the AngularJS 1.x part twice, we have to remove the ng-app directive within the file index.html.
When we start the application after this, we just see the AngularJS 1.x components:
Nevertheless, it's a hybrid application with both versions of Angular. To proof this, the next section shows how to use an Angular component within the shown AngularJS component.
Step 3: Downgrading an Angular Component
To show how to use an Angular Component within our hybrid application's AngularJS context, this tutorial uses a very simple dummy component:
// src/app/ng2-demo.component.ts
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'ng2-demo',
template: `
<h3>Angular 2 Demo Component</h3>
<img width="150" src="..." />
`
})
export class Ng2DemoComponent {
}
The source for the shown image can be found in scaffolded AppComponent.
To use this component within an AngularJS template, we have to downgrade it. For this, ngUpgrade provides the function downgradeComponent:
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { UpgradeModule, downgradeComponent } from '@angular/upgrade/static';
import { AppComponent } from './app.component';
import { Ng2DemoComponent } from "ng2/app/ng2-demo.component";
declare var angular: any;
angular.module('phonecatApp')
.directive(
'ng2Demo',
downgradeComponent({component: Ng2DemoComponent})
);
@NgModule({
declarations: [
AppComponent,
Ng2DemoComponent
],
imports: [
BrowserModule,
UpgradeModule
],
entryComponents: [
Ng2DemoComponent // Don't forget this!!!
],
providers: [],
// bootstrap: [AppComponent] // No Bootstrap-Component
})
export class AppModule {
constructor(private upgrade: UpgradeModule) { }
ngDoBootstrap() {
this.upgrade.bootstrap(document.body, ['phonecatApp'], { strictDi: true });
}
}
As you see in this sample, the downgraded component is registered as a directive within the AngularJS 1.x module. For this, we can leverage the global angular variable. In order to tell TypeScript about this preexisting variable, we have to use the declare keyword.
After this, we can call the Angular Component within an AngularJS 1.x template:
<!-- src/ng1/phone-list/phone-list.template.html -->
<div class="row">
<div class="col-md-2">
<!--Sidebar content-->
<p>
Search:
<input ng-model="$ctrl.query" />
</p>
<p>
Sort by:
<select ng-model="$ctrl.orderProp">
<option value="name">Alphabetical</option>
<option value="age">Newest</option>
</select>
</p>
<p>
<!-- Angular 2 Component -->
<ng2-demo></ng2-demo>
</p>
</div>
As usual in AngularJS, we have to make use of kebab case within HTML files while we have to register the directive with its normalized name the JavaScript counterpart. The latter one is using camel case.
When we reload the application, it shows the AngularJS 1.x phone list with our Angular demo component:
Perhaps you are wondering how this new Anglar Component can use the existing application logic provided by AngularJS 1.x services. Read the next section to get an answer.
Step 4: Upgrade a service
In order to use an existing AngularJS 1.x service within a new Angular Component, we have to upgrade it. According to the official docs, we have to create an Angular service provider which uses a factory. This factory gets a reference to the AngularJS 1.x injector ($injector) and uses it to obtain the service in question:
// src/ng2/app/phone.service.ts
import { InjectionToken } from "@angular/core";
export const PHONE_SERVICE = new InjectionToken<any>('PHONE_SERVICE');
export function createPhoneService(i) {
return i.get('Phone');
}
export const phoneServiceProvider = {
provide: PHONE_SERVICE,
useFactory: createPhoneService,
deps: ['$injector']
}
Normally, we could use the service's type as the dependency injection token defined by the provide property. But in this case we explicitly decided to not upgrade the existing AngularJS 1.x code to TypeScript and so we don't have any type for it. Because of this, this sample uses a constant based Token called PHONE_SERVICE. For such tokens Angular 4+ provides the type InjectionToken. In Angular 2 we would use OpaqueToken instead. The InjectionToken takes a type parameter which identifies the type of the service it is pointing to. As mentioned, we don't have a type for this service and so we are just going with any.
The discussed service provider has to be registered with our Angular module:
// src/ng2/app/app.module.ts
[...]
import { phoneServiceProvider } from "ng2/app/phone.service";
[...]
@NgModule({
[...],
providers: [
phoneServiceProvider
]
})
export class AppModule {
[...]
}
After this, we can inject the phoneService into our Ng2DemoComponent and use it to load all managed phones:
import { Component, OnInit, Inject } from '@angular/core';
import { PHONE_SERVICE } from "ng2/app/phone.service";
@Component({
selector: 'ng2-demo',
template: `
<h3>Angular 2 Demo Component</h3>
<img width="150" src="[...]" />
<p>
{{phones.length}} Phones found.
</p>
`
})
export class Ng2DemoComponent implements OnInit {
phones: any[] = [];
constructor(
@Inject(PHONE_SERVICE) private phoneService: any) {
}
ngOnInit() {
this.phones = this.phoneService.query();
}
}
As our token is just a constant, this sample uses the Inject decorator which points to it. After loading the phones, it just displays their count.
After reloading the application we see can this:
Please note that we have an AngularJS 1.x component with an Angular Component that is displaying data from an AngularJS 1.x service.
Instead of nesting AngularJS 1.x and Angular stuff, we also need the possibility to activate routes from both versions. The next sections deal with this.
Step 5: Routing to Angular Components
Making the AngularJS 1.x Router to activate Angular components is quite easy. For this, we just have to configure a route with a template that points to the component in question:
$routeProvider.
when('/phones', {
template: '<phone-list></phone-list>' // AngularJS 1.x template
}).
when('/phones/:phoneId', {
template: '<phone-detail></phone-detail>' // AngularJS 1.x template
}).
when('/ng2-demo', {
template: '<ng2-demo></ng2-demo>' // Angular component
})
This allows to use the Angular Component alongside AngularJS routes which can base upon traditional controllers as well as directives and components.
I want to strike out, that this very approach works with the popular UI-Router too.
While this solution is very easy, it also comes with a drawback: We cannot leverage the new Angular Router for the newly written components. To make this possible, we can implement Victor Savkin's Sibling Outlet approach, which uses both routers together. To foundation for this is his Upgrade Shell pattern. The next two sections describe how to introduce those ideas into the case study presented here.
Step 6: Using Victor Savkin's Upgrade Shell pattern
The upgrade shell pattern has been introduced by Victor Savkin who one of the masterminds behind Angular. He describes it in his blog as well in his eBook about ngUpgrade. It envisages an Angular component on top of an hybrid application. This is the upgrade shell that contains both, AngularJS building blocks (directives, components, controllers) as well as Angular Components.
To implement this pattern we can use the AppComponent the CLI generated when we started the endeavor described in this article:
// src/ng2/app/app.component.html
<!--The whole content below can be removed with the new code.-->
<div style="text-align:center">
<h1>
Welcome to {{title}}!!
</h1>
</div>
<!-- ng1 -->
<div class="view-container">
<div ng-view class="view-frame"></div>
</div>
<!-- /ng1 -->
Note that this Angular components contains the ng-view for the AngularJS 1.x router.
To make this component the top level component of our application, we have to directly bootstrap it. For this, we have to put it into the bootstrap array of the AppModule:
// src/ng2/app/app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule, InjectionToken } from '@angular/core';
import { UpgradeModule, downgradeComponent } from '@angular/upgrade/static';
import { AppComponent } from './app.component';
import { Ng2DemoComponent } from "ng2/app/ng2-demo.component";
import { phoneServiceProvider } from "ng2/app/phone.service";
declare var angular: any;
angular.module('phonecatApp')
.directive(
'ng2Demo',
downgradeComponent({component: Ng2DemoComponent})
);
@NgModule({
declarations: [
AppComponent,
Ng2DemoComponent
],
imports: [
BrowserModule,
UpgradeModule
],
entryComponents: [
Ng2DemoComponent // Don't forget this!!!
],
providers: [
phoneServiceProvider
],
bootstrap: [AppComponent]
})
export class AppModule {
// Remove code for bootstrapping hybrid app manually !!!
/*
constructor(private upgrade: UpgradeModule) { }
ngDoBootstrap() {
this.upgrade.bootstrap(document.body, ['phonecatApp'], { strictDi: true });
}
*/
}
Please note, that we also have to remove the code to bootstrap the application manually. This code is moved into the AppComponent and does it's job after the upgrade shell has been bootstrapped:
// src/ng2/app/app.component.ts
import { Component, Inject } from '@angular/core';
import { PHONE_SERVICE } from "ng2/app/phone.service";
import { UpgradeModule } from "@angular/upgrade/static";
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'app';
phones: any[] = [];
constructor(private upgrade: UpgradeModule) { }
ngOnInit() {
this.upgrade.bootstrap(document.body, ['phonecatApp']);
}
}
Also, make sure that the index.html is just referencing our upgrade shell:
<!-- src/index.html -->
<body>
<app-root></app-root>
</body>
Reload the application and see the upgrade shell which contains the AngularJS 1.x application.
When this works, we have provided the foundation for the goal of the next section: Using both, the AngularJS 1.x as well the Angular router, alongside.
Step 7: Using Victor Savkin's Sibling Outlet approach to use both Routers
[Victor's sibling outlet approach]((https://blog.nrwl.io/upgrading-angular-applications-managing-routers-and-url-ca5588290aaa) describes a way to use routers of both Angular versions alongside. To implement it, we need to load the Angular router:
npm install @angular/router --save
After this, extend the app.component.html. It gets one outlet for each router version. For the AngularJS 1.x router it's a div with the ng-view directive. For the Angular Router it's a router-outlet element:
<!-- src/ng2/app/app.component.html -->
<div class="view-container">
<div ng-view class="view-frame"></div>
<router-outlet></router-outlet>
</div>
When activating an AngularJS 1. based route, the first one gets a template; when activating an Angular route the latter one is used.
Now, let's configure the Angular router:
// src/ng2/app/app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule, InjectionToken } from '@angular/core';
import { RouterModule} from '@angular/router';
import { UpgradeModule, downgradeComponent } from '@angular/upgrade/static';
import { AppComponent } from './app.component';
import { Ng2DemoComponent } from "ng2/app/ng2-demo.component";
import { phoneServiceProvider } from "ng2/app/phone.service";
declare var angular: any;
angular.module('phonecatApp')
.directive(
'ng2Demo',
downgradeComponent({component: Ng2DemoComponent})
);
@NgModule({
declarations: [
AppComponent,
Ng2DemoComponent
],
imports: [
BrowserModule,
UpgradeModule,
RouterModule.forRoot([
{
path: '',
pathMatch: 'full',
redirectTo: 'ng2-route'
},
{
path: 'ng2-route',
component: Ng2DemoComponent
}
],
{
useHash: true
}
)
],
entryComponents: [
Ng2DemoComponent
],
providers: [
phoneServiceProvider
],
bootstrap: [AppComponent]
})
export class AppModule {
}
As you can see here, the configuration for the Angular router just defines two routes in this example. In addition to this, is is using the hash strategy for the sake of uniformity between the two versions.
We also have to make sure that the Angular router is doing nothing when a AngularJS 1.x route is activated. For this, Victor proposes the use of a custom UrlHandlingStrategy:
// src/ng2/app/app.module.ts
import { RouterModule, UrlHandlingStrategy } from '@angular/router';
[...]
export class CustomHandlingStrategy implements UrlHandlingStrategy {
shouldProcessUrl(url) {
return url.toString().startsWith("/ng2-route") || url.toString() === "/";
}
extract(url) { return url; }
merge(url, whole) { return url; }
}
This strategy has to be registered, e. g. with the AppModule:
// src/ng2/app/app.module.ts
@NgModule({
[...]
providers: [
phoneServiceProvider,
{ provide: UrlHandlingStrategy, useClass: CustomHandlingStrategy }
],
bootstrap: [AppComponent]
})
export class AppModule {
}
After this, we have to modify the AngularJS 1.x routing configuration a bit. First of all, we have to remove the configured hash prefix because this would irritate the Angular router. In addition to this, we have to add a default route using otherwise that loads an empty template into the version-1-outlet when the route in question is handled by the other router:
// src/app1/app.config.js
// No Prefix for the sake of uniformity
// $locationProvider.hashPrefix('!');
$routeProvider.
when('/phones', {
template: '<phone-list></phone-list>'
}).
when('/phones/:phoneId', {
template: '<phone-detail></phone-detail>'
}).
when('/ng2-demo', {
template: '<ng2-demo></ng2-demo>'
})
.otherwise({template : ''});
As above, everything shown using the AngularJS 1.x router also works the the popular UI-Router.
After this, just add some kind of menu to the AppComponent that allows to switch between the AngularJS 1.x based as well as Angular based routes:
<!-- src/app2/app.component.html -->
<a routerLink="ng2-route">ng2-route</a> |
<a href="#/phones">Phones</a>
After reloading the application we should have the possibility to switch between our routes:
Ich habe meine Folien zum Vortrag „Lernen durch Üben“, den ich auf der DWX 2017 gehalten habe, zu Speakerdeck hochgeladen.
Der Beitrag Folien zum Vortrag Lernen durch Üben erschien zuerst auf Refactoring Legacy Code.
PowerShell Core ist die plattformneutrale Variante der Windows PowerShell. Sie läuft nicht nur auf Windows, sondern auch Linux und MacOS.
Die Folien zu meinem Vortrag „Nextlevel Clean Code Development“ sind online bei Speakerdeck zu finden.
Der Beitrag Folien zum Vortrag Nextlevel Clean Code Development erschien zuerst auf Refactoring Legacy Code.
Während der DWX 2017 in Nürnberg hat Tilman Börner, Chefredakteur der dotnetpro, mich interviewt. Im Interview plaudern wir über die Entwicklung der Clean Code Developer Initiative.
Der Beitrag Interview von der DWX17 zu Nextlevel Clean Code Developer erschien zuerst auf Refactoring Legacy Code.
NDepend nutzte ich mittlerweile häufig zur Analyse meiner Anwendungen. Die statische Codeanalyse liefert zwar kein vollständiges Bild zum Zustand einer Anwendung, aber man erhält genügend Informationen um Probleme frühzeitig zu erkennen. Die früheren Versionen hatte ich bereits hier und hier beschrieben. In der neusten Version kommt nun das Thema der technischen Schulden grosse Beachtung. Ein … Technische Schulden verfolgen mit NDepend 2017.2 weiterlesen
On July 1st, I got the email from the Global MVP Administrator. I got the MVP award the third time in a row :)
I'm pretty proud about that and I'm happy to be part of the great MVP community one year more. I'm also looking forward to the Global MVP Summit in March to meet all the other MVPs from around the world.
Not really a fan-boy...?
I'm also proud of that, because I don't really call me a Microsoft fan-boy. And sometimes, I also criticize some tools and platforms built by Microsoft (feel like a bad boy). But I like most of the development tools build by Microsoft and I like to use the tools, and frameworks and I really like the new and open Microsoft. The way how Microsoft now supports more than its own technologies and platforms. I like using VSCode, Typescript and Webpack to create NodeJS applications. I like VSCode and .NET Core on Linux to build Applications on a different platform than Windows. I also like to play around with UWP Apps on Windows for IoT on a Raspberry PI.
There are much more possibilities, much more platforms, much more customers to reach, using the current Microsoft development stack. And this is really fun to play with it, to use it in real project, to write about it in .NET magazines, in this blog and to talk about it in the user groups and on conferences.
Thanks
But I wouldn't get honored again without such a great development community. I wouldn't continue to contribute to the community without that positive feedback and without that great people. This is why the biggest "Thank You" goes to the development community :)
Sure, I also need to say "Thank You" to my great family (my lovely wife and my three kids) which supports me in spending som much time to contribute to the community. I also need to say Thanks to my company and my boss for supporting me and allowing me to use parts of my working time to contribute the the community.
Die meisten Beispiele für Webpack enthalten fertige Konfigurationen die als npm scripte hinterlegt sind. Wenn man aber einen automatisierten Build Prozess verwendet z.B. über den TFS, dann möchte man evtl. einige Variablen von außen an den Buildprozess übergeben. Dazu könnte z.B. die “baseUrl” gehören, wenn die Anwendung nicht im Root des Webserver gehostet wird. Wenn […]
Manchmal könnte man sagen “früher” war alles besser. Zumindest war es mit Angular 1 und dem “alten” System in dem man noch direkt JavaScript und Styles eingebunden hat, einfacher im HTML die passende IntelliSense für die CSS Klassen mit der Hilfe von Resharper zu erhalten. Dabei handelte es sich z.B. um Bootstrap und font awesome […]
Zur Unterstützung des NOSSUED Software Entwicklungs Open Space bieten wir den ersten 2 Teilnehmern, die uns eine Kopie ihres Tickets an schulung@co-IT.eu zukommen lassen, die Teilnahme an unserem 3-tägigen Angular 4 Fundamentals Workshop kostenlos an.
Das Training ist vom 11-13. Juli in unseren modernen, klimatisierten Büros mit höhenverstellbaren Tischen im Herzen von Karlsruhe. Unser Firmenprofil verrät euch mehr.
Für alle diejenigen, die meinen Blog lesen und nicht zum #nossued gehen können, habe ich ebenfalls eine spezielle Aktion: Wer mir als erstes an die oben genannte E-Mail-Adresse eine Nachricht mit dem Titel „ich blogge“ schreibt und darin seinen Blog verlinkt, der darf auch kostenlos an der Schulung teilnehmen.
Einsortiert unter:Development, Events, German Tagged: Workshop 
Es ist mal wieder so weit: Zum achten Mal findet #nossued, der Software Open Space der .NET Usergroup in Karlsruhe statt. Termin ist der 14-16 Juli. Zur Anmeldung geht es hier. Der Teilnahmebeitrag kann wie immer frei gewählt werden.
Impressionen der letzten Open Spaces findet ihr in meinem Blog. Meinen Artikel zum Open Space Format hat die dotnetpro freundlicherweise freigegeben.
Wir du vielleicht schon am Titel erkannt hast, hat sich der Name geändert: Dieser lautet nun Software Entwicklungs Open Space, um dem breiteren Fokus Rechnung zu tragen. Das spiegelt sich im Logo ebenso wieder. Der Hashtag #nossued und die Webseitenadresse sind gleich geblieben.
Wir würden uns freuen, wenn ihr ein wenig Werbung macht und dieses Plakat bei euch in der Firma aushängt. Ihr könnt mich gerne anschreiben, dann senden wir euch Postkarten, Flyer und Plakat zu. Schaut auch auf der dedizierten Facebook Veranstaltung vorbei und teilt diesen Beitrag.
Einsortiert unter:Events, German Tagged: Community, Open Space 
CRUD ist nicht die Antwort auf alle Fragen. Der größte Kritikpunkt ist die auf vier Verben begrenzte Semantik: Fachexperten und Anwender denken nicht in CREATE, READ, UPDATE und DELETE. Welche Wörter verwenden sie stattdessen?
Wie jedes Jahr fand auch in diesem Jahr wieder mit der Developer Week die größte deutsche Entwicklerkonferenz im NCC Ost in Nürnberg statt. An dieser Stelle möchte ich nun alle Inhalte zu meinen Sessions und Workshops zum Download anbieten. Im Archiv enthalten sind alle Inhalte, die während meiner Session erzeugt wurden, also Folien, Notizen in OneNote sowie alle Projekte aus Visual Studio (2017).
Sessions
Workshops
Wichtiger Hinweis: Das Archiv zum Workshop ist mit einem Passwort versehen, welches allen Teilnehmern während dem Workshop bekannt gegeben wurde. Falls es jemand vergessen haben sollte, kann dies per Email erfragt werden.
Ich möchte mich auf diesem Wege noch einmal bei allen Teilnehmern meiner Sessions und des Workshops bedanken, es war wirklich wieder eine wahnsinnig tolle und spaßige Veranstaltung.
Recent changes in Azure brought some significant changes in autoscaling options for Azure Web Apps (i.e. Azure App Service to be precise as scaling happens on App Service plan level and has effect on all Web Apps running in that App Service plan). This article describes how you can configure basic autoscaling based on CPU load.
- Log in to the Azure portal at http://portal.azure.com
- Navigate to the App Service you would like to autoscale.
- Select Scale out (App Service plan) from the menu
- Click on Enable autoscale. This activates the editor for scaling rules.
- Click on Add a rule. This shows a form where you can create a rule and specify details of the scaling.
For the sake of simplicity, leave all values as they are, i.e.
Metric source: <the App Service plan> (this is the Azure resource, the metric is measured from)
Time aggregation: Average
Metric name: CPU Percentage
Time grain statistic: Average
Operator: Greater than
Threshold: 70
Duration (in minutes): 10
Operation: Increase count by
Instance count: 1
Cool down (minutes): 5
This means: Constantly the average of the CPU load of the last minute is calculated. If the average of this value calculated over 10 minutes is greater than 70% one App Service instance is added to the pool. The system waits at least 5 minutes before the next scaling action takes place.
- Confirm with Add. This adds the scale up rule, i.e. without any further action the App Service plan would only scale up, but never scale down.
- Add another rule. Keep default values for all parameters except the following:
Operator: Less than
Threshold: 40
Operation: Decrease count by
This means: When CPU load average over 10 minutes goes below 40% decrease number of instances by 1.
- Confirm with Add. Notice that the Instance limits are still set to their default values of 1. I.e. without further action the App Service plan wouldn’t scale because these limits set the number of instances are set to the fixed value of 1.
- Change the Instance limits to the following values:
Minimum: 1
Maximum: 5
Default: 2
This means: Always leave at least one instance (even though CPU load might be below 40%), never scale above 5 instances (even though CPU load might be above 70%). If there is a problem with the metrics system (metrics cannot be evaluated) and the number of instances is below 2 then scale up to 2 instances.
The dialog should now look like this:
- Confirm everything with Save.
That’s it. Your autoscale configuration is set now, i.e. the App Service plan autoscales according to the settings you specified above.
Further information
Es gibt eine neue Bibliothek rund um das Thema DevOps. Ihr findet dort alles was ihr braucht, um möglichst schnell von 0 auf DevOps zu kommen. Auf der Seite wird sowohl die strategische Bedeutung von DevOps für die Software-Entwicklung erläutert, als auch die einzelnen Bereiche der Microsoft DevOps-Lösung.
Zur Einstimmung gibt’s hier nochmal die Keynote des Technical Summit 2016 mit Donovan Brown und seiner Definition von DevOps.
Wer eher eine englische Übersichtsseite bevorzugt wird unter Microsoft DevOps Blog fündig.