Wer RavenDB nicht auf seinem eigenen Server betreiben möchte oder einfach wissen möchte wieviel Speicherplatz die eigentlichen Daten benötigen gibt es zwei Möglichkeiten:

Falls es noch einen anderen Weg gibt: Immer her damit – aktuell hab ich nur die beiden Methoden gefunden und sie scheinen mehr oder weniger zu passen.

RavenDB Storage per JSON über die API:

Über die Server-Statistics (http://localhost:8080/admin/stats) bekommt man ein JSON mit dem Eintrag “TotalDatabaseHumaneSize”

RavenDB Speicher direkt auf Dateiebene:

Über das “Data” File innerhalb des Datenbank Ordners sieht man ebenfalls die Größe.

Speicherplatz ist lokal natürlich billig… aber wie sieht es gehosted aus?

Wer RavenDB selbst betreibt der sollte eigentlich keine Probleme mit Festplattenspeicher haben – wir reden hier von einem zweistelligen MB Betrag bei in meinem Beispiel 1500 Dokumenten mit einigen Daten daran – selbst Gigabytes sind heute billig.

Gehosted sieht es bei RavenHQ und CloudBird aktuell so aus (Stand Mai 2013). Diese beiden Hoster sind (glaub ich) aktuell auch die einzigen die RavenDB “in der Cloud” gemanaged anbieten. Der Speicher ist hier schon “teurer”, jedenfalls für Hobby-Entwickler.

RavenHQ

Genauere Informationen gibt es hier.

CloudBird

Genauere Informationen gibt es hier.

Damit sollte man nun in der Lage sein abzuschätzen wieviel “Speicher” man benötigt und kann den entsprechenden Plan auswählen.

Die Powershell ist ein prima Werkzeug und immer mehr System-Tools und Dienste stellen Powershell Module zur Verfügung. Da ich aber nur “am Rande” mit Powershell zutun habe bin ich auf ein nettes Detail gestossen, welches vermutlich bei den erfahreneren Powershell Usern maximal ein müdes Lächeln hervorruft:

Ps-Cmd | Format-List etc.

Um den Text-Output zu formatieren oder um alle Details des Ergebnisses zu sehen gibt es folgende Befehle:

Format-Wide

Format-List

Format-Table

Format-Custom 

Insbesondere das “lange” Dateiennamen bzw. Objekt-Namen irgendwann abgeschnitten werden hatte mich dazu veranlasst nach diesen Methoden zu suchen.

Beispiel:

dir | Format-List Name,LastWriteTime

Ich nehm den einfachen “dir”-Command, wobei man den Output überall über diese Zusätze formatieren kann.

Format-Wide

Format-List

Format-Table

Bei Format-Custom hatte ich spontan kein gutes Beispiel gefunden, vermutlich kann man damit aber nette Sachen machen

Powershell-Anfänger Kurs erstmal wieder beendet.

Nach langer Zeit haben wir mal wieder ein kleines Angebot für euch: Wir sind Medienpartner der Developer Week 2013 und über uns könnt ihr günstiger an Tickets herankommen. Mit dem Code DWX13coi könnt ihr von Sonderkonditionen profitieren (= Ticketpreise werden niedriger & keine bösen Überraschungen).

Die Developer Week (DWX) bündelt vom 24.-27. Juni 2013 in Nürnberg die bekannten Veranstaltungsformate WDC (Web Developer Conference), MDC (Mobile Developer Conference) und DDC (.NET Developer Conference) in einer Woche und an einem Ort. Die Teilnehmer erwarten mehr als 200 Top-Experten vor Ort, fast 40 Thementracks und 250 Sessions zu Web, Mobile und .NET-Entwicklung.

Präsentiert wird die Veranstaltung von den Fachmagazinen dotnetpro und der web & mobile developer der Neuen Mediengesellschaft Ulm.

Zur Anmeldung geht es direkt hier – dort könnt ihr auch über den Code angeben und bekommt einen günstigeren Preis.

Freiticket? Freiticket!

Als kleines Extra gibt es noch ein Freiticket für die komplette Veranstaltung zu gewinnen!

Da einfache Verlosungen immer etwas unlustig sind, probieren wir mal einen anderen Weg: Kommentiert den Facebook-Post auf unserer Facebook Fanseite und schreibt den lustigsten, skurrilsten oder sonderbarsten Checkin-Kommentar den ihr gelesen oder selbst verfasst habt. Der Kommentar mit den höchsten “Likes” gewinnt. Am 31. Mai (Freitag) zum Mittag endet die Aktion.

Windows Authentifizierung ist eine einfache (und naheliegende) Authentifizierungs-Option für “Haus-interne” Webapplikationen.

Setup

Im IIS selbst kann man die Windows Authentifzierung sehr leicht anschalten:

Natürlich kann man dies auch über die web.config steuern:

 <system.web>
  ...
  <authentication mode="Windows"/>
  ...
 </system.web>
 ...

Fehlermeldung “HTTP Error 401.2 – Unauthorized”:

Dies kann (wie fast immer) viele Gründe haben, z.B. weil man nicht die erforderten Rechte hat. Wenn man dies als Fehlerquelle ausschliessen kann, sollte man überprüfen ob überhaupt die Windows Authentifzierung angeschalten ist und ob das Feature in den Windows-Komponenten aktiviert ist:

Providers:

Im Normalfall gibt es zwei Provider: Negotiate und NTLM. Negotiate sagt einfach nur, dass Server und Client sich abstimmen. Allerdings hatte ich bislang zweimal das Problem, dass Server und Client sich auf Kerberos Authentifizierung geeinigt hatten, dies aber aus irgendeinem Grund nicht funktionierte. Als ich nur noch NTLM nutze ging es.

Troubleshooting Tipps:

Ruft man die Seite direkt auf dem Server über den IE auf, wird immer NTLM genommen (und nicht Kerberos).

Alle nicht IE-Browser versuchen sich über NTLM zu authentifizieren. Zum Testen nehm ich sowohl IE als auch Chrome.

Wer im IE eine automatische Anmeldung möchte, d.h. kein Login Prompt, muss die URL in der Intranet-Zone eintragen (oder die Policies verändern)

Windows Authentifizierung ist eine nette Sache – wenn sie funktioniert

Wo APIs im Spiel sind, ist das JSON Format nicht weit. Da ich immer mal wieder zwei Tools benutze, möchte ich diese hier auch mal kurz würdigen.

JSON Viewer

Wer nur den JSON-Text vor sich hat sieht meist die Struktur nicht. Über JSON Viewer kann man sich recht einfach einen Überblick verschaffen: [URL]

JSON2CSharp

Der Titel sagt schon alles: Mit dem Tool kann man sehr einfach JSON in CSharp Code umwandeln. Dies ist dann ziemlich nützlich wenn man z.B. das Gegenstück zur einer JSON-API baut und mit den Resultaten “arbeiten” möchte: [URL]

Durch meine Tätigkeit bei der  OneOffixx AG habe ich recht tiefe Einblicke in die Erstellung von Microsoft Office Dokumente mit .NET bekommen. Da das Problem “Office Dokumente per Code” zu erstellen recht verbreitet ist, schreib ich mal Empfehlungen für die ersten Schritte.

Must Have Tools

Ganz klar sollte man das Office in der jeweiligen Version installiert haben – zum Teil unterscheiden sich die Versionen. Für die meisten Fälle sollte es aber klappen, aber lieber nachprüfen bevor der Kunde sich ärgert .
Wichtiger Hinweis: OpenXML benötigt keine Office Installation. Man kann es bedenkenlos z.B. auf einem Webserver nutzen.

Das OpenXML SDK und das OpenXML SDK Productivity Tool for Microsoft Office. Die aktuellste Version ist die 2.5, welches es hier zum Download gibt – wobei man erst das SDK installieren muss und danach die Tools.

Visual Studio wäre natürlich von Vorteil

Ein guten XML Viewer – Notepad ist leicht nervig. Ich nutze Nodepad++ mit den XML Tools Plugin.

OpenXML ist… kompliziert…

Microsofts XML Spezifikation liegt “gefühlt” sehr nah an der Ur-Implementierung im binären Format – es finden sich daher oft sehr interessante Konstrukte in XML Form wieder.

Das Bild stammt zudem von dieser Seite, welche den Standard “nicht so gern hat” – ohne Wertung von meiner Seite

Da der Umgang in komplexeren Dokumenten nicht so einfach wie hier dargestellt ist empfehle ich jeden folgendes Vorgehen…

Vorgehen: Wunsch-Dokument erstellen – OpenXML Productivity Tool – Reflect Code FTW!

Am einfachsten ist es sich sein Wunsch-Dokument in Word/Powerpoint/Excel zu erstellen (bzw. ein bestehendes in das Tool laden) und über das Productivity Tool sich den Code dazu anzeigen lassen.

Der erzeugte Code ist zwar “kryptisch”, funktioniert aber (im Sinne von Copy/Paste in ein neues Projekt) und nun kann man sich Stück für Stück den Code refactoren. Das Tool kann neben “Reflect Code” auch ein Diff zwischen zwei Open XML Dateien erzeugen, zum Debugging äusserst hilfreich!

Andere Herangehensweise: Das Zip mal öffnen…

Um die Struktur genauer zu verstehen ist es auch von Vorteil die docx/pptx/xlsx Datei in .zip umzubenennen und die einzelnen XML Files genauer anzuschauen:

Wo liegt denn die DocumentFormat.OpenXml.dll und was brauch ich noch?

Die .NET Assembly wird mit dem SDK installiert:

C:\Program Files (x86)\Open XML SDK\V2.5\lib

Das Open XML SDK setzt auf den Namespace System.IO.Packaging auf, daher benötigt man noch die WindowsBase.dll.

Das wäre es eigentlich auch schon…

Durchbeissen und Frust-Resistenzen aufbauen

Happy Coding!

Zwar legt das Metro Design viel Wert auf Typografie – jedoch sind auch Icons sehr wichtig. Wer das Windows Phone SDK installiert hat, bekommt 36 Icons mitgeliefert. Diese sind unter diesem Pfad zu finden:

C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v8.0\Icons

Viele Icons, welche man von den eingebauten Anwendungen kennt, sind allerdings nicht enthalten. Pedro Lamas hat 99 weitere Icons aus von den App-Resources extrahiert und bietet sie hier zum Download an.

Ich hatte mich recht lange mti dem Thema ADFS 2.0 (“Active Directory Federation Services”) beschäftigt und da kam die recht einfache Frage auf: Wie stelle ich fest ob die Verbindung zwischen ADFS und AD “funktioniert”? Hier eine simple Variante es zu testen…

Was ist ein ADFS überhaupt?

Wenn man über AD-Grenzen hinweg “Vertrauensstellungen” braucht, dann nimmt man in der Microsoft Welt die Active Directory Services. Diese vermitteln zwischen Sender (eigenes Unternehmens-AD) und Empfänger (ein anderes AD oder ein grosse “Zentrale”, wie z.B. der Windows Azure Access Control Service) und stellt für den angemeldeten Benutzer Claims aus. Vermutlich ist das nicht 100% ganz exakt und meine Begrifflichkeiten passen auch nicht 100%, aber im Grunde versteh ich das System so

Wie teste ich nun die Funktionalität des ADFS?

Der ADFS nutzt den IIS um die eigentlichen Endpunkte zu hosten. Es gibt auch eine simple Login-Seite, die jeder Nutzen kann:

https://{ADFS-FQDN}/adfs/ls/IdpInitiatedSignon.aspx

Danach erscheint eine simple “Login-Seite” – nach dem Klick auf “Anmelden” sollte sowas zu sehen sein:

Wenn diese Seite ohne es Nutzernamen / Passworts kam funktioniert die Anmeldung über Kerberos – andernfalls wird NTLM genommen.

Falls alles schief läuft (oder die Konfigurationsdatenbank “kaputt” ist) sieht man solch eine Fehlermeldung:

Was man damit testen kann:

Damit stellt man erstmal nur sicher, dass die Konfiguration/Verbindung zwischen ADFS und eigenen AD “funktioniert” – mehr nicht – aber auch hier kann es schon zu Problemen kommen. Ob nun die “Gegenstelle” funktioniert ist ein anderes Problem.

Ich habe ein ADFS Proxy im Einsatz – was nun?

Im Grunde prüft man erst den “Haupt”-ADFS und später schaut man von einer anderen Maschine, welche nur den Proxy sieht, ob dieser Login klappt. Danach geht es weiter bis hin zum “Kunden”.

In diesem Blogpost ist das Vorgehen näher beschrieben (und ich glaub von diesem hab ich auch den Tipp) : How to test if ADFS is functioning

Troubleshooting

Ich hatte ein paar Probleme mit dem ADFS, welche leider noch nicht vollständig gelöst wurden, jedoch hab ich ein paar Links noch gefunden, welche vielleicht jemanden weiterhelfen:

AD FS 2.0: How to Change the Local Authentication Type

AD FS 2.0: How to Configure the SPN (servicePrincipalName) for the Service Account

Heute bin ich auf ein kleines Problem gestossen: Meine Windows Phone App wollte meinen ausgefählten Font nicht anzeigen – auch einige andere gingen nicht.

Obwohl der Visual Studio Designer die Fonts durchaus anzeigt:

Im Emulator ist davon allerdings nichts mehr zu sehen:

Grund hierfür:

Windows Phone enthält nicht alle Schriftarten wie Windows

D.h. bei der Wahl der Schriftarten sollte man darauf achten, dass sie mit Windows Phone kompatibel sind.

Ich hab zwei Seiten gefunden welche verfügbare Fonts auflisten:

Fonts in Silverlight for Windows Phone

Text and fonts for Windows Phone

PS: Comic Sans ist natürlich verfügbar

Wer WebDeploy auf einem Server Betriebssystem nutzt, der geht im Standardfall über den Port 8172. Aber wofür ist der Port eigentlich da und wie kann ich den ändern?

Hinweis: Für die WebDeploy Installieren empfehle ich diesen und diesen Blogpost. 

Port 8172 = IIS Management Service Default Port

Der Port 8172 ist der Standard-Port des IIS Management Services, welchen es auch nur für Server Betriebssysteme gibt (also keine Sorge wenn ihr ihn im IIS unter Windows 7/8 nicht findet).

Über die GUI (und sicher auch über die Powershell) kann man diese Einstellungen ändern wenn der Dienst gerade nicht läuft.

Das war es eigentlich schon.

Hintergrund-Info: WebDeploy & Web Management Service Handler

Weiter oben habe ich schon geschrieben das der Web Management Service nur auf Server Betriebssystemen zum Einsatz kommt – wie funktioniert dann aber WebDeploy auf meinem lokalen IIS?

Auf dem Blog von Richard Szalay habe ich eine tolle Zusammenfassung über WebDeploys “Deployment Modelle” gefunden:

1. Web Management Service (WMSvc) handler
   This is the preferred method for IIS 7+ / Windows Server 2008+ and supports non-administrator deployments. It piggybacks on the WMSvc (ie. remote IIS management) by registering a custom handler (http://server:8172/msdeploy.axd). Making use of WMSvc also means that this method is not available to Windows client versions (including 7 and 8), as WMSvc is not available on those platforms. At the command line, this method is specified on the dest provider as “,computerName=http://server:8172/msdeploy.axd?site=iis-site-name”
   
2. Web Deploy Agent Service
   This is the only choice for IIS6 / Server 2003, is not installed by default, and requires the deployment user to be an administrator. At the comment line, this method is specified as “,computerName=server“
3. “On Demand” Agent Service (temp agent)
   This choice installs the agent service temporarily for a single deployment. Useful when you have administrator credentials but aren’t able to remotely install the handler or agent service. At the command line, this method is specified as“,computerName=server,tempAgent=true”

WebDeploy auf dem Server selbst funktioniert immer im Zusammenspiel mit dem Web Management Service – ändert man den Port des WMSvc Handlers, ändert man den Port für WebDeploy.

Hintergrund-Info: Wo werden diese Einstellungen eigentlich gespeichert?

Ein paar dieser Settings (wie z.B. den Port) habe ich in der Registry wiedergefunden:

Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WebManagement\Server

Andere Settings stehen in der administration.config (unter C:\Windows\System32\inetsrv\config)

TL;DR:

Auf einem Server im IIS Manager auf Management Service gehen und da den Port ändern. WebDeploy nutzt den Management Service für das Deployment – wobei der Management Service auch zur “Remote-Verwaltung” dient.

IIS Administration ist nicht einfach – zwar gibt es Powershell Scripts, aber intuitiv geht anders. Über einen Tweet von Scott Hanselman bin ich auf das Projekt von Jonas Hovgaard gestossen: Servant.

Achtung: Das Tool befindet sich noch in der Anfangsphase – alles auf eigene Gefahr, aber he… es sieht schick aus, also

Installation

Nach dem Download es Zips gibt es zwei Wege Servant zu nutzen:

Direkt ausführen über die Servant.Service.exe oder die Batch Datei aufrufen (die auch wieder nur die .exe mit einem Parameter aufruft) – über die Batch Datei wird ein Dienst “Servant for IIS” erstellt.

Nach dem Starten: <3

Nachdem man ein Admin-Kennwort festgelegt hat (aktuell ist dies die einzige Möglichkeit) sieht man direkt seine IIS Konfiguration:

Schaut gut aus…

Hintergrund Infos

Wer Servant direkt installiert, installiert im Hintergrund einen Dienst – die Management Seite selbst ist nicht im IIS gehostet.

Servant benutzt zudem NancyFX und ServiceStack (und bestimmt weitere nette Sachen )

Wer mehr Wissen will der kann sich via Twitter oder Facebook connecten (oder direkt auf der Website).

Ausblick

Jonas hat auf Jabbr einen Servant Raum erstellt und ein paar Ausblicke gegeben. Denkbar ist dass Servant eine REST API für das Management von IIS-Servern zur Verfügung stellt und auch Git-Deployment ermöglichen soll (ähnlich wie Microsoft es mit Projekt Kudu für Azure gemacht hat).

Diese Features werden zurzeit von CSOM unterstützt:

Um mit dem Sharepoint zu kommunizieren stehen dem Entwickler REST/OData, Javascript Bibliothek und C# Schnittstellen bereit.

Als Javascript Entwickler hat man also 2 Möglichkeiten um Daten mit dem Sharepoint auszutauschen, entweder man nutzt die Javascript Bibliothek oder man benutzt die REST Schnittstelle per jQuery. Ich persönlich, finde die bereitgestellte Javascript Bibliothek nicht gelungen. Was im .net Code sinnvoll ist, wirkt im JS Code eigenartig unhandlich. Die breitgestellten Bibliotheken wurden mit Hinblick auf größtmögliche Konsistenz entworfen. Die Schnittstellen sollten sich in allen Welten möglichst gleich anfühlen. Dieser Ansatz ist durchaus nachvollziehbar aber zum Glück haben wir die Wahl J

CSOM JavaScript Library

var context = SP.ClientContext.get_current();
site = context.get_web();
context.load(site);
context.executeQueryAsync(
	function(){console.log(site.get_title())},
	function(){console.log(‘error’)},
);

Die Idee hinter dieser Schnittstelle ist, dass man mit „context.get_web();“ sagt welchen Daten man laden möchte. Mit „context.load(site)“ fügt man es dem Request hinzu und „context.executeQueryAsync“ führt den Request dann schließlich aus. Wenn man sich die Objekte im Debugger seines lieblings Browsers anschaut, bekommt man oft einen Berg unleserlicher Variablennamen angezeigt – super für Menschen die ihren Spaß an Rätseln haben, für alle anderen unter Umständen eher anstrengend. Es gibt auch eine nicht minifizierte Variante der Bibliothek die diesen Nachteil beheben könnte, irgendwo im Netz, so sagte man.

CSOM REST Api mit JQuery

var requestUri = _spPageContextInfo.webAbsoluteUrl + "/_api/web/?$select=Title";
$.ajax({
	url:requestUri,
	beforeSend: function (request)
            {
                request.setRequestHeader("Accept", "application/json; odata=verbose");
            },
	success:function(data){console.log(data.d.Title)}
});

Das Schöne an dieser Variante ist, dass man die Urls zum Debuggen auch einfach mit dem Browser aufrufen kann und dann das Ganze als lesbares XML angezeigt bekommt. Wichtig bei dieser Variante ist, dass man den accept Header auf “application/json; odata=verbose” setzt. Ich hatte es zuerst mit jQuery’s getJSON versucht und mich über die „406 request is not acceptable“ Fehlermeldung gewundert. Das liegt daran, dass jQuery den accept Header “application/json“ setzt und sich der Sharepoint nicht so richtig wohl fühlt, wenn man ihm das „odata=verbose“ vorenthält.

Das Ergebnis ist in beiden Fällen das Gleiche. Für was man sich letztendlich entscheidet ist also Geschmacksache.

Wer normalerweise Software entwickelt die auf großen Servern oder auf richtigen PC-Clients läuft der schnell Gefahr bei der Entwicklung für mobile Endgeräte recht schnell eine “OutOfMemoryException” zu sehen. Jedenfalls ging es mir so

Szenario: Viele Bilder laden = ಠ_ಠ

Wer in Windows Phone viele Bilder (mit hoher Auflösung) als Bitmap in den Speicher laden oder anzeigen möchte, sollte sich im klaren sein, dass das schief gehen kann.

Was sind denn “viele”?

Ich hatte bereits das Problem das ich ab 8-10 Bilder ein Problem hatte – hierbei hab ich einfach auf Bilder auf dem Phone zugegriffen (ohne die Bilder zu skalieren!) und die Kamera des Nokias schiesst recht hochauflösende Bilder.

Ergebnis:

Das Memory-Limit bei Windows Phone Apps

Ab 150MB sollte man vorsichtig sein. Mehr dazu in der MSDN

URIs anstatt Bitmaps

Wer eine Foto-Anwendung baut sollte im ViewModel bzw. in der Applikationslogik eher mit URIs (= Pfad zum eigentlichen Bild) arbeiten anstatt direkt mit großen Bitmaps. Um das Bild in der UI anzuzeigen habe ich mir einen Converter geschrieben:

Im XAML:

<Image Width="108" Height="108" Stretch="UniformToFill" Source="{Binding PhotoSource, Converter={StaticResource UriPathToThumbnailConverter}}" />

Converter:

public class UriPathToThumbnailConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if(ViewModelBase.IsInDesignModeStatic)
            {
                return value;
            }

            IsolatedStorageFile ISF = IsolatedStorageFile.GetUserStoreForApplication();

            Uri path = value as Uri;

            using (var sourceFile = ISF.OpenFile(path.LocalPath, FileMode.Open, FileAccess.Read))
            {
                BitmapImage bm = new BitmapImage();
                bm.DecodePixelWidth = 220;
                bm.SetSource(sourceFile);
                return bm;
            }
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

Wichtig ist auch hier “DecodePixelWidth” bzw. “DecodePixelHeight” zu setzen – damit kann wird das Bild auf eine bestimmte größe festgelegt und ich hatte die Memory Probleme in den Griff bekommen.

Profiler für Windows Phone Apps

Im Visual Studio selbst ist auch ein Profiler für Windows Phone Apps enthalten:

Danach öffnet sich noch ein weiteres Menü:

Danach startet die Anwendung und bis man die “Session” beendet werden Daten aufgenommen.

Ergebnis des Profilers:

Ein Graph!

Damit sollte man den Speicherverbrauch im Auge behalten können und optimieren.

Weitere Tipps für Bilder & Windows Phone

Dieser Blogpost enthält noch einige weitere Hinweise – auch wenn er mit Windows Phone 7 betitelt ist, scheint es nach wie vor zuzutreffen. Weitere Tipps findet man auch in der MSDN.

Fazit:

App-Entwickler sollten ein wesentlich strengeren Blick auf die Performance- und Memory-Werte der Anwendung schauen da man sehr leicht das System ausreizen kann. Mit den Hinweisen konnte ich jedenfalls meine Memory Probleme lösen

Buzzwords?! Nein – am Ende passt es doch alles zusammen und ist sogar ziemlich cool. Ich hatte bereits das kostenlose Buch über Claim-based Authentifizierung empfohlen – heute geht es um folgendes Szenario:

Wie kann ich meine ASP.NET Seite auf “einfachste” und ohne grosse Zauberei mit dem Access Control Service verbinden? 

Achtung: Microsoft selbst empfiehlt eher ein grösseres Tooling (im Falle von ASP.NET ist das auch echt schick!), was am Ende die web.config unglaublich aufbläht – zudem hatte ich Schwierigkeiten weil die Handler da “zu viel automatisch” machen.
Die Idee hab ich von diesem Post – und funktioniert bislang Zudem lernt man einiges über die Protokolle dahinter.

Kurzfassung: Was ist der Access Control Service (ACS)

Dieser Azure Service darf man sich wie einen zentralen Verteiler für Authentifizierung vorstellen – man kann verschiedene Authentifizierungsanbieter einklicken und ACS übernimmt dabei die Transformation der Tokens in das was wir benötigen. Eure Anwendung soll ADFS (für Business Kunden), Microsoft Account und Facebook unterstützen? Puh… Der Access Control Service kann hierfür interessant sein! 

Mehr Informationen gibt es hier.

Was ist ein Microsoft Account?

Der Microsoft Account war früher bekannt unter dem Namen Windows Live ID. Diese Bezeichnung sieht man immer wieder, aber eigentlich find ich Microsoft Account vom Naming her besser, daher bleiben wir dabei.

Was ist ein JSON Web Token (JWT)?

Über dieses Format werden am Ende die Claims ausgetauscht. Mehr dazu hier.

Vorbereitung: ACS Namespace

Für das Sample benötigen wir ein ACS Namespace, der im Management-Portal eingerichtet werden kann:

Dort legen wir eine “Relying party application” an – dies repräsentiert unsere Claim-based Anwendung:

(aktuell ist die ACS-Verwaltung immer noch im alten look)

Wichtigster Punkte:

- der Realm

- die Return URL

- das Token Format auf JWT umstellen

- Bei Identity Provider “Windows Live ID” auswählen

- Eine Rule Group anlegen (bei mir ist die schon angelegt)

In der Rule Group sicher stellen, dass auch die Claims weitergegeben werden:

Welche Daten bekomme ich durch die Windows Live ID/Microsoft Account?

Fast keine – bis auf einen kryptischen Key im “nameidentifier”-Claim. D.h. man kommt aktuell an absolut 0 Profil Informationen und man muss den Nutzer diese Geschichte manuell nochmal eintragen lassen. Der Key ist auch pro ACS Namespace eindeutig – die Realms spielen (anders als es vielleicht in der MSDN steht) keine Rolle für den “nameidentifier”

Schauen wir uns das Sample an:

Standard-MVC App – kein Azure Auth Toolkit etc. in Verwendung! Nur der Link hinter “Log in” verweisst auf einen Controller den ich gleich zeige.

Bei “Log in” werde ich sofort auf die Microsoft Login Seite umgeleitet.

Kleiner Hinweis: Die Parameter in der URL wie “wa” oder “wtrealm” stammen aus dem WS-Federation Spec.

Oben in der Adresse sieht man auch unseren Access Control Service wieder (bzw. den ich angelegt hab). Danach wird man direkt auf die Startseite umgeleitet und ist unter einem sehr seltsamen Namen “angemeldet”

Was passiert im Hintergrund?

Hier der komplette Code meines Authentifzierungs-Controllers:

/// <summary>
    /// Everything based on WS-Federation: http://docs.oasis-open.org/wsfed/federation/v1.2/os/ws-federation-1.2-spec-os.html
    /// </summary>
    public class AuthController : Controller
    {
        public ActionResult Index()
        {
            // Microsoft Account Login

            // 2 Option - use hosted Loginpage from ACS or host your own...

            // based on Azure ACS Portal - Login Page Integration - Option 1:
            // Problem: wfresh=0 not supported - logout is :/
            return new RedirectResult("https://codeinside.accesscontrol.windows.net:443/v2/wsfederation?wa=wsignin1.0&wtrealm=urn:sample:wifless");

            // Option 2: Use the link from the JSON - but needed more coding.
            // But wfresh=0 is supported!
            //return new RedirectResult("https://login.live.com/login.srf?wa=wsignin1.0&wtrealm=https%3a%2f%2faccesscontrol.windows.net%2f&wreply=https%3a%2f%2fcodeinside.accesscontrol.windows.net%2fv2%2fwsfederation&wp=MBI_FED_SSL&wctx=cHI9d3NmZWRlcmF0aW9uJnJtPXVybiUzYXNhbXBsZSUzYXdpZmxlc3Mmcnk9aHR0cCUzYSUyZiUyZmxvY2FsaG9zdCUzYTg4MTclMmZBdXRoJTJmQ2FsbGJhY2s1&wfresh=0");
        }

        [ValidateInput(false)]
        public ActionResult Callback(string wresult, string wa)
        {
            if (wa == "wsignin1.0")
            {
                var wrappedToken = XDocument.Parse(wresult);
                var binaryToken = wrappedToken.Root.Descendants("{http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd}BinarySecurityToken").First();
                var tokenBytes = Convert.FromBase64String(binaryToken.Value);
                var token = Encoding.UTF8.GetString(tokenBytes);

                var result = AcsAuthorizationTokenValidator.RetrieveClaims(token,
                                                                          "https://codeinside.accesscontrol.windows.net/",
                                                                          new List<string>() { "urn:sample:wifless" });

                var name = result.Claims.Single(x => x.Type == ClaimTypes.NameIdentifier);

                FormsAuthentication.SetAuthCookie(name.Value, false);
            }
            else if (wa == "wsignoutcleanup1.0")
            {
                FormsAuthentication.SignOut();
            }
            return RedirectToAction("Index", "Home");
        }

        public ActionResult Logout()
        {
            FormsAuthentication.SignOut();

            return RedirectToAction("Index", "Home");
        }

    }

Über Auth/Index werd ich direkt zum ACS Login bzw. direkt weiter zum Microsoft Login umgeleitet. Die Links zu dieser Seite findet man in seinem ACS-Namespace unter “Application integration” – in meinem Fall nehm ich die Option 1.

Wenn ich mehrere Identity Provider (z.B. Facebook oder Google) ebenfalls auf das Sample zuschalten (was wirklich so einfach geht wie es klingt), dann würde eine etwas spartanische Login-Seite mit einer Auswahl den User begrüssen.

Der Nachteil der Variante 1:

- Sehr spartanisches UI bei mehreren Identity Providern

- Den Login erzwingen ist gar nicht so einfach. Wenn man irgendwie mit irgendeinem Microsoft Account eingeloggt ist, sieht der Nutzer noch nichtmal den Account. Da man selbst auch keinen Zugriff auf den Microsoft Account Namen hat ist es schwer dem User zu vermitteln mit welchem Account er überhaupt gerade arbeitet.

- Logout ist auch schwieriger – aber ich zeig gleich eine Variante wie es gehen könnte (die ich jetzt nicht umgesetzt hab)

Das Gute an der Variante: Es ist ein sehr simpler Link mit einem Callback…

Noch zur Variante 2:

Dort wird ein Link zu einem JSON angeboten was man recht einfach auswerten kann – mit allen Identity Providern und den richtigen Login-URLs sowie der Logout URL.

Bei dieser LoginUrl (die direkt auf login.live etc. zeigt) wird auch der Parameter “wfresh=0” unterstützt – d.h. der Nutzer muss sich explizit vorher anmelden – was schon wesentlich besser ist.

Zum Callback:

Nachdem die Authentifizierung durch ist schickt der Access Control Service die Antwort zum eingetragenen Callback URL – darin enthalten ist ein XML:

<t:RequestSecurityTokenResponse xmlns:t="http://schemas.xmlsoap.org/ws/2005/02/trust">
	<t:Lifetime>
		<wsu:Created xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">2013-04-08T23:49:21.754Z</wsu:Created>
		<wsu:Expires xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">2013-04-08T23:59:21.754Z</wsu:Expires>
	</t:Lifetime>
	<wsp:AppliesTo xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
		<EndpointReference xmlns="http://www.w3.org/2005/08/addressing">
			<Address>urn:sample:wifless</Address>
		</EndpointReference>
	</wsp:AppliesTo>
	<t:RequestedSecurityToken>
		<wsse:BinarySecurityToken wsu:Id="_d3b3e3f6-4bd2-424c-89e9-ebbe662c1305-E64ACB699C73604D58CEA265FE69ECA9" ValueType="urn:ietf:params:oauth:token-type:jwt" EncodingType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">ZXlKMGVYQWlPaUpLVjFRaUxDSmhiR2NpT2lKU1V6STFOaUlzSW5nMWRDSTZJamRUZDFaRmMyNHpVbW93YW5WblNWUjBWRlp4WjJwQ1VVWlJVU0o5LmV5SmhkV1FpT2lKMWNtNDZjMkZ0Y0d4bE9uZHBabXhsYzNNaUxDSnBjM01pT2lKb2RIUndjem92TDJOdlpHVnBibk5wWkdVdVlXTmpaWE56WTI5dWRISnZiQzUzYVc1a2IzZHpMbTVsZEM4aUxDSnVZbVlpT2pFek5qVTBOalE1TmpFc0ltVjRjQ0k2TVRNMk5UUTJOVFUyTVN3aWJtRnRaV2xrSWpvaVMwMVpOR3A1ZUdGSFRWWllZbkl3V2xsRE9DOXJlUzlFTjJabWNXRTBZM1Z0U3pKQ1dFNWxWRUZIV1QwaUxDSnBaR1Z1ZEdsMGVYQnliM1pwWkdWeUlqb2lkWEpwT2xkcGJtUnZkM05NYVhabFNVUWlmUS5VeDFsa0hDaDdBYl85d2lQN1BnR20zNjR4T2tsOHBHUEhNSEF2ZVJSMEVGRTR2VHRybV9wbmF3ajR0STVQZlVFOXB1d1JYNDQzOWRhSkQ4MzM4SG5yOVI1VktmZ3JIYnRuTlM2UVJoeGNIUDREZjBINVFQcFZ2Tm9VU1lJa2ZLWTVFUXE5ei1JVEpiNVZhWEZscF81OENUaDJtMkVYYkIwR3pRLV9BQlF3MWIxZEd1dHV5VHVfdEhWWUdPek9iTDdac0l1dHJXQTdjOEtJYUpoT21NVzNxNEp4RVBLNllnTURERWxkcmR6OFRTVTFZVE8xY3ZqMGZZVHh3d0t3MVlFQmlEamJSLUVxN1FKQzZDZWRsZjJmaDRDbkNBQlFTZzlhbmRVSDZSeTBqU3ctX2tZaHBZOTdkdkpRRDh4eDY2eVMxQmZBNXViQlVMbXF6eWh3U2NYaXc=</wsse:BinarySecurityToken>
	</t:RequestedSecurityToken>
	<t:TokenType>urn:ietf:params:oauth:token-type:jwt</t:TokenType>
	<t:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</t:RequestType>
	<t:KeyType>http://schemas.xmlsoap.org/ws/2005/05/identity/NoProofKey</t:KeyType>
</t:RequestSecurityTokenResponse>

Interessant hier ist der “BinarySecurityToken”, wenn wir diesen base64 kodierten String umwandeln bekommen wird dies:

eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsIng1dCI6IjdTd1ZFc24zUmowanVnSVR0VFZxZ2pCUUZRUSJ9.eyJhdWQiOiJ1cm46c2FtcGxlOndpZmxlc3MiLCJpc3MiOiJodHRwczovL2NvZGVpbnNpZGUuYWNjZXNzY29udHJvbC53aW5kb3dzLm5ldC8iLCJuYmYiOjEzNjU0NjQ5NjEsImV4cCI6MTM2NTQ2NTU2MSwibmFtZWlkIjoiS01ZNGp5eGFHTVZYYnIwWllDOC9reS9EN2ZmcWE0Y3VtSzJCWE5lVEFHWT0iLCJpZGVudGl0eXByb3ZpZGVyIjoidXJpOldpbmRvd3NMaXZlSUQifQ.Ux1lkHCh7Ab_9wiP7PgGm364xOkl8pGPHMHAveRR0EFE4vTtrm_pnawj4tI5PfUE9puwRX4439daJD8338Hnr9R5VKfgrHbtnNS6QRhxcHP4Df0H5QPpVvNoUSYIkfKY5EQq9z-ITJb5VaXFlp_58CTh2m2EXbB0GzQ-_ABQw1b1dGutuyTu_tHVYGOzObL7ZsIutrWA7c8KIaJhOmMW3q4JxEPK6YgMDDEldrdz8TSU1YTO1cvj0fYTxwwKw1YEBiDjbR-Eq7QJC6Cedlf2fh4CnCABQSg9andUH6Ry0jSw-_kYhpY97dvJQD8xx66yS1BfA5ubBULmqzyhwScXiw

Nun kommt ein NuGet Package ins Spiel – der JWTSecurityTokenHandler über dies und etwas Code (basierend auf diesem Microsoft Sample) bekommen wir am Ende die Claims als ClaimsPrincipal:

/// <summary>
    /// Based on this sample: http://code.msdn.microsoft.com/AAL-Native-Application-to-fd648dcf/sourcecode?fileId=62849&pathId=697488104
    /// </summary>
    public class AcsAuthorizationTokenValidator
    {
        /// <summary>
        ///
        /// </summary>
        /// <param name="token">= Token</param>
        /// <param name="allowedAudience">= Azure ACS Namespace</param>
        /// <param name="issuers">= RPs in ACS</param>
        /// <returns></returns>
        public static ClaimsPrincipal RetrieveClaims(string token, string issuer, List<string> allowedAudiences)
        {
            JWTSecurityTokenHandler tokenHandler = new JWTSecurityTokenHandler();

            // Set the expected properties of the JWT token in the TokenValidationParameters
            TokenValidationParameters validationParameters = new TokenValidationParameters()
                                                                 {
                                                                     AllowedAudiences = allowedAudiences,
                                                                     ValidIssuer = issuer,
                                                                     SigningToken = new X509SecurityToken(new X509Certificate2(GetSigningCertificate(issuer + "FederationMetadata/2007-06/FederationMetadata.xml")))
                                                                 };

            return tokenHandler.ValidateToken(token, validationParameters);
        }

        private static byte[] GetSigningCertificate(string metadataAddress)
        {
            if (metadataAddress == null)
            {
                throw new ArgumentNullException(metadataAddress);
            }

            using (XmlReader metadataReader = XmlReader.Create(metadataAddress))
            {
                MetadataSerializer serializer = new MetadataSerializer()
                                                    {
                                                        CertificateValidationMode = X509CertificateValidationMode.None
                                                    };

                EntityDescriptor metadata = serializer.ReadMetadata(metadataReader) as EntityDescriptor;

                if (metadata != null)
                {
                    SecurityTokenServiceDescriptor stsd = metadata.RoleDescriptors.OfType<SecurityTokenServiceDescriptor>().First();

                    if (stsd != null)
                    {
                        X509RawDataKeyIdentifierClause clause = stsd.Keys.First().KeyInfo.OfType<X509RawDataKeyIdentifierClause>().First();

                        if (clause != null)
                        {
                            return clause.GetX509RawData();
                        }
                        throw new Exception("The SecurityTokenServiceDescriptor in the metadata does not contain the Signing Certificate in the <X509Certificate> element");
                    }
                    throw new Exception("The Federation Metadata document does not contain a SecurityTokenServiceDescriptor");
                }
                throw new Exception("Invalid Federation Metadata document");
            }
        }
    }

Ergebnis:

Claims…von Microsoft! Leider keine “menschlich-lesbaren” – aber immerhin gibt es dabei kein Datenschutz Risiko

ACS to the rescue!

Der Access Control Service ist ein recht interessanter Dienst und steht auch in keiner Konkurrenz zum Azure AD – man kann auch Azure AD und Facebook in seiner Anwendung über den ACS nutzen. Stellt es euch als Plugin-fähigen Identitiy Provider vor.

Ich versuch demnächst noch zum neuen “Azure AD” zu schreiben – bis dahin können interssierte ein Blick hier reinwerfen wenn man ACS und Azure Active Directory zusammen nutzen möchte.

Download Sample @ GitHub

Nehmt eine Subdomain, wenn…

- ihr unter einer Domain “verschiedene Dienste” anbieten möchtet, die auch “logische getrennt sind”

- ihr leicht Einfluss auf die Subdomains nehmen könnt

Bsp:

blog.mydomain.com

shop.mydomain.com

forum.mydomain.com

Warum?

Wenn ihr diese Sachen über Subdirectories löst ist es schwieriger diese Dienste auszulagern. Man kann sehr einfach einen CNAME Eintrag machen und so verweisst z.B. blog.mydomain.com auf ein Tumblr Blog und nicht auf meine Maschine. Auch kann man sehr einfach die einzelnen Seiten unter anderen Maschinen laufen lassen (ohne Loadbalancer etc.).

Mit Subdirectories ist diese Sache komplizierter

Nehmt ein Subdirectory, wenn…

- ihr keinen Einfluss auf Subdomains habt (z.B. beim Kunden wird der gesamte Applikations-Stack installiert und ihr wollt den Admin nicht unnötig DNS-Settings einpflegen lassen)

- es Applikations-Interna oder die Seiten zu klein sind um eine eigene WebApp” daraus zu machen (Sowas wie ein Impressum vll.)

Was sagt Google zu dem Thema?

Ein Google Mitarbeiter hat sich dazu auf YouTube geäussert:

Und was sagt Stackoverflow?

Die Antwort find ich ziemlich gut:

Pro’s for subdomains:

• You can isolate configuration (for for example apache) per-domain.
• It will be easier to migrate parts of your application to other machines. Sub-directories won’t really give you this flexibility.
• Instead of having to use a $baseUri variable in every html template, you can just assume the root of the app is always /.

Cons:

• It will be much more annoying to quickly setup staging or temporary development environments. For every ‘app’ you will now need DNS of hosts-file entries and webserver configuration. With subdirectories you could drop the app in a directory, and go!
• If you do ever have the requirement to deploy your application on a different system where using / is because of some odd policy not possible, some rewriting might be in order.

My advice:

Make sure you can always do both, which will give you the best of both worlds. Every part of your app should have a configurable base uri that is always respected. As long as you make sure you can always go both ways, then who cares what you do? it’s just a url and it can always be changed.

Aber du nutzt selber code-inside.de/blog?

Ja – der Blog ist schon einige Jahre alt und damals wusste ich es nicht besser. Problematisch bei einer Änderung jetzt wäre das die alten Links trotzdem noch funktionieren müssen und ich nicht genau weiss wie Google darauf reagiert.

Daher vorher Gedanken machen

Das Musik- und Filmindustrie keine Fans des schnellen und weitestgehend anonymen Datenaustauschs über das Internet sind, ist inzwischen hinlänglich bekannt. Die einschlägige Presse berichtet unerlässlich von Klagewellen gegen Internetnutzer, die sich des verteufelten Filesharings schuldig gemacht haben. Fest steht, die rechtliche Handhabe zum Thema IP Recht im Internet steckt momentan noch in den Kinderschuhen und die Liste der Grauzonen und Schlupflöcher ist lang.

Eine Idee der belgischen Künstlervereinigung SABAM sollte diese Problematik nun ein für allemal lösen. In einer Reihe von Gerichtsverfahren versuchte das Unternehmen Internet Access Provider und Host Provider dazu zu verpflichten, allgemeine Sperren in ihr System einzufügen, die sämtliche Kommunikation ihrer User auf urheberrechtlich fragwürdige Inhalte filtern sollte. Das endgültige Ende der Anonymität im Internet?

SABAM vs. Scarlet

Alles begann damit, dass mehrere auffällig gewordene IP Adressen zu Kundenanschlüssen des niederländischen Internetanbieters Scarlet zurückverfolgt werden konnten. SABAM strebte daraufhin ein Gerichtsverfahren an, wonach Scarlet dazu verurteilt werden sollte, ein generelles Filtersystem zu integrieren, welches sämtliche Kommunikation ihrer Kunden auf mögliche Urheberrechtsverletzungen kontrolliert. Wenn das System eine solche Verletzung nachweißt, müsste Scarlet den Namen sowie die Adresse des betroffenen Kunden an den Rechteinhaber weitergeben, damit dieser unverzüglich ein ordentliches Gerichtsverfahren anstreben könnte. Das alles natürlich auf Kosten des Internetanbieters und damit auf Kosten der Kunden, versteht sich.

Das belgische Gericht sah sich mit dieser Anfrage überfordert und konsultierte daher den Europäischen Gerichtshof mit der Bitte um Klärung. Darf ein nationales Gericht einen so weitreichenden Eingriff in die Privatsphäre unzähliger Benutzer bewilligen?

Der EuGH

Der EuGH sah hier zwei sehr wichtige Grundrechte kollidieren. Zum Einen das Recht auf Schutz des geistigen Eigentums und zum Anderen die Schutz der Privatsphäre. Der EuGH war der Ansicht, dass es dem Internetanbieter sowie seinen Kunden nicht zuzumuten ist, eine von Zeitraum und Umfang unbeschränkte Überprüfung über sich ergehen zu lassen und wies daher das Anliegen SABAM’s ab.

Privatsphäre FTW?

Nicht wirklich. Juristen streiten noch über den Wert dieser Entscheidung. Trotz dass die allmächtige Musikindustrie enorm auf die Bretter geschickt wurde, nehmen es die Juristen sehr genau und begründen, dass die Zurückweisung nur für das speziell angefragte Filterungssystem gelten würde. Ein generelles Nein zum Filtern persönlicher Informationen ist das noch nicht.

Aber so gut wie oder?

Nicht wenn es nach unseren Nachbarn von der anderen Teichseite geht. Datenschutz wird ja bekanntlich nicht gerade großgeschrieben in den USA. Während in UK die Internetanbieter gemeinschaftlich auf die Barrikaden gehen, gründen die amerikanischen Access Provider sogar eine Gemeinschaft mit den Vertretern der Musik- und Filmindustrie. Die Internet Service Provider Gruppe ISP, deren Mitglieder insgesamt 60% des amerikanischen Marktanteiles ausmachen, gründeten gemeinsam mit einigen namen haften Künstlervereinigungen das CCI, Center for Copyright Information. Zusammen wurde ein 4 Jahres Vertrag geschlossen, der vor allem die Einführung eines Copyright Alert Systems zum Inhalt hat. Schlaues Vorgehen der Künstlerverbände? Sie übernehmen die Hälfte der Kosten und der Rest kann ja im Notfall noch 1:1 auf den Kunden umgewälzt werden.

Copyright Alert System oder nix gönnen sie einem!

Das Alert System funktioniert folgender Maßen: Private Unternehmen durchsuchen das Internet nach möglichen Rechtsverletzern. Wird ein solcher aufgespürt, gibt es eine Meldung an den Internetanbieter. Dieser trägt den Verstoß in eine Datenbank ein und sendet dem Kunden gleichzeitig eine Warnung, dass sein Fehlverhalten registriert wurde. Erfolgen einige Warnungen innerhalb eines kurzen Zeitrahmens wird’s ernst. Technische „Bestrafungen“ sind die Folge, wie zum Beispiel die Drosselung der Netzgeschwindigkeit oder wenns ganz hart kommt sogar die Sperrung des Zugangs. Der Kunde bekommt dann die Möglichkeit an einem Besserungsprogramm teilzunehmen, bei dem ihm das unerwünschte Verhalten abtrainiert wird bis er sich wieder als verantwortungsbewusster Internetnutzer bewährt hat.

Zusätzlich werden die Ergebnisse der Inquisition Untersuchung in einem monatlichen Bericht an die Rechteinhaber übersendet, damit diesen der Gang vor Gericht dadurch erleichtert wird, dass sie sich nicht mehr mit dem lästigen Raussuchen von Namen und Adressen rumärgern müssen.

Aber ich wars doch garnicht!

Zu Unrecht beschuldigt? Keine Sorge! Es kann natürlich Beschwerde gegen die Verwarnungen eingelegt werden. Gegen einen geringen Unkostenbeitrag von 35$ kann der Kunde eine zweite Überprüfung beantragen, die dann von einem durch die Vertreter der Künstlerverbände gestelltes Anwälteteam durchgeführt wird.

Fazit: lieber noch schnell ein paar Downloads anschieben

Ein weiterer Schritt in die totale Offenlegung des Internets. Zwar kann man sicherlich argumentieren, dass die Schaffer geistigen Eigentums ein berechtigtes Interesse an der Kohle Wahrung ihrer Rechte haben, aber das ein solches System, einmal eingeführt, sich nicht nur auf Verstöße gegen das Copyright beschränkt dürfte jedem klar sein. Wir haben das Glück, dass Europa sich noch zögerlich bei derartig starken Eingriffen bewegt, aber wie man am Beispiel des britischen Digital Aconomy Acts sieht, kann dieser Trend schneller zu uns überschwappen als uns lieb ist.

Mehr Informationen auf Heise Online oder im Urteilstext des EuGH.

Anmerkung:

Dieser Blog Post wurde von Antje Kilian verfasst, die ansonsten für die Übersetzung der englischen Artikel auf Code Inside verantwortlich ist. Da sie sich momentan in den letzten Zügen ihres Studiums des Internetrechts befindet, dachten wir es wäre eine gute Idee etwas davon auch für den Blog zu nutzen.

Wenn euch der kurze Ausflug in die Juristerei gefallen hat und ihr gerne auch in Zukunft hin und wieder einige technisch relevante, juristische News lesen möchtet oder wenn euch so was überhaupt nicht interessiert, dann hinterlasst uns gerne euer Feedback in den Kommentaren, via Twitter, Facebook oder wo auch immer .

Wer ein Windows Phone sein eigen nennt und .NET Entwickler ist da liegt es nah mal das Windows Phone SDK auszuprobieren. Der Zugriff auf Hardware geht bei “nativen” Anwendungen naturgemäß deutlich einfacher als es selbst bei modernsten Webanwendung im Jahre 2013 möglich wäre, daher hab ich mir die Kamera API unter Windows Phone 8 angeschaut.

In meinem Beispiel möchte ich einfach nur auf die Kamera zugreifen und ein aktuelles Bild aufnehmen und anzeigen – keine Speicherung, keine Videoaufnahme etc.

Variante 1: Camera Capture Task

Die einfachste Möglichkeit ein Bild aufzunehmen ist auf die mitgelieferte Foto-App zu verweisen – dafür gibt es den “Camera Capture Task”.

Vorteil:

Spezielle Bildeinstellungen (ISO…), Kamerablitz, Zoomeinstellungen etc. kann der Nutzer wie gewohnt nutzen und die eigene App benötigt prinzipell keinen direkten Zugriff auf die Kamera. Generell kann man auch davon ausgehen dass die Foto-App sehr gut getestet ist.

Nachteil:

Aufgenommen Bilder werden auch in der “Camera Roll” gespeichert. Hat der Nutzer nun noch eingestellt dass das Bild automatisch zu Skydrive geladen wird, passiert dies ebenfalls. Die eigene Anwendung bekommt eine Kopie des Bildes. Wenn man also nur temporär das Bild benötigt, die Bilddaten nur innerhalb der Anwendung behalten möchte oder eine eigene (vll. bessere) UI bauen möchte, für den ist diese Variante eher nicht geeignet.

Code:

Das Bild selbst zeige ich hinterher im Image Element namens “Result” an. In der Application Bar ist einfach ein Button der zur eigentlichen Camera App weiterleitet.

Der Code ist hierbei denkbar einfach:

CameraCaptureTask definieren und auf Button-Click wird “Show” aufgerufen.

    public partial class MainPage : PhoneApplicationPage
    {
        CameraCaptureTask cameraCaptureTask;

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            cameraCaptureTask = new CameraCaptureTask();
            cameraCaptureTask.Completed += new EventHandler<PhotoResult>(cameraCaptureTask_Completed);
        }

        private void ApplicationBarIconButton_Click(object sender, EventArgs e)
        {
            cameraCaptureTask.Show();
        }

        private void cameraCaptureTask_Completed(object sender, PhotoResult e)
        {
            if(e.TaskResult == TaskResult.OK)
            {
                BitmapImage image = new BitmapImage();
                image.SetSource(e.ChosenPhoto);
                Result.Source = image;
            }
        }

        private void ApplicationBarIconButtonApi_Click(object sender, EventArgs e)
        {
            NavigationService.Navigate(new Uri("/CameraPreview.xaml", UriKind.Relative));
        }
    }

Bei “Show” wird die Camera App gestartet:

Nachdem man das Foto gemacht hat kommt man in das “Complete”-Event. Wobei man aber hier noch prüfen muss ob wirklich ein Bild gemacht wurde oder nicht.

Fertig.

Variante 2: Camera API

Die Camera API ist wesentlich mächtiger – erfordert allerdings auch mehr Aufwand. In meinem Demo zeig ich nur das aktuelle Kamerabild an und kann dann ein Bild knipsen.

Vorteil:

Komplette Kontrolle, die Bilder bleiben in der App (bzw. kann ich es selbst entscheiden) und man kann die wildesten Sachen machen (vermutlich )

Nachteil:

Man muss alles selber machen – Blitz, Kameraeinstellungen (wenn man die braucht), Preview-Bild darstellen etc. und die Anwendung braucht den Zugriff auf die Kamera:

Code:

Der Aufbau ist fast identisch – nur das ein Canvas-Element benutze um darin das Kamerabild anzuzeigen:

        ...<Grid x:Name="ContentPanel" Grid.Row="1">
            <Canvas x:Name="VideoCanvas">
                <Canvas.Background>
                    <VideoBrush x:Name="videoBrush">
                        <VideoBrush.RelativeTransform>
                            <CompositeTransform x:Name="previewTransform"
                            CenterX=".5"
                            CenterY=".5" />
                        </VideoBrush.RelativeTransform>
                    </VideoBrush>
                </Canvas.Background>
            </Canvas>
            <Image Visibility="Collapsed" x:Name="Result" />
        </Grid>...

Etwas sonderbar, aber ich hab es nicht anders hin bekommen: Das Bild über die API ist immer im Panorama-Mode – wenn ich es im Portrait-Mode anzeigen möchte muss ich das Bild drehen, daher die Transform.

    public partial class CameraPreview : PhoneApplicationPage
    {
        private PhotoCamera cam;

        public CameraPreview()
        {
            InitializeComponent();
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            VideoCanvas.Visibility = Visibility.Visible;
            Result.Visibility = Visibility.Collapsed;
            if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
            {
                cam = new PhotoCamera(CameraType.Primary);
                cam.CaptureImageAvailable += new EventHandler<Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureCompleted);
                videoBrush.SetSource(cam);
                previewTransform.Rotation = cam.Orientation;
            }
        }

        private void cam_CaptureCompleted(object sender, ContentReadyEventArgs e)
        {
            this.Dispatcher.BeginInvoke(() =>
                                            {
                                                BitmapImage tempImage = new BitmapImage();
                                                tempImage.SetSource(RotateStream(e.ImageStream, Convert.ToInt32(cam.Orientation)));

                                                Result.Source = tempImage;
                                                Result.Visibility = Visibility.Visible;
                                                VideoCanvas.Visibility = Visibility.Collapsed;
                                            });

        }

        /// <summary>
        /// Picture needs to be rotated - dunno why (because of the ImageRotateTransform... sucks...)
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="angle"></param>
        /// <returns></returns>
        private Stream RotateStream(Stream stream, int angle)
        {
          ...
        }

        protected override void OnNavigatingFrom(System.Windows.Navigation.NavigatingCancelEventArgs e)
        {
            if (cam != null)
            {
                cam.Dispose();

                cam.CaptureImageAvailable -= cam_CaptureCompleted;
            }
        }

        private void like_Click(object sender, EventArgs e)
        {
            cam.CaptureImage();
        }

    }

