.
Anmeldung | Registrieren | Hilfe

Blogger

.NET-Blog Archiv

.NET Developer Blogs

Building a home robot: Part 5 - arms and hands

13.01.2017 19:00:00 | Daniel Springwald

(see all parts of "building a home robot")

I wanted Roobert to get two identical hands with separate moveable fingers.

Because of this (and the small size) I decided to use a commercial construction kit instead of designing and constructing the hands on my own.

Although it was a construction kit it was fun for hours to assemble the hands:

Each arm is constructed from the hand construction kit, 3 servos, 3d printed servo brackets and an I2C servo controller. Because the servo controller seemed to be unable to shut down the servo power, I attached a relays for each arm to turn the servo power on/on.

The servo holder for the upper arm parts are printed in 3D:

The complete arms:

The right arm:

A roobert-hand-assembling-workplace :-)

GitHub API: Create or update files

03.01.2017 01:45:00 |

This blogpost covers a pretty basic GitHub topic: Creating and updating content on GitHub. Of course, there are many ways to do it - e.g. you could do the full Git-ceremony and it would work with all Git hosts, but in my case I just wanted to target the offical GitHub API.

Prerequisite: A GitHub User, Repo and Token

To use this code you will need write access to a GitHub repository and you should have a valid GitHub token.

Code

The most simple way to communicate with the GitHub API is by using the Octokit SDK (from GitHub).

Description: Inside the try-block we try to get the target file, if it is already committed in the repo the API will return the last commit SHA.

With this SHA it is possible to create a new commit to do the actual update.

If the file was not found, we create the file. I’m not a huge fan of this try/catch block, but didn’t found any other way to check if the file is comitted or not (please give me a hint if this is wrong ;))

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Octokit;

namespace CreateOrUpdateGitHubFile
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Run(async () =>
            {
                var ghClient = new GitHubClient(new ProductHeaderValue("Octokit-Test"));
                ghClient.Credentials = new Credentials("ACCESS-TOKEN");

                // github variables
                var owner = "OWNER";
                var repo = "REPO";
                var branch = "BRANCH";

                var targetFile = "_data/test.txt";

                try
                {
                    // try to get the file (and with the file the last commit sha)
                    var existingFile = await ghClient.Repository.Content.GetAllContentsByRef(owner, repo, targetFile, branch);

                    // update the file
                    var updateChangeSet = await ghClient.Repository.Content.UpdateFile(owner, repo, targetFile,
                       new UpdateFileRequest("API File update", "Hello Universe! " + DateTime.UtcNow, existingFile.First().Sha, branch));
                }
                catch (Octokit.NotFoundException)
                {
                    // if file is not found, create it
                    var createChangeSet = await ghClient.Repository.Content.CreateFile(owner,repo, targetFile, new CreateFileRequest("API File creation", "Hello Universe! " + DateTime.UtcNow, branch));
                }

                
                
            }).Wait();
        }
    }
}

The demo code is also available on GitHub.

Hope this helps.

DbProviderFactories: Write database agnostic ADO.NET code

31.12.2016 16:00:00 |

Recently I needed to write a module that needs to connect to a wide range of SQL-DBs, e.g. MySQL, MS SQL, Oracle etc.

Problem: Most providers will use their concret classes

If you look at the C# example on the MySQL dev page you will see the MsSql-Namespace and classes:

MySql.Data.MySqlClient.MySqlConnection conn;
string myConnectionString;

myConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    conn = new MySql.Data.MySqlClient.MySqlConnection();
    conn.ConnectionString = myConnectionString;
    conn.Open();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show(ex.Message);
}

The same classes will probably not work for a MS SQL database.

“Solution”: Use the DbProviderFactories

For example if you install the MySql-NuGet package you will also get this little enhancement to you app.config:

<system.data>
  <DbProviderFactories>
    <remove invariant="MySql.Data.MySqlClient" />
    <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.9.9.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
  </DbProviderFactories>
</system.data>

Now we can get a reference to the MySql client via the DbProviderFactories:

using System;
using System.Data;
using System.Data.Common;

namespace DbProviderFactoryStuff
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("All registered DbProviderFactories:");
                var allFactoryClasses = DbProviderFactories.GetFactoryClasses();

                foreach (DataRow row in allFactoryClasses.Rows)
                {
                    Console.WriteLine(row[0] + ": " + row[2]);
                }

                Console.WriteLine();
                Console.WriteLine("Try to access a MySql DB:");

                DbProviderFactory dbf = DbProviderFactories.GetFactory("MySql.Data.MySqlClient");
                using (DbConnection dbcn = dbf.CreateConnection())
                {
                    dbcn.ConnectionString = "Server=localhost;Database=testdb;Uid=root;Pwd=Pass1word;";
                    dbcn.Open();
                    using (DbCommand dbcmd = dbcn.CreateCommand())
                    {
                        dbcmd.CommandType = CommandType.Text;
                        dbcmd.CommandText = "SHOW TABLES;";

                        // parameter...
                        //var foo = dbcmd.CreateParameter();
                        //foo.ParameterName = "...";
                        //foo.Value = "...";

                        using (DbDataReader dbrdr = dbcmd.ExecuteReader())
                        {
                            while (dbrdr.Read())
                            {
                                Console.WriteLine(dbrdr[0]);
                            }
                        }
                    }
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);
            }

            Console.ReadLine();

        }
    }
}

The most important line is this one:

DbProviderFactory dbf = DbProviderFactories.GetFactory("MySql.Data.MySqlClient");

Now with the DbProviderFactory from the MySql client we can access the MySql database without using any MySql-specific classes.

There are a couple of “in-built” db providers registered, like the MS SQL provider or ODBC stuff.

The above code will output something like this:

All registered DbProviderFactories:
Odbc Data Provider: System.Data.Odbc
OleDb Data Provider: System.Data.OleDb
OracleClient Data Provider: System.Data.OracleClient
SqlClient Data Provider: System.Data.SqlClient
Microsoft SQL Server Compact Data Provider 4.0: System.Data.SqlServerCe.4.0
MySQL Data Provider: MySql.Data.MySqlClient

Other solutions

Of course there are other solutions - some OR-Mapper like the EntityFramework have a provider model which might also work, but this one here is a pretty basic approach.

SQL Commands

The tricky bit here is that you need to make sure that your SQL commands work on your database - this is not a silver bullet, it just lets you connect and execute SQL commands to any ‘registered’ database.

The full demo code is also available on GitHub.

Hope this helps.

Building a home robot: Part 4 - moving the head up and down

26.12.2016 11:00:00 | Daniel Springwald

(see all parts of "building a home robot")

Because the monitor and raspberry pi are placed in the front of the head most of weight is there. So the motors for up/down  movement have to be powerful enough to handle this.

I decided to use two stepper motors with built in gearboxes. They also are the axis for the head movement. I mounted them back to back into a 3d printed box ,so they are moving in contrariwise directions.