Beim Navigieren zu dieser Page prüfen wir ob das Phone überhaupt eine Kamera besitzt und initialisieren  das “PhotoCamera” Objekt und setzen einen Event-Handler. Dann muss ich noch das Camerabild richtig drehen (previewTransform.Rotation = cam.Orientation), ansonsten passiert dies:

Irgendwie… schräg – daher haben wir auch die Rotation drin.

Wenn ich auf den Button drücke wird “CaptureImage” aufgerufen und es geht in den Event-Handler rein. Hierbei passiert fast dasselbe wie bei der ersten Variante, aber durch den Trick mit dem drehen ist jetzt auch das Bild gedreht (keine Ahnung warum… vielleicht kann mir ein XAML/Windows Phone Experte einen Tipp geben was ich falsch mache) und muss entweder “optisch” zurückgedreht werden oder wir drehen das gesamte “File”. Da ich auf Byte/Pixtel/Stream-Niveau eine ziemliche Niete bin und ich den Blogpost von Tim Heuer gefunden hab geb ich einfach den Source Code der Methode wieder ohne es zu kommentieren

/// <summary>
        /// Picture needs to be rotated - dunno why (because of the ImageRotateTransform... sucks...)
        /// Origin: http://timheuer.com/blog/archive/2010/09/23/working-with-pictures-in-camera-tasks-in-windows-phone-7-orientation-rotation.aspx
        /// </summary>
        private Stream RotateStream(Stream stream, int angle)
        {
            stream.Position = 0;
            if (angle % 90 != 0 || angle < 0) throw new ArgumentException();
            if (angle % 360 == 0) return stream;

            BitmapImage bitmap = new BitmapImage();
            bitmap.SetSource(stream);
            WriteableBitmap wbSource = new WriteableBitmap(bitmap);

            WriteableBitmap wbTarget = null;
            if (angle % 180 == 0)
            {
                wbTarget = new WriteableBitmap(wbSource.PixelWidth, wbSource.PixelHeight);
            }
            else
            {
                wbTarget = new WriteableBitmap(wbSource.PixelHeight, wbSource.PixelWidth);
            }

            for (int x = 0; x < wbSource.PixelWidth; x++)
            {
                for (int y = 0; y < wbSource.PixelHeight; y++)
                {
                    switch (angle % 360)
                    {
                        case 90:
                            wbTarget.Pixels[(wbSource.PixelHeight - y - 1) + x * wbTarget.PixelWidth] = wbSource.Pixels[x + y * wbSource.PixelWidth];
                            break;
                        case 180:
                            wbTarget.Pixels[(wbSource.PixelWidth - x - 1) + (wbSource.PixelHeight - y - 1) * wbSource.PixelWidth] = wbSource.Pixels[x + y * wbSource.PixelWidth];
                            break;
                        case 270:
                            wbTarget.Pixels[y + (wbSource.PixelWidth - x - 1) * wbTarget.PixelWidth] = wbSource.Pixels[x + y * wbSource.PixelWidth];
                            break;
                    }
                }
            }
            MemoryStream targetStream = new MemoryStream();
            wbTarget.SaveJpeg(targetStream, wbTarget.PixelWidth, wbTarget.PixelHeight, 0, 100);
            return targetStream;
        }

Fazit:

Am “einfachsten” ist es vermutlich den Task zu nehmen – wenn der Anwendungsfall es zulässt. Die Sache mit der Rotation bei der Camera API ist mir etwas schleierhaft – vielleicht mach ich da auch etwas grundsätzlich falsch. Allerdings dauert es auch einige Sekunden bis man Pixel für Pixel den Stream umgebaut hat – daher würde ich das produktiv so nur “ungern” nehmen. Irgendwer eine Idee?

Weiterführende Links und Beispiele:

Auf der Suche nach ein paar guten Beispielen und weiteren Informationen bin ich auf diese Links gestossen, wobei nicht alles geklappt hat – aber vielleicht nützt es dem einen oder anderen etwas:

EXIF Daten auslesen:

Understanding and Reading Exif Data

Reading and displaying EXIF photo data on Windows Phone (konnte ich nur teilweise auslesen…)

Read Exif data from Image on WP 

Camera:

MSDN: Using Cameras in Your Windows Phone Application

How to create a base camera app for Windows Phone

Image Tips for Windows Phone 7

Handling picture orientation in CameraCaptureTask in Windows Phone 7 (Orientation scheint ziemlich “komplex” zu sein – die Exif Variante ging bei mir nicht)

Rotating an Image in Windows Phone