Putting together neck and front head:

Assembling including cables, Raspberry Pi and electronics:

The two stepper motors have much power - but still not enough to lift the head. To fix this problem I placed a counterbalance made from lead in the back of the head.

The first test with provisional counterbalance:

After some hours of testing another problem occurred. The mechanic connection between the two motors and the 3d printed part was very small.

Only 4mm PLA to connect  to the whole head wight and movement:

And the PLA material was not strong enough to handle this for a long time – so the freedom of movement increased.

To solve this I used two small parts of aluminum with holes matching to the axis of both stepper motors.

Goodbye Techblog

20.12.2016 17:12:00 | Martin Hey

Ich habe immer gerne gebloggt, war das doch für mich ein Weg, mein Wissen zu teilen. Und oft genug habe ich beim Suchen nach Lösungen für Probleme meine eigenen Posts gefunden und so gemerkt, dass ich das gleiche Problem schon mal hatte - ein bisschen Eigennutz war also dabei und ich habe ihn auch als private Wissenssammlung mit Indizierung durch Google verwendet. 

Aber in den letzten beiden Jahren ist immer weniger Zeit fürs Bloggen geblieben (6 Posts in 2016 ist nicht viel) und auch die Themen mit denen ich mich beschäftige verändern sich - so bin ich zwar noch an Entwickler-Themen dran, aber oft genug sind da auch eher betriebswirtschaftliche Themen die mich umtreiben.

Ich werde auch weiterhin aktiv in der Entwickler-Community bleiben und an anderer Stelle sicher weiter bloggen. Nur dieser eher privat betriebene Blog wird zum Ende des Jahres 2016 gelöscht.

Angelehnt an den allerersten Post aus 2007: goodbye world

A small library to support the CQS pattern.

11.12.2016 18:00:00 | Jürgen Gutsch

The last years, I loved to use the Command and Query Segregation pattern. Using this pattern in every new project, requires to have the same infrastructure classes in this projects. This is why I started to create a small and reusable library, which now supports ASP.NET Core and is written to match .NET Standard 1.6.

About that CQS

The idea behind CQS is to separate the query part (the read part / fetching-the-data-part) from the command part (the write part / doing-things-with-the-data-part). This enables you to optimize both parts in different ways. You are able to split the data flow into different optimized pipes.

From my perspective, the other most important benefit of it is, that this approach enforce you, to split your business logic into pretty small peaces of code. This is because each command and each query only does one single thing:

  • fetching a specific set of data
  • executing a specific command

E. g. if you press a button, you probably want to save some data. You will create a SaveDataCommand with the data to save in it. You'll pass that command to the CommandDispatcher and this guy will delegate the command to the right CommandHandler, which is just responsible to save that specific data to the database, or what ever you want to do with that data. You think you'll also add a log entry with the same command? No problem: Just create another CommandHandler using the same command. With this approach you'll have two small components, one to save the data and another one to add a log entry, which are completely independent and can be tested separately.

What about fetching the data? Just create a "Query" with the data used as a filter criteria. Pass the Query to the QueryProcessor, which delegates the Query to the right QueryHandler. in this QueryHandler, you are able to select the data from the data source, map it to the result you expect and return it back.

Sounds easy? It really is as easy.

Each Handler, both the QuerHandlers and the CommandHandlers, are isolated peaces of code, if you use Dependency Injection in it. This means unit tests are as easy as the implementation itself.

What is inside the library?

This library contains a CommandDispatcher and a QueryProcessor to delegate commands and queries to the right handlers. The library helps you to write your own commands and queries, as well as your own command handlers and query handlers. There are two main NameSpaces inside the library: Command and Query

The Command part contains the CommandDispatcher, an ICommand interface and two more interfaces to define command handlers (ICommandHandler<in TCommand>) and async command handlers (IAsyncCommandHandler<in TCommand>):

The CommandDispatcher interface looks like this:

public interface ICommandDispatcher
{
    void DispatchCommand<TCommand>(TCommand command) where TCommand : ICommand;
    Task DispatchCommandAsync<TCommand>(TCommand command) where TCommand : ICommand;
}

The Query part contains the QueryProcessor, a generic IQuery, which defines the result in the generic argument and two different QueryHandlers. It also contains two more interfaces to define query handlers (IHandleQuery<in TQuery, TResult>) and async query handlers (IHandleQueryAsync<in TQuery, TResult>)

public interface IQueryProcessor
    {
        TResult Process<TResult>(IQuery<TResult> query);
        Task<TResult> ProcessAsync<TResult>(IQuery<TResult> query);
    }

Using the library

For the following examples, I'll reuse the speaker database I already used in previous blog posts.

After you installed the library using Nuget, you need to register the the QueryProcessor and the CommandDispatcher to the dependency injection. You can do it manually in the ConfigureSerices method or just by using AddCqsEngine()

public void ConfigureServices(IServiceCollection services)
{
	services.AddMvc(),

	services.AddCqsEngine();

	services.AddQueryHandlers();
	services.AddCommandHandlers();
}

The methods AddQueryHandlers and AddCommandHandlers are just methods to encapsulate the registrtion of your Handlers, and are propably written by you as a user of this library. The method could look like this:

public static IServiceCollection AddQueryHandlers(this IServiceCollection services)
{
	services.AddTransient<IHandleQueryAsync<AllSpeakersQuery, IEnumerable<Speaker>>, SpeakerQueryHandler>();
	services.AddTransient<IHandleQueryAsync<SpeakerByIdQuery, Speaker>, SpeakerQueryHandler>();

	services.AddTransient<IHandleQueryAsync<AllEventsQuery, IEnumerable<Event>>, EventQueryHandler>();
	services.AddTransient<IHandleQueryAsync<SingleEventByIdQuery, Event>, EventQueryHandler>();

	services.AddTransient<IHandleQueryAsync<AllUsergroupsQuery, IEnumerable<Usergroup>>, UsergroupQueryHandler>();
	services.AddTransient<IHandleQueryAsync<SingleUsergroupByIdQuery, Usergroup>, UsergroupQueryHandler>();

	services.AddTransient<IHandleQueryAsync<AllNewslettersQuery, IEnumerable<Newsletter>>, NewsletterQueryHandler>();
	services.AddTransient<IHandleQueryAsync<SingleNewsletterByIdQuery, Newsletter>, NewsletterQueryHandler>();
	
	return services;
}

Usually you will place this method near you handlers.

The method AddCqsEngine is overloaded to add your QueryHandlers and yor CommandHandlers to the dependnecy injection. There is no real magic behind that method. It is just to group the additional dependencies:

services.AddCqsEngine(s =>
	{
		s.AddQueryHandlers();
		s.AddCommandHandlers();
	});

The parameter s is the same Seervicecollection as the one in the ConfigureServices method.