UI:

PhotoHub – Windows Phone 8 XAML LongListSelector Grid Layout sample

Sample Code @ GitHub

Das ASP.NET Team hat auf ihrer Codeplex Seite die Roadmap aktualisiert.

Da die Punkte auf der Roadmap schon recht kurz gehalten sind, lohnt es sich jetzt nicht dies in meinen eigenen Worten wiederzugeben.

Eine Sache die ich persönlich sehr Interessant finde ist jedoch OWIN mit dem Katanaproject – hier mal eine Präsentation über OWIN von mir.

Feedback?

Wer Feedback dem ASP.NET Team geben möchte kann dies über ihre UserVoice Seite machen.

Der Post scheint wie aus einer vergangen Zeit (COM???), aber ich hatte erst kürzlich damit zutun. Ich hab ehrlich gesagt auch sehr wenig Ahnung was COM überhaupt macht, aber ich hatte die Aufgabe in einer bestehenden COM-Register-Function Code zu ändern. Ohne Debugging ist das allerdings etwas heiss.

ComRegisterFunction & ComUnregisterFunction

Vereinfacht: Die Methode die mit den Attributen versehen ist, werden bei der jeweiligen Aktion aufgerufen.

    [ComVisible(true)]
    [Guid("E041712F-D936-4B5B-A3F0-5DB66C4634B0"), ProgId("Foobar")]
    public class Foobar
    {
        [ComRegisterFunction]
        public static void RegisterFunction(Type type)
        {
            Console.WriteLine("Register of Foobar...");
        }

        [ComUnregisterFunction]
        public static void UnregisterFuntion(Type type)
        {
            Console.WriteLine("Unregister of Foobar...");
        }

        public string Buzz()
        {
            return Guid.NewGuid().ToString();
        }

    }

Das Registrieren übernimmt das Tool “RegAsm”

Das Tool befindet sich hier (bzw. im jeweiligen Framework Order):

C:\Windows\Microsoft.NET\Framework\v4.0.30319\regasm.exe

Beim Aufruf des Tools + Angabe der Assembly wird auch unser Code ausgeführt:

Zum Debugging

Zum Debuggen muss man das Projekt nur auf das regasm.exe Tool lenken und den Output als Argument mit angeben:

Damit sollte auch das Debugging funktionieren:

Hoffentlich braucht ihr das nicht allzu oft

Während des Vortrags hat Dennis auch das wunderbare Wort “Architektenporno” eingeworfen als es um die Umsetzung des Konzeptes ging (mit Domain Models, Events, etc.) – was durchaus ein treffender Begriff für unsere Branche, die ständig nach neuen Methoden/Herangehensweisen sucht, ist.

Architektenporno?

Jürgen Gutsch (einer der Organisatoren der .NET User Group) hat den Begriff in einem Tweet recht gut zusammengefasst:

“eigentlich ist alles was man als Architekt geil findet und sofort umsetzen will” (natürlich überspitzt formuliert)

Super, oder? Wer kennt das Gefühl nicht? Aber vorher stellen wir uns natürlich ein paar Fragen…