This library makes heavily use of dependency injection and uses the IServiceProvider, which is used and provided in ASP.NET Core. If you replace the built in DI container with different one, you should ensure that the IServiceProvider is implemented and registered with that container.

Query the data

Getting all the speakers out of the storage is a pretty small example. I just need to create a small class called AllSpeakersQuery and to implement the generic interface IQuery:

public class AllSpeakersQuery : IQuery<IEnumerable<Speaker>>
{
}

The generic argument of the IQuery interface defines the value we want to retrieve from the storage. In this case it is a IEnumerable of speakers.

Querying a single speaker looks like this:

public class SpeakerByIdQuery : IQuery<Speaker>
{
    public SingleSpeakerByIdQuery(Guid id)
    {
        Id = id;
    }

    public Guid Id { get; private set; }
}

The query contains the speakers Id and defines the return value of a single Speaker.

Once you got the QueryProcessor from the dependency injection, you just need to pass the queries to it and retrieve the data:

// sync
var speaker = _queryProcessor.Process(new SpeakerByIdQuery(speakerId));
// async
var speakers = await _queryProcessor.ProcessAsync(new AllSpeakersQuery());

Now let's have a look into the QueryHandlers, which are called by the QueryProcessor. This handlers will contain your business logic. This are small classes, implementing the IHandleQuery<in TQuery, TResult> interface or the IHandleQueryAsync<in TQuery, TResult> interface, where TQuery is a IQuery<TResult>. This class usually retrieves a data source via dependency injection and an Execute or ExecuteAsync method, with the specific Query as argument:

public class AllSpeakersQueryHandler :
    IHandleQuery<AllSpeakersQuery, IEnumerable<Speaker>>
{
    private readonly ITableClient _tableClient;

    public SpeakerQueryHandler(ITableClient tableClient)
    {
        _tableClient = tableClient;
    }

    public Task<IEnumerable<Speaker>> Execute(AllSpeakersQuery query)
    {
        var result = _tableClient.GetItemsOf<Speaker>();
        return result;
    }
}

public class SpeakerByIdQueryQueryHandler :
    IHandleQueryAsync<SpeakerByIdQuery, Speaker>
{
    private readonly ITableClient _tableClient;

    public SpeakerQueryHandler(ITableClient tableClient)
    {
        _tableClient = tableClient;
    }
    
    public async Task<Speaker> ExecuteAsync(SpeakerByIdQuery query)
    {
        var result = await _tableClient.GetItemOf<Speaker>(query.Id);
        return result;
    }
}

Sometimes I handle multiple queries in a single class, this is possible by just implementing multiple IHandleQuery interfaces. I would propose to do this only, if you have really small Execute methods.

Executing Commands

Let's have a quick look into the commands too.

Let's assume we need to create a new speaker and we need to update a speakers email address. To do this we need to define two specific commands

public class AddSpeakerCommand : ICommand
{
    AddSpeakerCommand(Speaker speaker)
    {
        Speaker = speaker;
    }

    public Speaker Speaker { get; private set; }
]

public class UpdateSpeakersEmailCommand : ICommand
{
    UpdateSpeakersEmailCommand(int speakerId, string email)
    {
        SpeakerId = speakerId;
        Email = email;
    }

    public int SpeakerId { get; private set; }

    public string Email { get; private set; }
}

As equal to the queries, the commands need to be passed to the CommandDispatcher, which is registered in the DI container.

// sync
_commandDispatcher.DispatchCommand(new AddSpeakerCommand(myNewSpeaker));
// async
await _commandDispatcher.DispatchCommandasync(new UpdateSpeakersEmailCommand(speakerId, newEmail));

The CommandHandlers are small classes which are implementing the ICommandHandler or the IAsyncCommandHandler where TCommand is a ICommand. Thise handlers contain a Handle or a HandleAync method with the specific Command as argument. As equal to the query part, you usually will also get a data source from the dependency injection:

public class AddSpeakerCommandHandler : ICommandHandler<AddSpeakerCommand>
{
	private readonly ITableClient _tableClient;

	public AddSpeakerCommandHandler(ITableClient tableClient)
	{
		_tableClient = tableClient;
	}

	public void Handle(AddSpeakerCommand command)
	{
		_tableClient.SaveItemOf<Speaker>(command.Speaker);
	}
}

Command validation

What about validatig the commands? Sometimes it is needed to check authorization or to validate the command values before executing the commands. You can do the checks inside the handlers, but this is not always a good idea. This increases the size and the complexity of the handlers and the validation logic is not reusable like this.

This is why the CommandDispatcher supports precondition checks. As equal to the command handlers, you just need to write command preconditions (ICommandPrecondition<in TCommand>) od async command preconditions (ICommandPrecondition<in TCommand>). This interfaces contain a Chack or ChackAsync method which will be executed before the command handlers are executed. You can hava as many preconditions as you want for a single command. If you register the preconditions to the DI container, the command dispatcher will find and execute them:

public class ValidateChangeUsersNameCommandPrecondition : ICommandPrecondition<ChangeUsersNameCommand>
{
    public void Check(ChangeUsersNameCommand command)
    {
        if (command.UserId == Guid.Empty)
        {
            throw new ArgumentException("UserId cannot be empty");
        }
        if (String.IsNullOrWhiteSpace(command.Name))
        {
            throw new ArgumentNullException("Name cannot be null");
        }
    }
}

In case of errors, the command dispatcher will throw an AggregateException with all the possible exceptions in it.

Conclusion

The whole speaker database application is built like this: Using handlers to create small components, which are handling queries to fetch data or which are executing commands to do something with the data.

What do you think? Does it make sense to you? Would it be useful for your projects? Please drop some lines and tell me about your opinion :)

This library is hosted on GitHub in the "develop" branch. I would be happy about any type contribution on GitHub. Feel free to try id out and let me know about issues, tips and improvements :)

Contributing to OSS projects on GitHub using fork and upstream

06.12.2016 18:00:00 | Jürgen Gutsch

Intro

Some days ago, Damien Bowden wrote a pretty cool post about, how to contribute to an open source software project hosted on GitHub, like the AspLabs. He uses Git Extensions in his great and pretty detailed post. Also a nice fact about this post is, that he uses a AspLabs as the demo project. Because we both worked on that on the hackathon at the MVP Summit 2016, together with Glen Condron and Andrew Stanton-Nurse from the ASP.NET Team.

At that Hackathon we worked on the HealthChecks for ASP.NET Core. The HealthChecks can be used to check the heath state of dependent sub systems in an e. g. micro service environment, or in any other environment where you need to know the health of depending systems. A depending systems could be a SQL Server, an Azure Storage service, the Hard drive, a Web-/REST-Service, or anything else you need to run your application. Using the HealthChecks you are able to do something, if a service is not available or unhealthy.

BTW: The HealthChecks are mentioned by Damian Edwards in this ASP.NET Community Standup: https://youtu.be/hjwT0av9gzU?list=PL0M0zPgJ3HSftTAAHttA3JQU4vOjXFquF