Neue Herangehensweisen, Frameworks und Methode werden ständig entwickelt und das ist auch super (und halte es da wie Norbert Eder). Wenn mir eine neue Herangehensweise (wie CQRS) über den Weg läuft, dann muss ich mir eine ganze Reihe von Frage stellen:

- Was sind die Vorteile davon?

- Was sind die Nachteile?

- Ist es für mein Team eine grosse Umstellung?

- Gibt es Alternativen?

- Gibt es Erfahrungswerte mit diesem Konzept?

- Kann ich das anderen Stackholdern (Betrieb/Kunde/Projekt-Management) erklären?

- Usw…

Je nachdem um was es sich handelt sind die Fragen natürlich anders, spätestens an dieser Stelle sollte man sich aber intensive Gedanken machen.

Aber der wichtigste Punkt – der vermutlich auch am schwersten zu beantworten ist:

Ist diese Vorgehensweise das richtige für mein Projekt oder ist das nur eine Wunschvorstellung die ich im Kopf habe?

Wer sich über bestimmte neue Vorgehensweisen/ Frameworks/ … informiert, der kommt häufig zu “Experten-Blogs”, welche natürlich auch meist auf einem sehr hohen Niveau das Thema vorstellen – sprich: Es kann fürchterlich kompliziert wirken (“Alles Event-getrieben und asynchron!”) oder sehr radikal (“Testabdeckung von 100%!”).

Leider wird oft der Kontext (Projekt-/Kunden-/Teamstruktur etc.) nicht genannt in dem dieser Experte arbeitet, sodass man selber schwer absehen kann ob das der richtige Weg für mich überhaupt ist.

Kleines Beispiel: Nur weil “Big Data” mit Hadoop ein riesen Thema ist, würde ich jetzt nicht auf die Idee kommen eine kleine Blogsoftware mit diesem System umzusetzen. Auch wenn mein Architektenherz sagt “Klingt cool – machen!”

Stellt euch also ganz kritisch die Frage ob das wirklich passt. Oder ob man es nicht übertreibt. Nicht jeder baut das nächste Facebook.

Aber: Kenne die Werkzeuge die es gibt!

Falls natürlich jemand am nächsten Facebook arbeitet, dann sollte er die Werkzeuge kennen – daher Augen auf und zur gegebenen Zeit das entsprechende Werkzeug einsetzen – ohne direkt fanatisch eine Richtung zu verfolgen, die sich als nicht passend rausstellt.

PS: Danke nochmal an Dennis für den hervorragenden Vortrag!

Checkliste:

- .NET 4.0 installiert?

- aspnet_regiis.exe –i ausgeführt?

- ASP.NET 4.0 in den “web server extensions” aktiviert?

- Wildcard-Mapping (in der Website gibt es irgendwo ein “Configure” Button) auf aspnet_isapi.dll (und “Verify file exists” rausnehmen!)?

Dann lief es zumindest bei mir – mit ASP.NET 4.0, HTTP PUT/DELETE etc. und WCF.

Das “Ende” ist absehbar

Die (meiner Meinung nach) gute Nachricht zuerst: Das .NET 4.0 Framework ist das letzte Framework was für Windows Server 2003 (und Windows XP auf der Clientseite) zur Verfügung steht. Danach muss man wohl oder übel sich ein neueres Betriebssystem installieren.

Wer .NET 4.5 einsetzen möchte, der braucht mindestens Windows Server 2008!

Weitere Hilfe benötigt?

In diesem Post stehen noch ein paar weitere Tipps (hier zum ganzen Foren-Thread).

Microsoft hat ein kostenloses PDF zum Thema Claim-based Identity, Access Control Service und wie man das mit der restlichen Microsoft Welt (Sharepoint, ADFS, Azure) in Zusammenspiel bringt herausgegeben:

Download-Link bzw. MSDN Link

Die Ankündigung hab ich heute auf Vittorio Bertoccis Blog gefunden.

Mehr Informationen?

Wer sich tiefer mit der Matiere auseinander setzen will, sollte definitiv ein Blick auf den restlichen Blog von Vittorio werfen. Interessant zudem ist auch sein Video zum Thema Window Azure Active Directory.

Von SAML zu JWT

Was im PDF nicht enthalten ist, wo sich allerdings ein Trent abzeichnet ist die Abkehr von SAML hin zu JWT. Auch hier empfehle ich wieder Vittorios Blog und die Windows Azure Authentication Library.

Die Informationsvielfalt in dem Gebiet ist nicht besonders hoch und meist kommt man früher oder später auf Vittorios Blog hinaus – vielleicht findet jetzt jemand den Blog von ihm schneller

Wenn der IIS keine Seiten enthält und ich über New-WebSite eine Seite anlegen möchte, dann kommt der Fehler “Index was outside the bounds of the array.”

Fehlerbehebung: ID explizit mitgeben

New-Website -Name Foobar -Id 1 -PhysicalPath C:\inetpub\wwwroot

Auf einem Windows Server 2012 ist dies nicht nötig.

Gefunden habe ich diesen Tipp hier.

Wer die Teambuilds des TFS einsetzt kennt vermutlich das Problem, dass beim Bauen der Solution der TFS automatisch sämtlichen Projekt-“Output” in ein “Binaries” Verzeichnis umlenkt. Die Standard Templates gehen wohl davon aus, dass eine Solution nur einen Output hat, allerdings hab ich dies bislang nur selten so vorgefunden und selbst da find ich die Idee nicht besonders clever.

Build-Process Templates bearbeiten

Damit der TFS die Solution genau so baut wie der normale Visual Studio Client muss man das Build-Process Template bearbeiten. Das Template ist eine .xaml Datei und ist ziemlich gross und auch nicht wirklich übersichtlich.

Lösung

Am einfachsten öffnet ihr die .xaml Datei mit einem Texteditor eurer Wahl und such die Zeile mit “<mtbwa:MSBuild”. An dieser Stelle ruft der Prozess MSBuild auf. In den Standard-Templates ist das genau 2 mal der Fall (Build & Clean).

Löscht im mtbwa:MSBuild Tag das Attribute “OutDir” und der TFS lenkt den Output nicht mehr um.

Alternativ kann man sich im Prozess-Editor auch bis an die Stelle klicken:

Gefunden hab ich diese einfache Variante hier.

Bei einer Umstellung von einer .NET 4.0 Anwendung, welche unter anderem auch die Windows Identity Foundation benutzt, auf .NET 4.5 ist mir aufgefallen dass der Typ “Claim” unter Umständen in drei Namespaces definiert sein kann:

Die 3 Namespaces mit den Claim

Seit .NET 4.5 gibt es Claims in diesen zwei Namenspaces:

System.Security.Claims.Claim

System.IdentityModel.Claims.Claim

Unter umständen (wenn die Referenz Microsoft.IdentityModel.dll noch im Projekt ist) hat man noch dies zur Auswahl:

Microsoft.IdentityModel.Claims

Erkläuterung:

Das Konzept der Claims wurde mit .NET 4.5 direkt ins Framework eingebunden. Daher gibt es auch einige Interfaces, wie z.B. IClaimsIdentity, nicht mehr. Der Artikel “What’s New in Windows Identity Foundation 4.5” listet alles genauer auf. Die Microsoft.IdentityModel.* Namespaces sind damit veraltet.

Wichtigste Parts meiner Meinung nach:

WIF Is Now Part of the .NET Framework

WIF classes are now spread across several assemblies, the main ones being mscorlib, System.IdentityModel, System.IdentityModel.Services, and System.ServiceModel. Likewise, the WIF classes are spread across several namespaces: System.Security.Claims, several System.IdentityModel namespaces, and System.ServiceModel.Security. TheSystem.Security.Claims namespace contains the new ClaimsPrincipal and ClaimsIdentity classes (see below). All principals in .NET now derive from ClaimsPrincipal. For more detailed information about the WIF namespaces and the kinds of classes that they contain, see WIF API Reference. For information about how namespaces map between WIF 3.5 and WIF 4.5, see Namespace Mapping between WIF 3.5 and WIF 4.5.

New Claims Model and Principal Object

Claims are at the very core of the .NET Framework 4.5. The base claim classes (Claim, ClaimsIdentity, ClaimsPrincipal, ClaimTypes, and ClaimValueTypes) all live directly in mscorlib in the System.Security.Claims namespace. It is no longer necessary to use interfaces in order to plug claims into the .NET identity system: WindowsPrincipal, GenericPrincipal, and RolePrincipal now inherit from ClaimsPrincipal; and WindowsIdentity, GenericIdentity, and FormsIdentity now inherit from ClaimsIdentity. In short, every principal class will now serve claims. The WIF 3.5 integration classes and interfaces (WindowsClaimsIdentity, WindowsClaimsPrincipal, IClaimsPrincipal, IClaimsIdentity) have thus been removed. In addition, the ClaimsIdentity class now exposes methods which make it easier to query the identity’s claims collection.

Migration auf Windows Identity Foundation 4.5

Wer eine Anwendung migriert, der schaut am besten in der Mapping Tabelle nach.

Wenn im Code diese Klassen “WindowsClaimsIdentity, WindowsClaimsPrincipal, IClaimsPrincipal,IClaimsIdentity” vorkommen, dann kann man es meist sehr einfach mit ClaimsPrinciple bzw. ClaimsIdentity austauschen.

Ansonsten ist die hauptsächliche Claim-Definition im System.Security.Claims Namespace!

Die Azure Websites sind in der Handhabung sehr simpel, dennoch kann man leicht neue Instanzen dazuschalten. Doch was macht man, wenn ein Fehler passiert?

Azure Website Konfiguration

Unter den Einstellungen der Azure Websites kann man 3 Diagnose-Tools anschalten:

• Detailed Error Logging – Turn on detailed error logging to capture all errors generated by your web site.
• Failed Request Tracing – Turn on failed request tracing to capture information for failed client requests.
• Web Server Logging – Turn on Web Server logging to save web site logs using the W3C extended log file format.

Quelle: How to monitore web sites

Wo werden diese Logs gespeichert?

Die Logs werden in einem Verzeichnis auf der Maschine abgelegt, welches über FTP zugänglich ist. Dafür in das “Dashboard” wechseln und dort nach “FTP DIAGNOSTIC LOGS” suchen. Der Deployment-User (der auch das Git-Deployment übernimmt) wird dort als Login gebraucht!

Ich benötige weitere Logging- / Exception-Informationen

Leider sind die Error-Pages nicht wirklich immer zielführend, daher kommt man relativ schnell zu dem Punkt an dem man ein Logging Framework benötigt.

ELMAH to the rescue!

Ich hatte mich schnell für ELMAH entschieden, samt der zusätzlichen ASP.NET MVC Integration:

Dann noch den XmlFile-Provider einhängen in der web.config:

<elmah>
  <errorLog type=”Elmah.XmlFileErrorLog, Elmah” logPath=”~/App_Data” />
</elmah>

Dann kann man auch via der FTP Seite sich bis zur Seite und dem App_Data Verzeichnis navigieren:

Natürlich würde auch Log4Net oder NLog funktionieren.

Damit sollte es auch mit dem Debugging klappen

Fazit:

Die Azure Websites verhalten sich sehr ähnlich wie eine normale Web-Anwendung auf einem normalen IIS, daher gelten hier fast die selben Bedingungen. Hier ist kein völlig anderes Vorgehen wie bei den Cloud Services (mit den Table Storage und den Diagnostics) von nöten.

Firmen-IT & die Cloud – manchmal muss es die IP-Adresse sein

Schwieriger wird der Fall wenn man ein Hybrid-Betrieb fahren möchte: Wer SQL Azure nutzen möchte, aber die Anwendung läuft im Firmen-Netz braucht oftmals eine interne Firewall-Freischaltung auf Basis von IP-Adressen bzw. IP-Adressbereichen.

IP-Adress Ranges von Azure (Stand Oktober 2011!)

Leider habe ich keine offiziellen Angaben dazu gefunden, sondern nur durch zufall mit einem Kollegen diese Seite entdeckt, welche die IP-Ranges von Oktober 2011 auflistet:

United States (South/Central)

65.55.80.0/20, 65.54.48.0/21, 65.55.64.0/20, 70.37.48.0/20, 70.37.64.0/18, 65.52.32.0/21, 70.37.160.0/21, 157.55.103.48/28, 157.55.176.0/20, 157.55.103.32/28, 157.55.192.0/22

United States (North/Central)

207.46.192.0/20, 65.52.0.0/19, 65.52.48.0/20, 65.52.192.0/19, 209.240.220.0/23, 157.55.136.0/21, 157.55.60.224/28, 157.55.160.0/20

Europe (North)

213.199.128.0/20, 213.199.160.0/20, 213.199.184.0/21, 94.245.112.0/20, 94.245.88.0/21, 94.245.104.0/21, 65.52.64.0/20, 65.52.224.0/19