Because Damien Bowden also worked on that project, my idea was to do the same post. So asked him to "fork" the original post, but use the Git CLI in the console instead of Git Extensions. Because this is a fork, some original words are used in this post ;)

Why using the console? Because I'm a console junkie since a few years and from my perspective, no Git UI is as good as the simple and clean Git CLI :) Anyway, feel free to use the tool that fits your needs. Maybe someone will write the same post using SourceTree or using the Visual Studio Git integration. ;)

As a result this post is a also simple guideline on how you could contribute to OSS projects hosted on GitHub using fork and upstream. This is even not the only way to do it. In this demo I'm going to use the console and the basic git commands. As same as Damien did, I'll also use the aspnet/AspLabs project from Microsoft as the target Repository.

True words by Damien: So you have something to contribute, cool, that’s the hard part.

Setup your fork

Before you can make your contribution, you need to create a fork of the repository where you want to make your contribution. Open the project on GitHub, and click the "Fork" button in the top right corner.

Now clone your forked repository. Click the "Clone and download" button and copy the clone URL to the clipboard.

Open a console and cd to the location where you want to place your projects. It is c:\git\ in my case. Write git clone followed by the URL to the repository and press enter.

Now you have a local master branch and also a server master branch (remote) of your forked repository. The next step is to configure the remote upstream branch to the original repository. This is required to synchronize with the parent repository, as you might not be the only person contributing to the repository. This is done by adding another remote to that git repository. On GitHub copy the clone URL the the original repository aspnet/AspLabs. Go back to the console and type git remote add upstream followed by the URL of the original repository:

To check if anything is done right, type git remote -v, to see all existing remotes. It should look like this:

Now you can pull from the upstream repository. You pull the latest changes from the upstream/master branch to your local master branch. Due to this you should NEVER work on your master branch. Then you can also configure your git to rebase the local master with the upstream master if preferred.

Start working on the code

Once you have pulled from the upstream, you can push to your remote master, i. e. the forked master. Just to mention it again, NEVER WORK ON YOUR LOCAL FORKED MASTER, and you will save yourself hassle.

Now you’re ready to work. Create a new branch. A good recommendation is to use the following pattern for naming:

<gitHub username>/<reason-for-the-branch>

Here’s an example:

JuergenGutsch/add-healthcheck-groups

By using your GitHub username, it makes it easier for the person reviewing the pull request.

To create that branch in the console, use the git checkout -b command followed by the branch name. This creates the branch and checks it out immediately:

Creating pull requests

When your work is finished on the branch, you need to push your branch to your remote repository by calling git push Now you are ready to create a pull request. Go to your repository on GitHub, select your branch and and click on the "Compare & pull request" button:

Check if the working branch and the target branch are fine. The target branch is usually the master of the upstream repo.

NOTE: If your branch was created from an older master commit than the actual master on the parent, you need to pull from the upstream and rebase your branch to the latest commit. This is easy as you do not work on the local master. Or update your local master with the latest changes from the upstream, push it to your remote and merge your local master into your feature branch.

If you are contributing to any Microsoft repository, you will need to sign an electronic contribution license agreement before you can contribute. This is pretty easy and done in a few minutes.

If you are working together with a maintainer of the repository, or your pull request is the result of an issue, you could add a comment with the GitHub name of the person that will review and merge, so that he or she will be notified that you are ready. They will receive a notification on GitHub as soon as you save the pull request.

Add a meaningful description. Tell the reviewer what they need to know about your changes. and save the pull request.

Now just wait and fix the issues as required. Once the pull request is merged, you need to pull from the upstream on your local forked repository and rebase if necessary to continue with you next pull request.

And who knows, you might even get a coin from Microsoft. ;)

The console I use

I often get the question what type console I use. I have four consoles installed on my machine, in addition to the cmd.exe and PowerShell. I also installed the bash for Windows. But my favorite console is the Cmder, which is a pretty nice ConEmu implementation. I like this console because it is easy to use, easy to customize and it has a nice color theme too.

Thanks

Thanks to Andrew Stanton-Nurse for his tips. Thanks to Glen Condron for the reviews. thanks Damien Bowden for the original blog post ;)

I'd also be happy for tips from anyone on how to improve this guideline.

VSTO: Bilder in Ribbons nutzen

01.12.2016 15:40:01 | Hendrik Loesch

Aktuell habe ich die Ehre ein Excel Plugin zu schreiben. Dieses verfügt über ein eigenes Ribbon, welches möglichst ansprechend aussehen soll. Für mich als Farblegastheniker ist es unmöglich ansprechende Icons zu designen. Dazu kommt, dass die Google Bildersuche schon allein aufgrund der rechtlichen Situation eine eher fragliche Quelle ist. Um nun also möglichst nah am […]

XMAS Treffen der SharePoint UG München bei CGI

17.11.2016 11:46:07 | Sebastian Gerling

Wir veranstalten auch diese Jahr wieder ein XMAS Treffen der SharePoint UG München bei der CGI in der Spixstr. 59. Termin ist der 21.12. um 18:30. Dabei lassen wir  uns bei Glühwein von Max und Corinna auf Weihnachten mit SharePoint einstimmen, dafür haben wir folgende Vorträge: Titel: Hybrid Search – Everything YOU need to know Abstract: In […]

Enable SSL with custom domains on GitHub Pages via Cloudflare

15.11.2016 01:15:00 |

Two weeks ago I decided (finally!) that I should enable SSL on this blog.

Problem: GitHub Pages with a custom domain

This blog is hosted on GitHub Pages with a custom domain, which currently doesn’t support SSL out of the box. If you stick with a github.io domain SSL is not a problem.

Cloudflare to the rescure

I decided to take a deeper look at Cloudflare, which provides DNS, CDN and other “network”-related services. For the “main” service Cloudflare serves as the DNS for your domain and is like a proxy.

With this setup you have some nice benefits:

  • A free SSL certificate (AFAIK you can also use your own cert if you need)
  • A CDN cache
  • DDOS protection
  • “Analytics”

Be aware: This is just the free plan.

And everything is pretty easy to manage via the web interface.

Setup

The first step is to register at Cloudflare & setup your domain. After the first step you need to change the name server for your domain to Cloudflares server.

All your domain belonging can now be managed inside Cloudflare:

x

Setting up some rules

When your DNS changes are done (which can take a couple of hours) you might want to introduce some basic rules. I use these settings, which enforces HTTPS and Cloudflare cache:

x

Done… or nearly done.

Now we have done the “Cloudflare-part”. The next step is to make sure that everything on your page uses HTTPS instead of HTTP to avoid “mixed content”-errors.

Some notes from my own “migration”:

  • If you have Google Analytics - make sure you change the property-settings to the HTTPS URL
  • If you use Disqus you need to migrate your comments from the HTTP url to the HTTPS URL. There is a migrate tool available, which uses a CSV file.