Europe (West)

94.245.97.0/24, 65.52.128.0/19

Asia (Southeast)

207.46.48.0/20, 111.221.16.0/21, 111.221.80.0/20

Asia (East)

11.221.64.0/22, 65.52.160.0/19

Benutzung auf eigene Gefahr – hat aber bei mir funktioniert und der Admin war glücklich

Was macht eine gute Applikation aus? Ein möglichst grosses Feature-Sets? Eine technisch einwandfreie Software? Ein tolles Design? Die Antwort liegt (für mich) irgendwo in der Mitte bzw. eher auf einem anderen Level: Für den Anwender sind es meist die kleinen Details die eure App definieren. 

Banale Dinge, wie z.B. ein DropDown können “begeistern”

Der Artikel um den Nachbau des “Amazon Dropdown-Menüs” ging durch die Twitter-Webdesign-Welt. Auf den ersten Blick eigentlich total banal und unspannend – ein Drop-Down. Super. Auf der anderen Seite ein nettes Detail (und schon ziemlich cool).

Anderseits macht Amazon natürlich nicht durch das Drop-Down mehr Umsatz – aber mit sowas hebt man sich von der Masse ab (wobei Amazon natürlich schon längst auf einer völlig anderen Ebene ist) und das ist insbesondere am Anfang für viele wichtig um beim Nutzer zu punkten.

Technisch perfekt, aber völlig lieblos designed

Wer Benutzer (damit sind nicht nur Consumer gemeint, sondern vielleicht auch der normale Büroangestellte, oder auch der Entwickler, der eure API nutzen möchte) überzeugen will, sollte seine Applikation mit Liebe entwickeln. Sich auch in den Anwender reinversetzen. Frustrierende Tools, die lieblos gestaltet wurden, gibt es schon mehr als genug. Selbst Business-Software geht diesen Weg, oder warum sonst kann man lustige Brote als Hintergrund in Outlook setzen?

Details ja, aber nicht verloren in der Detailliebe und auch nicht kitschig

Hier kommt vermutlich das kniffligste: Die Balance zu finden zwischen “funktionstüchtige, kalte Software” und “soooo viele Details, aber warum geht das nicht?”. Die Erwartungshaltung des Anwenders an die Software soll erfüllt werden – aber wenn er dabei eine schönes Nutzererlebnis hat, dann her damit!

Ich hab keine Zeit für Details – braucht sowieso kein Mensch!

Der Gedanke, dass man an Details nur Zeit verschwendet ist für einen Techniker naheliegend (und vielleicht sogar “typisch deutsch”), aber grundsätzlich verkehrt.

Wie bereits Mr. Coding-Horror gut zusammengefasst hat: This is all your app is: a collection of tiny details.

Selbst eine API kann mit Liebe designed werden. Für die StackExchange-Leute war es auch nicht nötig ein Webtool zum Testen ihrer API bereitzustellen – gibt ja Fiddler, oder? Aber trotzdem ist das ein nettes Details, was die Nutzererfahrung runder macht:

100% Test-Abdeckung, aber…

Viele Software-Entwickler lieben Statistiken und natürlich will jeder eine toll geteste Software haben – 80 oder mehr % sind doch ein gutes Ziel, oder? Für mich auch der verkehrte Ansatz – wenn die Applikation hohes Frustrations-Potenzial hat, weil das Nutzererlebnis einfach vollständig fehlt, dann würde ich da lieber meine Zeit investieren.

Also liebe Software Kollgen: Liebe und Begeisterung durch Software verbreiten – yay!

Wer heute noch auf der Suche nach einem “billigen” Hoster für seine ASP.NET Website ist, der sollte sich unbedingt das Website-Feature von Windows Azure genauer anschauen. Bereits mitte letzten Jahres von Scott Guthrie unter dem Titel “Meet the new Windows Azure” vorgestellt habe ich es nun doch letztendlich mal selbst ausprobiert (und nicht nur auf Videos und Konferenzen gesehen ) und bin mehr als begeistert.

Windows Azure Websites

Die Websites sind ein wesentlich leichtgewichtiges Modell als die “Cloud Services” und sind momentan noch im Preview Status – d.h. man muss es aktuell noch explizit freischalten.

Nach dem Anlegen kann man entweder das “Publish profil” runterladen und via WebDeploy das Deployment erledigen oder man wählt die Option via TFS oder Git zu deployen:

Als Quelle können diverse Git-Provider dienen oder auch der Team Foundation Service:

In meinem Fall habe ich mich für GitHub entschieden und kann direkt danach mein Repository auswählen:

Danach wird versucht ein Deployment durchzuführen, d.h.

Wenn alles gut geht wird die Website im Repository gebaut und deployed:

Randnotiz: Man kann auch wieder auch ältere Deployments zurückgreifen wenn man möchte.

Fazit:

Eine kleine ASP.NET Seite zu hosten war nie einfacher und billiger als heute. Die Gewissheit die kleine Seite auch ohne große Probleme hinterher auf mehrere Maschinen skalieren zu lassen ist eine der Stärken von Azure.

Was passiert wenn mehrere ASP.NET Projekte in einem Repository sind?

Aktuell scheint es so als ob das automatische Deployment nur eine Solution mit einem Webprojekt unterstützt wird – allerdings kann man natürlich selbst zu Azure “pushen”.

Was kostet es?

10 Seiten gibt es kostenlos – wobei eine Traffic und CPU Limitierung vorliegt. Wer eine Custom-Domain haben möchte, muss zudem auch einen kleinen Betrag zahlen. Mehr Informationen gibt es auf der Pricing Seite.

Kann man das Git-Deployment für seinen eigenen IIS nutzen?

Ja! Das Git-Deployment auf Azure wird von “Kudu” gemanaged, welches auf GitHub zur Verfügung steht – samt einem recht großen Wiki.

Da ich in lezter Zeit immer häufiger auf die Powershell zugegriffen hab und es mich immer gestört hat, dass die Visual Studio Tools wie sn.exe oder msbuild.exe nur über die “Developer Command Prompt” aufrufbar waren (ohne den kompletten Pfad anzugeben) habe ich mal nach der Lösung gegoogelt.

Was macht die Developer Command Prompt?

Der Shortcut ruft eigentlich die Batch Datei “VsDevCmd.bat” auf, welche diverse Umgebungsvariablen setzt.

Die Datei ist unter diesem Pfad zu finden:

C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\Tools

Ein Profile.ps1 anlegen

Um in jeder Powershell Session auf diese Funktionalität zuzugreifen kann man ein Profil anlegen. 

Dazu legt man einen “WindowsPowershell” Ordner hier an:

C:\Users\USERNAME\Documents

Im WindowsPowershell Ordner legt man eine Profile.ps1 Datei an. Diese wird ab sofort bei jeder Powershell Session automatisch ausgeführt

Visual Studio Tools in der Powershell registrieren (und noch mehr)

Durch ein Link von dem Stackoverflow Threads bin ich auf diesen Blog gekommen. Zudem habe ich noch ein paar Anregungen von Thomas Freudenberg übernommen, da er sein Powershell Profile hier veröffentlicht hat. Heraus gekommen ist dies:

###############################################################################
# Profile PS1 based on this samples:
# http://stackoverflow.com/questions/138144/whats-in-your-powershell-profile-ps1file
# http://www.tavaresstudios.com/Blog/post/The-last-vsvars32ps1-Ill-ever-need.aspx
# Place this file in: C:\Users\ACCNAME\Documents\WindowsPowerShell\profile.ps1
# https://gist.github.com/thoemmi/3720721
###############################################################################
# red background if running elevated
###############################################################################

& {
 $wid=[System.Security.Principal.WindowsIdentity]::GetCurrent()
 $prp=new-object System.Security.Principal.WindowsPrincipal($wid)
 $adm=[System.Security.Principal.WindowsBuiltInRole]::Administrator
 $IsAdmin=$prp.IsInRole($adm)
 if ($IsAdmin)
 {
  (get-host).UI.RawUI.Backgroundcolor="DarkRed"
  clear-host
 }
}

###############################################################################
# Exposes the environment vars in a batch and sets them in this PS session
###############################################################################
function Get-Batchfile($file)
{
    $theCmd = "`"$file`" & set"
    cmd /c $theCmd | Foreach-Object {
        $thePath, $theValue = $_.split('=')
        Set-Item -path env:$thePath -value $theValue
    }
}

###############################################################################
# Sets the VS variables for this PS session to use (for VS 2012)
###############################################################################
function VsVars32($version = "11.0")
{
	# 64bit Key in Registry
    $theKey = "HKLM:SOFTWARE\Wow6432Node\Microsoft\VisualStudio\" + $version
    $theVsKey = get-ItemProperty $theKey
    $theVsInstallPath = [System.IO.Path]::GetDirectoryName($theVsKey.InstallDir)
    $theVsToolsDir = [System.IO.Path]::GetDirectoryName($theVsInstallPath)
    $theVsToolsDir = [System.IO.Path]::Combine($theVsToolsDir, "Tools")
    $theBatchFile = [System.IO.Path]::Combine($theVsToolsDir, "vsvars32.bat")
    Get-Batchfile $theBatchFile
    [System.Console]::Title = "Visual Studio " + $version + " Windows Powershell"

	Write-Host "[Profile.ps1] Visual Studio 2012 CMD Commands set" -Foreground Green
}

function SetupPowershellHistory() {
	$profileFolder = split-path $profile

	# save last 100 history items on exit
	$historyPath = Join-Path $profileFolder history.clixml

	# hook powershell's exiting event & hide the registration with -supportevent.
	Register-EngineEvent -SourceIdentifier powershell.exiting -SupportEvent -Action {
		Get-History -Count 100 | Export-Clixml (Join-Path (split-path $profile) history.clixml) }

	# load previous history, if it exists
	if ((Test-Path $historyPath)) {
		Import-Clixml $historyPath | ? {$count++;$true} | Add-History
		Write-Host "[Profile.ps1] Loaded $count history item(s)" -Foreground Green
	}
}

###############################################################################
# Execute
###############################################################################
Write-Host "[Custom Profile.ps1 invoked]"

# VS
VsVars32

# History
SetupPowershellHistory

Write-Host "[Custom Profile.ps1 finished]"

Damit habe ich in jeder Powershell Session die Visual Studio Tools dabei sowie die letzten 100 Befehle die ich eingetippt hab (was ziemlich cool ist).

Was ist der Unteschied zwischen Profile.ps1 und Microsoft.Powershell_Profile.ps1?

Wer nur ein “Profile.ps1” ablegt, der hat die Funktionalität in allen Powershell Hosts zur Verfügung – d.h. auch z.B. im NuGet Package Manager. Wer es nur von der Windows Powershell benötigt, der kann ein Microsoft.Powershell_profile.ps1 anlegen.

Sourcen

Das ganze ist natürlich auch auf GitHub zu finden. Wer noch Anregung hat, kann gern auch ein Pull Request machen