Other solutions…

As far as I know there are other, similar, providers out there and of course you can host the page yourself.

Cloudflare is an easy solution if you are willing to hand of the DNS settings of your domain.

Hope this helps!

CGI has interviewed 1000 executives and thats the outcome in a nutshell…

11.11.2016 14:59:57 | Sebastian Gerling

CGIs Global 1000 is one of CGI’s long lasting traditions in which we interview top executives from 10 different industries and 20 different countries about business and IT priorities. Following graphic does show the top 5 priorities for the upcomming years: More Details can be found here.

Empfehlung: SharePoint Such Tipps von Wolfgang Miedl

09.11.2016 10:03:17 | Sebastian Gerling

Wolfgang hat auf seinem Blog (SharePoint 360) einen super Artikel über Suchtipps in SharePoint veröffentlicht, der wirklich lesenswert ist und gerade für Endanwender in Unternehmen von großem Wert sein kann, um Zeit beim Suchen nach den richtigen Informationen zu sparen. Hier auch der Link zum direkten Download des PDF:

Slides von der EKON

09.11.2016 09:10:00 | Jörg Neumann

Hier die Slides & Samples meiner Talks von der EKON:



Building a home robot: Part 3 - the chassis

06.11.2016 19:26:00 | Daniel Springwald

(see all parts of "building a home robot")

If you want to build an autonomous robot there are at least two things to solve: Battery power and automatic charging.
Nobody wants to build a robot which needs to be charged by hand.  But building and programming a chassis that can find its docking station and charge automatic is complex and/or expensive.

So it is great that there is an existing consumer product you can use: The roomba vacuum robot from iRobot. You can get a used one for round about 150 €. If its vacuum or brush unit is broken it may cost less - and you don’t need these units.

The Roomba also supports an official and well documented serial port to control it and read its sensors.

So for my robot project I used an old iRobot Roomba.It was originally white color – but after some years of usage and sunlight some sort of ugly yellow instead.

To refurbish it I sanded it, painted it in my favorite color and bought a new battery.


In my case I wanted to use MakerBeans to build the main body of the home robot. So I mounted a small base of MakerBeans to the iRobot chassis. 

To find Roombas serial port you have to remove the robots cover. Next to the serial port there are some screws you can use to attach your own robot parts to the chassis:

 

 

Writing loops in T-SQL

01.11.2016 00:15:00 |

The topic is quite old, but I found it really helpful, so be warned.

Scenario: Iterate over a result set and insert it in a new table in T-SQL

I had to write a SQL migration script to move date from an old table into a new table with a new primary key.

Update! I discovered that my problem would have been solved with a much simpler SQL script (INSERT INTO x …(SELECT … FROM Y)). So my example here is pretty dumb - sorry if this confuses you, but I will keep the blogpost to show the mechanics. Thanks Mark!

Here was/is my resulting script using T-SQL Cursors:

DECLARE @TemplateId as uniqueidentifier;
DECLARE @UserId as uniqueidentifier;

DECLARE @OldTemplateFavCursor as CURSOR;

SET @OldTemplateFavCursor = CURSOR FOR
SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;
 
OPEN @OldTemplateFavCursor;
FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
 
WHILE @@FETCH_STATUS = 0
BEGIN
 INSERT INTO dbo.[UserFavoriteTemplate]
           ([Id]
           ,[TemplateId]
           ,[UserId])
     VALUES
           (NEWID()
           ,@TemplateId
           ,@UserId)

FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
END
 
CLOSE @OldTemplateFavCursor;
DEALLOCATE @OldTemplateFavCursor;

Explanation

In the first couple of lines we just declare some variables.

In this particular script we want to move the “TemplateId” & “UserId” from the table “UserTemplate” into the target table “UserFavoriteTemplate”, but I also want to store an additional GUID as Id.

This line will select our current data into the cursor:

SET @OldTemplateFavCursor = CURSOR FOR SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;

With the “OPEN”, “FETCH NEXT” and “CLOSE” we move the cursor and inside the “WHILE” we can do our migration.

The syntax seems (from a C# perspective) strange, but works well for this scenario.

Performance consideration

I wouldn’t recommend this approach for large scale migrations or actual production code because I heard that the performance is not as great as some clever joins or other T-SQL magic.

Make sure you really need this

You can do some clever joins with SQL - make sure you really need this approach. My example here is not a clever one, so use this feature wisely. (again - thanks to Mark for the comment!)

Thanks Christopher for your help!

Writing loops in T-SQL

01.11.2016 00:15:00 |

The topic is quite old, but I found it really helpful, so be warned.

Scenario: Iterate over a result set and insert it in a new table in T-SQL

I had to write a SQL migration script to move date from an old table into a new table with a new primary key.

Update! I discovered that my problem would have been solved with a much simpler SQL script (INSERT INTO x …(SELECT … FROM Y)). So my example here is pretty dumb - sorry if this confuses you, but I will keep the blogpost to show the mechanics. Thanks Mark!

Here was/is my resulting script using T-SQL Cursors:

DECLARE @TemplateId as uniqueidentifier;
DECLARE @UserId as uniqueidentifier;

DECLARE @OldTemplateFavCursor as CURSOR;

SET @OldTemplateFavCursor = CURSOR FOR
SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;
 
OPEN @OldTemplateFavCursor;
FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
 
WHILE @@FETCH_STATUS = 0
BEGIN
 INSERT INTO dbo.[UserFavoriteTemplate]
           ([Id]
           ,[TemplateId]
           ,[UserId])
     VALUES
           (NEWID()
           ,@TemplateId
           ,@UserId)

FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
END
 
CLOSE @OldTemplateFavCursor;
DEALLOCATE @OldTemplateFavCursor;

Explanation

In the first couple of lines we just declare some variables.

In this particular script we want to move the “TemplateId” & “UserId” from the table “UserTemplate” into the target table “UserFavoriteTemplate”, but I also want to store an additional GUID as Id.

This line will select our current data into the cursor:

SET @OldTemplateFavCursor = CURSOR FOR SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;

With the “OPEN”, “FETCH NEXT” and “CLOSE” we move the cursor and inside the “WHILE” we can do our migration.

The syntax seems (from a C# perspective) strange, but works well for this scenario.

Performance consideration

I wouldn’t recommend this approach for large scale migrations or actual production code because I heard that the performance is not as great as some clever joins or other T-SQL magic.

Make sure you really need this

You can do some clever joins with SQL - make sure you really need this approach. My example here is not a clever one, so use this feature wisely. (again - thanks to Mark for the comment!)

Thanks Christopher for your help!

Meetup in Muenchen: Gaming 2.0 – Welcome to the VR und AR Age am 17. November 2016

31.10.2016 10:22:54 | Kay Giza

Letzt Woche habe ich mit einigen über das Meetup am 17. November 2016 gesprochen, dort trifft sich zum ersten Mal der TUM Computer Science Club. Zum Start widmet sich das Meetup dem Thema Gaming 2.0. Dabei werden die neuesten Entwicklungen in der Spieleindustrie vorgestellt – AR und VR. Dabei kam die Frage auf, welche interessanten Meetups man noch so empfehlen könnte. Neben Meetups und User Group-Treffen gibt es natürlich noch zahlreiche weitere Events bzw. Veranstaltungen, auf die man hinweisen könnte. Meine Kollegen von TechWiese.de berichten regelmäßig über anstehende Community-Treffen. Daher hier auf Grund der Diskussion mal einige Beispiele, was so auf TechWiese.de zu finden ist... [... mehr auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
© Copyright 2006-2016 Kay Giza. All rights reserved. Legal

Slides von der ADC

26.10.2016 14:16:00 | Jörg Neumann

CGI startet Masterprogramm „Digital Business Management“

25.10.2016 11:38:55 | Sebastian Gerling

CGI sucht nach Masterstudenten, die berufsbegleitend an der Uni Reutlingen ihren Master of Science in Digital Business Management machen wollen. Dies ist der perfekte Einstieg in die Beratung und spannende Projekte im Bereich der Digital Transformation. Bei Interesse gerne bei mir melden – weitere Informationen könnt ihr hier finden: http://www.de.cgi.com/karriere/duales-master-studium-digital-business-management  

Workplace as a Service – das Modell der Zukunft?

19.10.2016 13:50:03 | Mathias Gronau

Auch der industrielle Mittelstand hat sich aufgemacht und ist auf dem Weg zur Digitalisierung. Wie dieser konkret aussehen kann, diskutieren wir aktuell mit rund 1.800 Teilnehmern auf der Deutschen Partnerkonferenz (#DPK16) in Bremen. Vor allem hohe Investitionskosten sowie eine fehlende IT-Infrastruktur schrecken viele mittelständische Unternehmen auf diesem Weg noch ab. So warnt die Investitionsbank KfW in ihrem Innovationsbericht davor, dass die mittelständische Wirtschaft das Potential der Digitalisierung bisher bei weitem nicht ausschöpft. Dabei nannte knapp ein Drittel der Mittelständler Finanzierungsprobleme als ein Digitalisierungshemmnis. Bereits im letzten Jahr warnte eine Studie im Auftrag des Bundesverbands der Deutschen Industrie, dass gerade deutsche Industrieunternehmen das Potential der digitalen Transformation verschenken würden – auch deshalb, weil sie nur sehr zurückhaltend in digitale Technologien investieren. Gründe für die geringe Investitionsbereitschaft liegen aber wohl weniger im fehlenden Kapital. Vielmehr schreckt auch die Schnelllebigkeit der digitalen Entwicklung ab: Technologien sind schnell veraltet und so kaufen heute beispielsweise 8 von 10 Unternehmen ihre IT-Leistungen extern ein. Mieten liegt im Trend und was für IT-Dienstleistungen längst Realität ist, erweitert „Workplace as a Service“ (WaaS) nun um die Hardware-Komponente. Mieten statt kaufen: „WaaS“ bietet neue Wege für die IT-Modernisierung Das neue Modell „Workplace as a Service“ bietet kleineren Firmenkunden nun die Möglichkeit, die eigenen Arbeitsplätze mit individuell konfigurierbaren Bundles der aktuellsten Hard- und Software auszustatten, indem sie diese über einen WaaS-Reseller mieten, anstatt sie zu kaufen. Unternehmen stellen sich ihren digitalen Arbeitsplatz nach den individuellen Anforderungen zusammen und kombinieren moderne Hardware mit Office 365, Windows 10 Enterprise und IT-Support. Die Händler vermieten die speziell konfigurierten Bundles für 12, 24 oder 36 Monate. Über das neue Mietmodell reagieren Firmen so noch flexibler auf aktuelle Trends und vermeiden hohe vorzufinanzierende Investitionen durch transparente und planbare Betriebskosten im Monat. Das bedeutet nicht zuletzt auch eine geringere Kapitalbindung. Unternehmen profitieren zudem durch eine stets aktuelle und sichere IT, die sofort verfügbar ist, sowie über weniger Unterhaltungsaufwand durch einen ausgelagerten Service. Surface Devices für Firmen jeder Größe ausleihbar Als fester Bestandteil des „WaaS“-Angebots erhalten Firmenkunden auch Zugriff auf „Surface as a Service“: „Workplace as a Service bietet unsere Surface Devices im Rundum-Sorglos-Paket“, so Andre Hansel, Senior Product Manager Surface Commercial bei Microsoft Deutschland. „Unternehmen mieten die aktuellsten Geräte der Surface-Reihe mit unseren modernsten Cloud- und Softwarelösungen. In Kombination mit Support-Services durch den Reseller bleiben die sensiblen Firmendaten so jederzeit bestmöglich geschützt.“ Als erster deutscher Partner bietet der B2B-Marketplace ALSO seinen Resellern zukünftig die Möglichkeit, das „SaaS“-Angebot für Firmenkunden über den ALSO Cloud Marketplace zu konfigurieren, bereitzustellen und zu verwalten. Aktuelle Premium-Bundles umfassen das Microsoft Surface Pro 4 (mit Type Cover, Office 365 und Surface Dock) für monatlich ab 47,96 Euro und das Surface Book (mit Windows 10 Enterprise E3 und Surface Dock) für monatlich ab 52,24 Euro. Über „WaaS“ erhalten Unternehmen ihre Surface Devices nicht nur inklusive der benötigten Software und IT-Infrastruktur von einem Partner, auch die Hardware-Versicherung zählt zum Komplettpaket: Das Surface Gerät wird bei Verlust oder Beschädigung innerhalb von 24 Stunden ersetzt. Sabine Hammer, Director Sales und Vorstandsmitglied der ALSO Deutschland GmbH erklärt […]

Interested in first experiences in international consulting area…?

19.10.2016 12:48:19 | Sebastian Gerling

We are activly looking for a working student  who will support our global accounts in growing business, standardizing processes and preparing VIP meetings. I am looking forward for your details. https://cgi.njoyn.com/cgi/xweb/xweb.asp?clid=21001&page=jobdetails&jobid=J1016-1495&BRID=EX497292&SBDID=1&LANG=4

Werder Bremen bietet Livestreaming mit Microsoft Azure

18.10.2016 12:20:17 | Mathias Gronau

Dass im Fußball ohne die Fans nichts geht, ist auch dem Management des SV Werder Bremen bewusst. Um die Fans noch enger an sich zu binden, setzt der Nord-Club auf Azure Media Services. Mit der Microsoft Cloud-Lösung kann der Erstligist sämtliche Werder-Ereignisse in Echtzeit und bester Studioqualität überall dorthin liefern, wo sich seine Fans gerade befinden. Werder-Fans können jetzt an jedem Ort und an jedem Screen die Spiele ihres Lieblingsclubs live verfolgen oder die besten Torchancen im Nachgang „on demand“ Revue passieren lassen – und sind ihrem Lieblingsclub stets so nah, wie am Spieltag im Weser-Stadion. Der SV Werder Bremen gehört zu den IT-Pionieren im Fußball und setzt schon seit mehr als 20 Jahren konsequent auf Digitalisierung und neue Medien. 1996 startete Werder als erster Bundesliga-Club seine eigene Webseite. In den letzten Jahren wurde „mobil, mobil, mobil“ zum Schlachtruf der Kommunikationsexperten des Bremer Bundesliga-Klubs. Schließlich entdecken durch die weltweite Vermarktung des Fußballs immer mehr Fans ihre Liebe zu Werder ohne die Möglichkeiten zu haben, täglich am Trainingsplatz vorbeizuschauen oder die Spiele im Weser-Stadion zu verfolgen. Sie wollen an jedem Ort und zu jeder Zeit die Partien ihres Lieblingsclubs verfolgen, die besten Torchancen Revue passieren lassen, die aktuellsten News lesen, das neueste Trikot kaufen oder die nächsten Tickets buchen. Deshalb hat der SV Werder den Bremer IT-Dienstleister und Microsoft-Partner team neusta im vergangenen Jahr mit dem Relaunch seiner gesamten Online-Welt beauftragt. Das Großprojekt ist nun an den Start gegangen und liefert in den ersten Monaten eine starke Performance. Optimale User Experience auf allen Endgeräten Sämtliche Portale des Nord-Clubs – von der Website, über das Streaming-Portal und den Online-Shop bis hin zu den mobilen Apps – wurden vollständig überarbeitet, um eine optimale User Experience auf allen Endgeräten zu schaffen. Das Ziel: Werder Fans sollen ihren Club überall, jederzeit und auf jedem Screen hautnah erleben können. Das gelingt am besten mit bewegten Bildern. Mit dem Einsatz der cloudbasierten Videostreaming-Lösung Azure Media Services kann der Erstligist jetzt sämtliche Werder-Ereignisse live und in bester Studioqualität überall dorthin liefern, wo sich seine Fans gerade befinden – ob zu Hause am Fernseher und PC oder unterwegs auf allen gängigen Mobilgeräten. Sobald die Kollegen von Werder-TV die Aufnahme beenden, ist das Ereignis auch schon auf sämtlichen Endgeräten „on demand“ verfügbar. Azure Media Services ermöglichen dem Verein, Veranstaltungen kosteneffizient zu produzieren und gleichzeitig zu streamen, aufzuzeichnen und zu codieren. Die skalierbare Azure-Plattform gewährleistet eine konstante, flexible Hochverfügbarkeit. Es wird nur die Rechenleistung eingesetzt, die auch benötigt wird. Bei Lastspitzen wird die Leistung entsprechend hochgefahren. So können beliebig viele Fans gleichzeitig den Stream verfolgen. Mit den voll vernetzten Fans Schritt halten „Genau wie Unternehmen sind Sportvereine auf eine agile und flexible IT angewiesen, um ihren voll vernetzten Fans ein optimales Vereinserlebnis bieten zu können“, sagt Oliver Gürtler, Senior Director der Cloud & Enterprise Business Group bei Microsoft Deutschland. „Durch den Einsatz von Cloud Computing nutzen sie Rechenkapazitäten und modernste Applikationen flexibel und entwickeln neue Geschäftsmodelle: zum Beispiel im Bereich Merchandising über Apps und digitale Kampagnen oder in den sozialen Netzwerken […]

Wir suchen: Functional Architect SAP Finance oder SAP BI (m/w)

17.10.2016 10:59:45 | Sebastian Gerling

Lust in einem spannenden Projektumfeld mit einem schnell wachsenden Team internationale Projekte im Umfeld SAP Finance oder SAP BI zu realisieren – ich freue mich auf eure Bewerbung. https://www.xing.com/jobs/muenchen-functional-architect-sap-finance-sap-bi-26901562?sc_o=as_c  

Sprache lernen als Teil der Integration

05.10.2016 21:22:32 | Mathias Gronau

In einem Punkt sind wir uns vermutlich einig: Sprache ist ein wichtiger Schlüssel zur erfolgreichen Integration. In Deutschland stehen derzeit Hundertausende Flüchtlinge vor der Herausforderung, Deutsch zu lernen – Erwachsene wie Kinder. In Berlin stellte Microsoft heute die neue Schlaumäuse- Sprachlernsoftware vor, die speziell für Flüchtlingskinder weiterentwickelt wurde. Die bereits vielfach ausgezeichnete Anwendung ist ab sofort als Universal App auch auf Arabisch, Englisch und Französisch verfügbar. Mit der kostenlosen Schlaumäuse-App können jetzt auch Kinder ganz ohne Deutschkenntnisse spielerisch die deutsche Sprache entdecken und selbständig üben. Die neue Version wurde im Rahmen eines Treffens von Microsoft CEO Satya Nadella mit Kindern einer Berliner Willkommensklasse erstmals gezeigt. Damit möglichst viele Menschen die Möglichkeiten neuer Technologien nutzen können, setzt sich Microsoft Philantropies auf der ganzen Welt für Zugang, Teilhabe und Bildung ein. Ein Schwerpunkt des humanitären Engagements von Microsoft ist die Unterstützung von NGOs und Regierungsorganisationen bei der Flüchtlingsarbeit. „Sprache ist ein essentieller Faktor, um in einem fremden Land Fuß zu fassen. Mit der Initiative Schlaumäuse möchten wir die vielen tausend Kinder, die auf der Flucht vor Krieg oder Verfolgung sind, dabei unterstützen, Deutsch zu lernen und sich leichter in der Gesellschaft und später in der Arbeitswelt zurechtzufinden. Das Programm zeigt, wie Technologie eingesetzt werden kann, um gesellschaftliche Herausforderungen anzugehen und einen wichtigen Beitrag zur Integration zu leisten“, erklärt Sabine Bendiek, Vorsitzende der Geschäftsführung von Microsoft Deutschland. Spielerisch die deutsche Sprache entdecken und selbständig üben Unter den vielen Flüchtlingen in Deutschland sind auch tausende Kinder, die schon viel Zeit auf ihrem Bildungsweg verloren haben. Sie müssen sich nun so schnell wie möglich in einer anderen Kultur, in einem neuen Bildungssystem und in einer fremden Sprache zurechtfinden. Hier setzt die neue, kostenlose Version der Schlaumäuse-App an. Sie richtet sich an Kinder im Alter von fünf bis neun Jahren und ist ab sofort auch auf Arabisch, Englisch und Französisch verfügbar. Damit können jetzt auch Kinder ohne Deutschkenntnisse spielerisch die deutsche Sprache entdecken und selbständig üben. Wie das genau funktioniert, ließ sich Microsoft-Chef Satya Nadella heute von Berliner Grundschülern einer Willkommensklasse zeigen. Die App soll Lehrer und Erzieher bei der Arbeit mit Flüchtlingskindern unterstützen Mit der neuen Schlaumäuse-App, die speziell auf die Bedürfnisse von Flüchtlingskindern zugeschnitten ist, möchte Microsoft auch Lehrer und Erzieher bei ihrer täglichen Arbeit unterstützen. In Zusammenarbeit mit Schulen, Kindergärten, Verbänden und ehrenamtlichen Organisationen im Bereich der Flüchtlingshilfe wird das Sprachlernprogramm bundesweit ausgerollt. Zum Start der Initiative übergab Microsoft die ersten von insgesamt 500 Starterpaketen an das neu gegründete House of Resources Berlin, einer vom Bundesamt für Migration und Flüchtlinge (BAMF) geförderten Initiative, die Ressourcen für verschiedene Hilfsorganisationen bereitstellt. „Die Bereitschaft der Menschen in Deutschland, sich für Flüchtlinge zu engagieren, ist nach wie vor sehr hoch. Aber um mehr zu erreichen, mangelt es vielen Initiativen an technologischen Möglichkeiten. Deshalb ist ein Engagement wie das von Microsoft richtungsweisend“, sagte Ana-Maria Stuth, Vorsitzende der Akademie für Ehrenamtlichkeit Deutschland und Leiterin des House of Resources, die in Berlin das erste mit der neuen Schlaumäuse-Software ausgestattete Tablet entgegennahm.

Microsoft Cloud Deutschland: Azure IaaS-, PaaS- und IoT-Dienste aus deutschen Rechenzentren verfügbar

05.10.2016 20:32:58 | Mathias Gronau

Dass Microsoft eine rein deutsche Cloud aufgesetzt hat, dürfte wohl allgemein bekannt sein. Heute hat Microsoft eine Erweiterung der Funktionalitäten der Cloud bekanntgegeben. Jetzt bietet Microsoft Public-Cloud-Infrastruktur-, Plattform- und IoT-Dienste aus deutschen Rechenzentren in Frankfurt/Main und Magdeburg Datenspeicherung ausschließlich in Deutschland, Datenaustausch über ein privates, vom Internet getrenntes Netzwerk, Kontrolle des Zugriffs auf Kundendaten durch deutschen Datentreuhänder, der deutscher Rechtsordnung unterliegt: T-Systems International Unter dem Namen Azure Deutschland stehen Infrastruktur-, Plattform- und IoT-Dienste der Microsoft Cloud-Plattform Azure ab sofort auch aus deutschen Rechenzentren in Frankfurt/Main und Magdeburg zur Verfügung. Das Angebot richtet sich an Geschäftskunden aus Deutschland, der EU sowie der Europäischen Freihandelszone (EFTA). Die neuen Services ermöglichen auch streng regulierten Branchen ihre digitale Transformation erfolgreich mit Public-Cloud-Lösungen voranzutreiben – von Big- Data- und Machine-Learning-Szenarien bis hin zum Internet der Dinge. Die souveräne Microsoft Cloud Deutschland kombiniert die georedundante Speicherung von Kundendaten in Deutschland mit einem Datentreuhandmodell: Der Datentreuhänder kontrolliert den Zugang zu den Kundendaten und ist ein unabhängiges Unternehmen mit Hauptsitz in Deutschland, das der deutschen Rechtsordnung unterliegt: T-Systems International, eine Tochter der Deutschen Telekom. Mit der Einführung der neuen Rechenzentrumsregionen in Deutschland hat Microsoft weltweit 34 Azure-Rechenzentrumsregionen, von denen bereits 30 in Betrieb sind. Das Datentreuhandmodell ermöglicht den Kunden eine Datenkontrolle, die es an anderer Stelle vermutlich nicht gibt. Der Zugang zu den Kundendaten liegt beim Datentreuhänder T-Systems International: Ohne Zustimmung des Datentreuhänders oder des Kunden erhält Microsoft keinen Zugriff. Wird diese Zustimmung durch den Datentreuhänder erteilt, greift Microsoft nur unter dessen Aufsicht zeitlich begrenzt auf die Kundendaten zu. „Die Microsoft Cloud Deutschland ist unsere Antwort auf die wachsende Nachfrage nach Microsoft Cloud-Diensten in Deutschland und Europa. Azure Deutschland unterstützt unsere Kunden dabei, zukunftsfähige Lösungen zu entwickeln und gleichzeitig ihre Compliance-Richtlinien einzuhalten“, sagt Sabine Bendiek, Vorsitzende der Geschäftsführung von Microsoft Deutschland. Trusted Cloud: Sicherheit, Datenschutz, Compliance und Transparenz Die Microsoft Cloud Deutschland basiert auf Microsofts weltweiten Trusted Cloud-Prinzipien: Sicherheit, Datenschutz, Compliance und Transparenz. Die deutschen Rechenzentren nutzen die gleichen Technologien und bieten die gleichen Service-Level und Sicherheitsstandards wie die globalen Microsoft-Cloud-Angebote. Dazu gehören Multi-Faktor-Authentifizierungen, biometrische Scans, Smartcards, Datenverschlüsselungen nach SSL/TLS-Protokollen, physische Sicherheitsmaßnahmen, Sicherungen gegen Naturkatastrophen und Stromausfälle. Um die Ausfallsicherheit (Business Continuity) und die Wiederherstellung von Daten und Diensten (Disaster Recovery) in Notfällen zu gewährleisten, findet ein kontinuierlicher Datenabgleich zwischen den beiden deutschen Rechenzentren statt. Für die Verschlüsselung und Absicherung des Datenverkehrs setzt Microsoft auf die D-Trust-Zertifikate der Bundesdruckerei GmbH. Azure Deutschland bietet SAP-Integration, Industrie-4.0-Standard und Open-Source-Unterstützung Mit Infrastrukturdiensten, wie virtuellen Maschinen, Storage Premium und Netzwerkkomponenten, ergänzt durch Plattform-Angebote wie SQL-Datenbanken oder Web Apps, bietet Azure Deutschland bereits zum Marktstart eine umfassende Palette an Services. Nach meinem Wissen hat kein anderer Anbieter zum Start so viele Dienste angeboten. Das ermöglicht „einfache“ Geschäftsszenarien wie Test- und Entwicklungsumgebungen ebenso wie komplexe Anwendungen: Geschäftskunden haben mit der Zertifizierung von SAP HANA für Microsoft Azure die Möglichkeit, ihre sensiblen Daten nun auf Azure Deutschland bearbeiten und speichern zu lassen. Das verringert den Installations- und Betriebsaufwand, die Infrastrukturkosten und verkürzt die Time-to-Market für neue Produkte. Für die Umsetzung von Big-Data-, Machine-Learning- und Industrie-4.0-Szenarien […]

Regeln | Impressum