Arndt Dibi

The series so far:

1. SQL Server Machine Learning Services – Part 1: Python Basics
2. SQL Server Machine Learning Services – Part 2: Python Data Frames
3. SQL Server Machine Learning Services – Part 3: Plotting Data with Python

If you’ve spent any time with the R language in SQL Server R Services or Machine Learning Services (MLS), you’re no doubt aware of the important role that data frames can play in your scripts, whether working with data that comes from a SQL Server database or from another source. The same is true for Python. You use data frames when passing data sets into and out of a script as well as when manipulating and analyzing data within that script.

This article focuses on using data frames in Python. It is the second article in a series about MLS and Python. The first article introduced you briefly to data frames. This article continues that discussion, describing how to work with data frame objects and the data within those objects.

Data frames and the functions they support are available to MLS and Python through the pandas library. The library is available as a Python module that provides tools for analyzing and manipulating data, including the ability to generate data frame objects and work with data frame data. The pandas library is included by default in MLS, so the functions and data structures available to pandas are ready to use, without having to manually install pandas in the MLS library.

This article includes a number of examples that leverage the pandas library to demonstrate various data frame concepts, using data from the AdventureWorks2017 sample database. As you’ll recall from the first article, you can specify a T-SQL query when calling the sp_execute_external_script stored procedure and then incorporate the data returned by that query into your Python script. The examples that follow all use the same T-SQL query, allowing us to focus specifically on the Python scripts and data frame concepts.

Introducing the data frame

The pandas library supports a variety of data structures. The two most commonly used for analytics are Series and DataFrame. The Series data structure is an indexed, one-dimensional array whose values can be any Python data type, including strings, integers, floating point numbers, and other Python objects. The DataFrame data structure is an indexed, two-dimensional array that includes one or more columns, similar to an Excel spreadsheet or SQL Server table. All columns in a data frame are Series objects of the same length.

To better understand the Series and DataFrame data structures, take a look at the following example, which calls the sp_execute_external_script stored procedure, passing in a Python script and T-SQL query:

Use AdventureWorks2017;
GO

-- define Python script
DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], as_index=False).sum()

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return aggregated data set
print(df2)
OutputDataSet = df2';

-- define T-SQL query
DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

-- run procedure, using Python script and T-SQL query
EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS(
    (Territories NVARCHAR(100), OrderMonths NCHAR(3), TotalSales MONEY));     
GO

If you reviewed the first article in this series, most of the elements should look familiar to you. The example first defines the Python script, saving it to the @pscript variable, and then defines the T-SQL query, saving it to the @sqlscript variable. Both variables are passed in as parameter values when calling the sp_execute_external_script stored procedure. The procedure call also specifies the Python language and the name and type of the columns in the output data set.

Refer to the first article in this series if you have questions about working with the sp_execute_external_script stored procedure.

With that in mind, let’s return to the example above, starting with the first statement in the Python script, which imports the calendar module and assigns the cl alias to the module:

import calendar as cl

The calendar module provides tools for working with date values. When you import a module in this way, you can use its data structures and functions in your Python script by referencing the alias.

After importing the module, the Python script assigns the data in the InputDataSet variable to the df1 variable:

df1 = InputDataSet

As you’ll recall from the first article, the InputDataSet variable provides access to the SQL Server data returned by the T-SQL query specified when calling the sp_execute_external_script stored procedure. By default, the variable is defined as a DataFrame object, which means that the df1 variable is also created as a DataFrame object, as is the df2 variable.

After assigning the data to the df1 variable, the script groups and aggregates the data in the df1 data set and then assigns the data set to the df2 variable:

df2 = df1.groupby(["Territories", "OrderMonths"], as_index=False).sum()

A DataFrame object such as df1 or df2 provides a number of functions for working with the data frame and its data. One of these functions is groupby, which you call by adding a period after the DataFrame object (in this case, df1) and then specifying the function name.

The first argument you pass to the function is the column or columns on which to base the grouping. When specifying multiple columns, you must enclose the column names in brackets and separate them with a comma. In this case, the data will be grouped first by the Territories column and then by the OrderMonths column.

The second argument you pass to the groupby function is as_index, which is set to False. This argument is related to how data frames are indexed and how Python returns data frame values. We’ll get into these topics more in a bit. Just know you must set this option to False to ensure that the values from the Territories and OrderMonths columns are returned to the calling application along with the aggregated sales data. The setting also ensures that the data is returned in ‘SQL-style,’ according to the pandas document pandas.DataFrame.groupby.

After specifying the groupby function, you must then tag on an aggregate function that specifies how the data should be summarized. In this case, the sum function is used to find the sales totals for each month for each territory.

One other note about the working with DataFrame functions: If calling a function outside of the context of a DataFrame object, you must first import the pandas module, using a statement such as the following:

import pandas as pd

You can then use the module’s alias when calling the specific function. For example, if you want to create a series, you can use the Series function:

data = ["one", 2, "three", 4.3456]
 ds = pd.Series(data)

The function generates a Series object based on the data variable. The object is then assigned to the ds variable. Python will also automatically generate an integer-based index for the Series object, starting with 0.

As noted earlier, each column in the data frame is a Series object. You can test this out by including a statement similar to the following in your script:

print(type(df2["Territories"]))

The type function returns the data type of the Territories column and the print function returns the data type to the console, confirming that the variable’s type is pandas.core.series.Series.

After aggregating the data, the Python script converts the OrderMonths values to a more readable format. If you run the T-SQL query in the above example separately from the stored procedure, you’ll see that the OrderMonths column returns numerical values to represent the months (the integers 1 through 12). To make the output more readable, the Python script creates a lambda function to convert these values into abbreviated month names:

df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

A lambda function is simply an anonymous, unnamed function. To use a lambda function to convert values in a column, you first specify the column by providing the data frame name followed by the column name, enclosed in brackets. Next, you tag on the pandas apply function, which tells Python to run the lambda function against every value in the specified column.

The lambda function is passed as an argument to the apply function. The function definition begins with the keyword lambda, followed by the x variable and a colon. The function definition then calls the month_abbr function from the calendar module (using the cl alias) and passes the x variable in as an argument, enclosed in brackets. In this way, the month_abbr function will be applied to each of the column’s integers, changing them to month abbreviations.

The final part of the Python script includes two statements that return the final data frame. The first statement uses the print function to return the data frame to the console:

print(df2)

The following figure shows how the returned data looks in SQL Server Management Studio (SSMS).

The first column, which is unnamed, is the data frame’s index. As with Series objects, Python generates the index automatically, starting with 0; however, you can change the index, reset it, or designate one of the columns as the index. The important point to remember is that a data frame, by default, is automatically assigned an index, which can be a factor when manipulating and analyzing data.

The final statement in the Python script assigns the df2 variable to the OutputDataSet variable:

OutputDataSet = df2

The OutputDataSet variable is the default variable used to return the script’s data to a calling application. Like the InputDataSet variable, the OutputDataSet variable is defined as a DataFrame object. The implication of this is that, when working with Python in SQL Server, you must pass your data to the OutputDataSet variable as a DataFrame object in order to return that data to a calling application. The following figure shows part of the data set returned by the OutputDataSet variable.

The integers shown in the first column are the row number labels used by SSMS. These values are not the index. The index is not included in the results. To include the index in the OutputDataSet results, you should use the reset_index function to turn that index into a column. For example, you can include the following statement in your script:

df2.reset_index(inplace=True)

The reset_index function turns the existing index into a column and generates a new index. For this example, the function takes only the inplace argument, which is available to a number of functions. When set to True, the argument tells Python to update the data frame in place, without needing to reassign the data frame to itself or assign it to a new variable.

Also note that the results shown in the above figure include the Territories and OrderMonths columns. If you had set the as_index argument to True or had not included the argument when calling the groupby function, the results would include only the TotalSales column.

You can retrieve information about a data frame by calling its properties. For example, the following Python script retrieves the column names and dimensions of the df2 data frame:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], as_index=False).sum()

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return information about data df2 data frame
print(list(df2.columns.values))
print(df2.shape)
print(len(df2.index))';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript;     
GO

The first print statement uses the list function and columns.values property to return a list of the columns in the df2 data frame. The shape property returns the data frame’s dimensions (number of rows and columns). The index property returns the data frame’s index. If you use the index property in conjunction with the len function, you’ll get the number of values in the index. (The len function returns the number of items in an object.) The Python scripts returns the following results:

['Territories', 'OrderMonths', 'Sales']
(120, 3)
120

The DataFrame class supports a wide range of properties (attributes) and functions (methods), making it possible to work with data in a variety of ways. For more information about the DataFrame class, see the topic pandas.DataFrame in the pandas documentation.

Adding columns to a data frame

Whether your data frames are based on SQL Server data or come from another source (or are a combination of both), there might be times when you’ll want to add columns. One way to do this is to aggregate the same source column in two different ways when calling the groupby function, as shown in the following example:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return df2 data set
OutputDataSet = df2';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), 
    OrderMonths NCHAR(3), AvgSales MONEY, TotalSales MONEY));     
GO

You should call the groupby function just like you did in the previous examples, but rather than tagging on the sum aggregate function at the end of the groupby function call, you specify the agg function, passing in a dictionary (dict) value as an argument. The dictionary value specifies the Sales column and two aggregate functions, mean and sum. The following figure shows part of the results that the Python script returns.

The data set now includes the AvgSales and TotalSales column, which are both based on the Sales column in the df1 data frame.

You can also insert columns into a data frame more directly, without having to define another aggregation. For example, the following Python script generates TargetSales sales, a computed column that adds 18% to the TotalSales values:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return df2 data set
OutputDataSet = df2';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3),
    AvgSales MONEY, TotalSales MONEY, TargetSales MONEY));     
GO

Before adding the column, I assigned names to the columns in the df2 data frame. I took this step to make it easier to reference those columns later in the script, which is especially beneficial when working with aggregated columns. (The pandas library also provides methods for naming aggregated and non-aggregated columns individually, but we’ll save that topic for a separate discussion.)

Instead of naming columns, you can reference columns by their internal index, but that can sometimes add more complexity than necessary. Personally, I prefer the readability that comes with using actual names.

To add column labels, first call the columns property on the df2 data frame and then assign the appropriate values to the property, providing each column name in the order the columns appears. You should enclose the column names in brackets and separate them with commas.

After renaming the columns, you can add the new column. Start by specifying the df2 data frame, followed by the new column name in brackets. Then set its value to an expression that calculates the values for the new column. In the example above, the expression simply multiples the TotalSales values by 1.18. The following figures shows part of the results now returned by the Python script.

Whenever you change your data frame in a way that will impact the columns retuned by the Python script, be sure to update the WITH RESULT SETS clause as necessary when calling the sp_execute_external_script stored procedure.

Filtering data in a data frame

The pandas library provides a variety of methods for filtering your data frame. For example, the following Python script uses the head function to return the first five rows from the data set:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return top five rows
OutputDataSet = df2.head(5)';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3),
    AvgSales MONEY, TotalSales MONEY, TargetSales MONEY));     
GO

To call the head function, you need only tag it onto the DataFrame object, optionally specifying the number of rows to return. If you don’t specify a number, Python will return five rows. The following figures shows the results returned by the Python script.

The pandas library also includes the tail function, which works the same way as the head function, except that it filters out all but the last rows in the data frame, instead of the first.

You can also specify which columns to retain in a data set:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific columns
OutputDataSet = df2[["Territories", "OrderMonths", "TotalSales"]]';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3), TotalSales MONEY));     
GO

When including multiple columns, enclose them in a second set of brackets and separate the column names with commas. Python will then filter out all but the specified columns. The following figure shows part of the script’s results.

You can also add the head or tail function after specifying other filter criteria:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific columns, last five rows
OutputDataSet = df2[["Territories", "OrderMonths", "TotalSales"]].tail(5)';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3), TotalSales MONEY));     
GO

Now the returned data set includes only three columns and last five rows, as shown in the following figure.

In addition to columns, you can filter rows out of a data frame, based on conditional expressions you specify when calling the columns. For example, the following statement filters out all rows except those with a Territories value of France and TotalSales value greater than 500000:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific rows
OutputDataSet = df2[(df2["Territories"] == "France") & (df2["TotalSales"] > 500000)]';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3),
    AvgSales MONEY, TotalSales MONEY, TargetSales MONEY));     
GO

The first expression compares the Territories values to France, using the equals (==) comparison operator. The second expression compares the TotalSales values to 500000, using the greater than (>) comparison operator. Each expression is enclosed in parentheses and separated with the and (&) conditional operator, which indicates that both expressions must evaluate to true for a row to be included in the results, as shown in the following figure.

As an alternative to what we’ve seen so far, the pandas library provides a set of functions that also make it possible to filter data in a data frame. The functions include at, iat, loc, and iloc. The pandas documentation recommends using these functions when possible because they are optimized for data access. For information about these functions, see the pandas document Indexing and Selecting Data.

One of the most valuable of these functions is loc, which lets you filter out columns, rows, or both. The following syntax provides a simple overview of how to use the function:

<DataFrame>.loc[<rows>, <columns>]

You specify row information as the first argument and column information as the second argument, separating the two by a comma. If you specify column information without row information, you need only include a colon for the first argument:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific columns
OutputDataSet = df2.loc[:,["Territories", "OrderMonths", "TotalSales"]]';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3), TotalSales MONEY));     
GO

The statement filters out all but the Territories, OrderMonths, and TotalSales columns. The following figure shows part of the results returned by the Python script.

If you want to filter out only rows, you can use the colon placeholder for the second argument or leave it off altogether. The following example includes the placeholder:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific rows
OutputDataSet = df2.loc[(df2["Territories"] == "France") &
  (df2["TotalSales"] > 500000),:]';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3),
    AvgSales MONEY, TotalSales MONEY, TargetSales MONEY));     
GO

Now the script returns all columns, but only few rows, as shown in the following figure.

To filter out both rows and columns, you can include both sets of criteria in one statement when using loc:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# return specific columns and rows
OutputDataSet = df2.loc[(df2["Territories"] == "France") & (df2["TotalSales"] > 500000),
  ["Territories", "OrderMonths", "TotalSales"]]';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3), TotalSales MONEY));     
GO

As the following figure shows, the results are now leaner still.

Be sure to review the pandas documentation for more information about the different ways you can filter data in a data set. Consider what we’ve covered here as only the beginning.

Adding rows to a data frame

Earlier in this article, you saw how to add columns to your data frame. With pandas, you can also add rows. In the following example, the Python script generates a new data frame based on filtered data and then adds a row to the data frame:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# calculate sales averages and totals for each territory and month
df1 = InputDataSet
df2 = df1.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})

# assign column names and add computed column
df2.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df2["TargetSales"] = df2["TotalSales"] * 1.18

# change month numbers to abbreviated month names
df2["OrderMonths"] = df2["OrderMonths"].apply(lambda x: cl.month_abbr[x])

# define the df3 data frame and add row
df3 = df2.loc[(df2["OrderMonths"] == "Jun") & (df2["TotalSales"] > 500000),
  ["Territories", "AvgSales", "TotalSales"]]
row = ["Australia", 8257.1674, 830092.7536]
df3.loc[len(df3)] = row
df3 = df3.sort_values(by="Territories")

# return the df3 data set
OutputDataSet = df3';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), AvgSales MONEY, TotalSales MONEY));
GO

To create the new data frame, the script uses the loc function to filter out all rows except those with an OrderMonths value that equals Jun and a TotalSales value greater than 500000. The function also filters out all but the Territories, AvgSales, and TotalSales columns. The filtered results are then assigned to the df3 variable to create the new data frame.

After defining the df3 data frame, the script specifies the values for the new row and saves them to the row variable. The script then uses the loc and len functions to set the value of the new row. The len function returns the number of rows in the data frame, and the loc function interprets that number as an index value for the new row.

This works because the index starts with 0, so the highest index number before the row is added is 3. The new row is added with an index value of 4 because the index size is four. As a result, the new row is inserted after all the other rows, which means that the territory names are no longer in alphabetical order. To fix this, you can call the sort_values function on the df3 data frame, specifying the name of the Territories column. The Python script now returns that data set shown in the following figure.

As you can see, the script returns a small data set that includes only five rows and three columns, just what we were after, with the values nicely sorted by territory name. The new row for Australia is included.

Removing a column from a data frame

You might also run into situations when you want to remove a column from a data frame. One way to do this is to use the loc function to filter out the column and then reassign the data frame to itself or a different variable. Another approach is to use the drop function available to the DataFrame class, as shown in the following example:

DECLARE @pscript NVARCHAR(MAX);
SET @pscript = N'
import calendar as cl

# define the df1 data frame
df1 = InputDataSet.groupby(["Territories", "OrderMonths"], 
  as_index=False).agg({"Sales": ["mean", "sum"]})
df1.columns = ["Territories", "OrderMonths", "AvgSales", "TotalSales"]
df1["TargetSales"] = df1["TotalSales"] * 1.18
df1["OrderMonths"] = df1["OrderMonths"].apply(lambda x: cl.month_abbr[x])
df1 = df1.loc[df1["TotalSales"] > 800000]
df1 = df1.sort_values(by="TotalSales", ascending=False)

# remove AvgSales column
df1.drop("AvgSales", axis=1, inplace=True)

# return df1 data set
OutputDataSet = df1';

DECLARE @sqlscript NVARCHAR(MAX);
SET @sqlscript = N'
  SELECT t.Name AS Territories, MONTH(h.OrderDate) AS OrderMonths,
    CAST(h.Subtotal AS FLOAT) AS Sales
  FROM Sales.SalesOrderHeader h INNER JOIN Sales.SalesTerritory t
    ON h.TerritoryID = t.TerritoryID
  WHERE YEAR(h.OrderDate) = 2013;';

EXEC sp_execute_external_script
  @language = N'Python',
  @script = @pscript,
  @input_data_1 = @sqlscript
  WITH RESULT SETS((Territories NVARCHAR(100), OrderMonths NCHAR(3),
    TotalSales MONEY, TargetSales MONEY));   
GO

This time round, I consolidated some of the script, although at this point, you should be well familiar with most of these elements. The only new construct is the statement that uses the drop function to remove the AvgSales column.

When calling the function, first specify the name of the column that should be dropped. Next, add the axis argument, setting its value to 1. This indicates that you’re dropping a column, not the index (which would be 0). The inplace argument comes next. As you saw earlier, it tells Python to update the data frame in place. The Python script returns the data set shown in the following figure.

As the example demonstrates, the drop function provides yet another way to remove a column from a data frame. When working with pandas and Python, you’ll find that there are often a number of different ways to carry out a task. You might have to do some digging to figure out the best approach, but sometimes it’s just a matter of preference. The better you understand pandas and Python, the better you’ll understand the options you have available to work with the data.

Making the most of the data frame

There is, of course, a great deal more to data frames and the pandas library than what we’ve covered here, but this should provide you with a foundation for getting started so you can strike out on your own. The best way to acquaint yourself with Python, pandas, and data frames is to play around with data sets in your Python scripts and experiment with the various ways you can manipulate and analyze data.

As we progress through this series, we’ll dig more into the Python language and pandas library and some of ways you can work with data. Your understanding of data frames will be instrumental in your ability to move forward with MLS and Python and to perform advanced data analytics.

The post SQL Server Machine Learning Services – Part 2: Python Data Frames appeared first on Simple Talk.

As a data person you’ve likely looked, with some envy, at the cool new multiplatform tools Microsoft has released for your developer coworkers. Visual Studio Code, or VS Code, is an open source application which will run on Windows, macOS, and Linux, allowing software development for a variety of languages. You’ve probably thought, “Hey, where’s OUR multiplatform tool for working with data?” Well, have I got good news for you!

Microsoft has just released SQLOPS – SQL Operations Studio – in preview mode. Built on top of VS Code, it is designed to manage your SQL Server from multiple platforms. SQLOPS runs on Windows, macOS, and Linux. Best of all, it is absolutely free to use.

Downloading SQLOPS

Before you rush off and download it, there is a word that needs to be stressed. PREVIEW. The tool is essentially in beta. This means there will be features that might not be quite complete, and you will likely encounter bugs. You are using this at your own risk, and you should expect frequent updates to the product. As a result, installation on your production systems is probably not a good idea.

As you will see, there are some features that make it worth looking at now. Using the tool is simple, and low risk, as technically there is no true install. You simply download it, extract the files, and start using it. To download, just go to https://docs.microsoft.com/en-us/sql/sql-operations-studio/download or you can use the shortcut http://bit.ly/sqlops. When you do, you’ll see this on the page:

From here, select the version appropriate to your operating system. Once it’s downloaded, installation is very simple.

Installation on a Mac

To install on a Mac, be sure to navigate to the site and download the file. Once the file is downloaded, simply select Open in Finder and unzip the file.

With the downloads folder open, simply drag and drop (or copy and paste) into the Applications folder.

Then, just double click on the SQL Operations Studio icon to open it. (Note this Mac has the Show file extensions option enabled, yours may not show the .app extension at the end. It’s still the same program.)

And there you go, you are ready to connect to your SQL Server!

Installation on Windows

Installation on Windows is even simpler. First, you will create a folder on your hard drive that will hold the application. Unlike most windows applications, SQLOPS does not have a traditional installer. On this Windows installation, C:\SqlOps was created.

Once you have it downloaded, just go to your downloads folder. Double click on the sqlops-windows-0.23.6.zip file (note the file name will change as new versions are released, use the file name that you downloaded). It will open another folder with the contents of the ZIP file.

Drag and drop (or copy and paste) the sqlops-windows folder to your C:\SqlOps (or wherever you created your target folder). Once there, navigate to the sqlops-windows folder.

Double-click sqlops.exe to run it. If the connection window doesn’t appear when you open SQLOPS, simply click on the New Connection icon.

Fill out the connection information and click Connect. Unlike other tools, this version doesn’t provide a dropdown list of databases, so you must type in a valid database name.

Installation on Linux

Installation on Linux turns out to be almost as simple. The download page has a bash script you can run to extract the files once they have been saved to your system. Be aware that depending on the version of Linux you run, there may be additional dependencies you have to install. Due to the wide variety of Linux distributions there are too many combinations to attempt to document here; just follow the instructions on the download site for your version of Linux.

The SQLOPS Interface

By this point, you’ve installed SQLOPS on your operating system and have filled out the connection information. Once you are connected to your server, you should see something like this (note the numbers were added to enable discussion of the layout):

The area denoted by the red number 1 is the Servers pane, also known as the Object Explorer in some online documentation. Expanding the server branch (in this example localhost), then Databases, will present a list of the databases. The Object Explorer serves the same function here as it does in SSMS (SQL Server Management Studio). It provides a way to navigate the various objects on your SQL Servers, drilling down and providing menus to launch other operations like editing data or executing queries.

In SSMS, when you connect to a server the area to the right is empty. With SQLOPS though, you can see a nice dashboard. The area in green, number 2, is the dashboard header. It gives an overview of the server including the SQL Server version, edition of SQL, computer name, and OS (Operating System) version.

The next area, number 3, are shortcuts to common tasks. At the server level, the three most common tasks are restoring a database, configuring your server, and creating a new query. As later versions of SQLOPS are developed, you may see other tasks in this area as new functionality is brought to the application. Below the tasks pane is area 4, which shows the backup status of your various databases.

To the right is area 5, the search pane. This provides a quick way to find various objects on your server. Just begin typing and it will narrow the list of databases to match what you are keying in.

Finally, the very bottom is area 6. This shows a graph comparing the sizes of your various databases. This screen capture is cut off due to size limitations, but it just allows you to get a quick at a glance comparison of size between your various databases.

On the very left is a big gray bar with some icons. Let’s take a quick look at it.

The top brings up the panel you’d already seen, the Servers (aka the Object Explorer). The next button down is the Task History. If you had performed any backups, restores, or other similar tasks you could reference them in this area. Below this is the Explorer pane. The Explorer pane has a list of all open files in the SQLOPS editor. It offers some useful options, so let’s take a closer look at it.

The Explorer pane contains list of all open files. To the right of the file name is the full path to the file. Right clicking on the file provides a rich context menu. Most of the options, such as Save and Close, are pretty obvious in their functionality but a few do warrant further explanation.

Open to the Side opens the file in split screen, so you can compare two files side by side in SQLOPS. Reveal in Explorer opens up an Explorer window in your computers operating system. Open in Terminal opens up a terminal window in the lower half of the SQLOPS application, by default it is PowerShell, but it can also be changed to a Command Prompt (CMD), or a BASH terminal. This may vary by operating system, for example on macOS you wouldn’t have the option for a CMD window. You can also open a terminal window by using the View menu in the toolbar, and selecting Integrated Terminal.

The Search pane brings up a pane that can be used to search, or search and replace, text in the current editor window. Below this is the Source Control pane, this allows you to manage your various files within your source code control system.

Way down at the bottom is a big gear icon. This allows you to alter the various settings of SQLOPS, such as the keyboard shortcuts, color theme, and more.

Running Queries

At this point you should have a good overview of the SQLOPS interface. Let’s start doing some actual work and do one of the most common things, running a query. From the Servers pane, expand your databases, then expand one database, then the tables for that database. For this example, I’ll be using the WideWorldImportersDW database.

NOTE: WideWorldImporters is a new sample database introduced with SQL Server 2016. If you don’t have it, you can download the backup file or source code from GitHub. There are multiple databases as part of the sample, for this article we’ll be using the data warehouse version (WideWorldImportersDW).

Right click on a table, and chose the Select Top 1000 option.

If you’ve worked with SSMS, the following screen should look familiar. Like SSMS, the query is at the top, and the results at the bottom. Unlike SSMS, which has the Results and Messages on separate tabs, SQLOPS places the messages just below the results. From here you can make changes to the query and re-run it, save your query, and perform other actions you’d normally do with a SQL file. There are two areas though that should be called out. The first is the Explain button, highlighted in red in the above image.

Clicking Explain brings up the query plan. While this is of course possible in SSMS, SQLOPS makes it much more convenient to run. Hovering over any item in the query plan brings up more details about that item.

The other area you should notice is to the right of the results, highlighted in green in the image showing the query results. From top to bottom, the first three are Save as CSV, Save as JSON, and Save as Excel. This is a great addition, allowing you to easily save your data for other purposes.

The final option is View as Chart. For the data in the previous SELECT 1000 query the option won’t provide anything meaningful, so let’s look at an example that will. In the Servers pane, right click on your database and pick New Query. Then, paste in the query below, assuming you are using the WideWorldImportersDW sample database.

SELECT d.[Calendar Year]
     , SUM(s.[Total Including Tax])
  FROM [WideWorldImportersDW].[Fact].[Sale] s
  JOIN [WideWorldImportersDW].[Dimension].[Date] d
    ON s.[Invoice Date Key] = d.[Date]
 GROUP BY d.[Calendar Year]
 ORDER BY d.[Calendar Year]

Run the query, and view the results at the bottom. Now press the chart button, as indicated by the giant red arrow.

Ta-da! A chart which neatly summarizes the results of your query appears. If you expand the Chart Type on the right, you’ll see many different charts are available. Play with it to see what the results are for the various types. One thing to be aware of, the chart viewer works best when there are a limited number of categories, as in this example, the years. If you have a lot of categories, for example hundreds of customers, the chart will be unreadable and not very useful.

Help Writing Your Queries

All of us have SQL syntax we use on a regular basis. But what about times when you are writing SQL queries that you don’t normally run? Often, you wind up doing internet searches to remind yourself of the correct syntax, or hunt for previous scripts where you used a similar query. Well SQLOPS has a great tool to help you out. Return to the Server pane, right click on your database, then pick New Query. In the empty editor, type sql, and see what pops up!

SQLOPS has an extensive library of snippets built in. A snippet is a code template that has the basics for a command. Let’s narrow it down some, keep typing adding Se after the code you have already typed.

As you can see, the snippet popup narrows itself down to those options with SE in the name. Since sqlSelect is already highlighted, just hit the TAB key on your keyboard.

You’ll see TableOrViewName is highlighted. Just type City, and you’ll see it updates both the TableOrViewName in the comment, as well as in the query itself. Hit the TAB key, which will highlight SchemaName. Simply type in Dimension, and it will also update both the comment and the query. From here you can edit your query normally, adding to the WHERE clause (or removing it), adding a GROUP BY, and whatever else you’d like to do. Then, you can run your query. This provides a very efficient way of writing your queries, especially for query types you don’t work with on a regular basis.

Peeking into Your Database

When writing queries, a common need is to know more information about the objects you’re working with. Let’s return to the previous example, where we generated a SELECT * query. Now you want to limit the query to a few columns. Sure, you could jump over the Server pane, and navigate down to the database, then the table, then the columns. It would be much more efficient though if you could jump right to the definition of the object. That’s where the peek functionality comes into play.

In the query editor, put your cursor on the table name, and right click. On the menu, pick Peek Definition.

A small window opens under the item you peeked. The definition for the table appears within. You can copy columns out of the window, as well as review the definition. Peek works for more than just tables, it can also be used with stored procedures, functions, and other similar objects. To close the peek window, just click on the x in the upper right of the peek window.

The other option is Go to Definition. This will open a new tab with the definition of the object (in this example the City table). From there you can alter, run, or anything else you’d normally do in a SQL window.

Summary

In this article, we explored SQLOPS – SQL Server Operations Studio. SQLOPS is the new open source, multiplatform tool for working with SQL Server. We began by seeing how easy it is to install, then showed the interface. Next, we looked at some common tasks such as editing queries, then reviewed the cool snippets feature. Finally, we looked at how to ‘peek’ into your database. Although still in preview, SQLOPS already has many features that make it a worthy addition to your toolkit.

If you’d like to see the actual code behind SQLOPS, you can get it from Microsoft’s github site, https://github.com/Microsoft/sqlopsstudio

The post A Walk Around SQL Operations Studio appeared first on Simple Talk.

Die Hamburger Ermittler haben hat über 100 Fotos und Videos von Teilnehmern der G20-Krawalle veröffentlicht. Hinweise aus der Bevölkerung sollen bei der Fahndung helfen.

This week we released several improvements to the Outlook connector, including saving an email as a ".eml" file, responding to calendar invitations automatically, and triggering flows when you are mentioned in an email thread. We have also made it easier to work with multiples by remembering your most recently used connections, and, have released five new connectors: Azure Container Instances, Azure Kusto, Metatask, Microsoft To-Do, and Plumsail Documents.

Comments

Windows Hello ließ sich offenbar mit einem speziell angefertigten Foto austricksen, zumindest, wenn die Gesichtserkennung verwendet wurde. Das Gute an der Sache ist, dass dieser Trick längst nicht mehr funktioniert.

Sicherheitsexperten der SySS GmbH haben herausgefunden, dass sich Windows Hello austricksen lässt mit einem speziellen Foto. Dafür wird eine frontale Infrarotaufnahme der Person benötigt, die Eigentümer des PCs ist. Diese wird daraufhin mit einem Laserdrucker auf Papier gedruckt in der Größe eines Gesichts mit einer 320 x 320-Auflösung. Dabei wurden auch der Kontrast des Bildes sowie die Helligkeit verändert, damit der Trick funktionieren konnte.

Legte man das Bild vor einen PC mit Windows Hello-Gesichtserkennung, wurde es als der Eigentümer des PCs erkannt, sodass der Login umgangen werden konnte.

> Windows Hello-Kamera im Blitzangebot bei Amazon

Trick funktioniert nicht mehr

Microsoft wurde im Oktober 2017 darüber informiert und man stand in sehr engem Kontakt mit dem deutschen Unternehmen. Die Redmonder hatten das Problem allerdings – ohne davon zu wissen – bereits im April 2017 behoben, denn der Trick funktioniert nicht mehr. Schon mit Windows 10 Version 1703, nämlich dem Windows 10 Creators Update, kann die Windows Hello-Gesichtserkennung nicht ausgetrickst werden. Im Windows 10 Fall Creators Update sowieso nicht, denn auch hier wurde die Sicherheit offenbar verbessert. Hierbei ist wichtig zu erwähnen, dass dafür das „Enhanced Anti-Spoofing“-Feature aktiviert sein muss, das allerdings bei allen Geräten standardmäßig eingeschaltet ist. Ihr müsstet es also manuell deaktivieren, sodass der Trick funktioniert.

Windows Hello-Gesichtserkennung ist sehr sicher

Interessant ist, dass die Funktion erst nach zweieinhalb Jahren zum allerersten Mal überlistet werden konnte. Bislang galt die Windows Hello-Gesichtserkennung als unknackbar, denn mit Fotos der Person konnte man die Erkennung des PC-Eigentümers bislang nie hereinlegen.

Dass nun ein Mechanismus gefunden wurde, welcher das Austricksen von einer Windows 10-Version aus dem Jahr 2016 erlaubt, ist unserer Meinung nach nicht besorgniserregend. Eher ist es beeindruckend, dass es so lange gedauert hat.

Das iPhone X ist bislang die einzige Referenz, welches Gesichtserkennung nutzt und diese konnte bereits häufiger manipuliert werden. Einerseits scheint sie weniger zuverlässig zu funktionieren, andererseits konnte sie durch Fotos geknackt werden. Während Apple behauptet hatte, dass die Gesichtserkennung am iPhone X höchstens von „bösen Zwillingen“ manipuliert werden kann, wurden selbst die oben abgebildeten Geschwister ohne allzu großer Ähnlichkeit als dieselbe Person erkannt.

> Windows Hello-Kamera im Blitzangebot bei Amazon

---

via Dr. Windows

Der Beitrag Windows Hello-Gesichtserkennung lässt sich nicht mehr mit Foto austricksen erschien zuerst auf WindowsArea.de.

Seagate will die Kapazität von Festplatten in den nächsten Jahren weiter erhöhen. 2030 sollen HDDs mit 100 TB erhältlich sein.

Die nun vorliegende Folge 3 hinkte im Zeitplan – im Gegensatz zu allen anderen Folgen – leider erheblich hinterher. Grund waren ungewöhnlich viele Verzögerungen, wie sie immer wieder auftreten können (die deutsche Bahn lässt grüßen). Hier die Quellen aller bisherigen Videos:

Klima-Video Teil I, Teil II, Teil III

Energiewende-Video Teil I, Teil II

Eine zweite Quelle nur für die Klima-Videos bietet der Video-Kanal des technischen Erstellers Klaus Maier

1. Video: https://youtu.be/aYtpOtM1UGM
2. Video: https://youtu.be/iqoGlewQBzQ
3. Video: https://youtu.be/d9d2iQTLf4I

Natürlich können alle Videos auch direkt auf der EIKE-Webseite erreicht werden. Dazu auf „Videos“ (ganz oben) gehen und nochmals „Videos“ klicken. Die Folge 3 der Klima-Videos beschäftigt sich nunmehr mit

• Meeresversauerung und Koallensterben?
• Der CO2 – Gehalt der Luft und die Erdtemperaturen über 0,5 Millarden Jahre bis heute.
• Steuert der CO2 – Gehalt der Luft die Erdtemperatur oder ist es umgekehrt?
• Das Rasiermesser von Ockham.
• Ist der jüngste Anstieg des CO2 menschgemacht?
• Näheres zum globalen CO2 Zyklus.
• CO2 zweitstärkstes Treibhausgas nach dem Wasserdampf und dennoch kein maßgebender Verursacher der jüngsten globalen Erwärmung – wie erklärt sich das?.
• Die Schlüssel-Rolle der Wolken beim Treibhauseffekt.
• Unzuverlässige Klimamodelle als Rettungsanker der Alarmisten.
• Klimaschutz gehört in den Müll der Geschichte!

Verbreiten Sie auch die dritte Folge wieder – falls sie Ihnen zusagt – so weit wie möglich unter Ihren Freunden und Bekannten!

Anmerkungen zu den fachlichen Grundlagen der Klima-Videos

Bereits Teil 2, aber insbesondere jetzt Teil 3, nehmen sich der mehr komplexen Zusammenhänge an, indem sie diese veranschaulichen und auch dem Laien näherbringen. Diese Themen sind für den Klima-Disput absolut maßgebend.

Ein Disput wird zwar in der wissenschaftlichen Fachliteratur geführt, von Medien und Politik wird er aber salopp als „überflüssig“ weggewischt. Gültig sind dort nur die alarmistischen Aussagen von wenigen ausgesuchten „Fachexperten“ (argument from authority), die ihre wissenschaftliche Neutralität politischen Zielen unterordnet haben. Unsere Bemühungen in EIKE bestehen darin, die dringend erforderliche öffentliche Klimadiskussion endlich in Gang zu setzen.

Um in den Klima-Videos korrekt berichten zu können, ist Kenntnis der Fachliteratur unabdingbar. Wer hat die aber schon, die Sache ist mühsam und zeitraubend. Ziel unseres Videoprojekts bestand infolgedessen darin, diesen Schritt dem Zuschauer zu ersparen. Korrekte, von ihm nachprüfbare, auf Basis der Fachliteratur gemachte Aussagen der Videos sollen es ihm dennoch ermöglichen, sich eine eigene unabhängige Meinung zu bilden.

Die Tendenz von Fachpublikationen kann man in „klima-alarmistisch“, „klima-skeptisch“ oder „anderes“ einteilen. Die weit überwiegende Anzahl aller referierten Klimapublikationen beschäftigt sich überhaupt nicht mit dem vermuteten Klima-Einfluss des Menschen. Sie gehört zu „anderes“. Sogar derjenige Teil des IPCC-Sachstandsberichts AR5, der das Thema „Extremwetterentwicklung“ behandelt, gehört zu „anderes“. Es geht hier nämlich nicht um einen anthropogenen Einfluss, sondern nur um Extremwetter-Messungen. Von vielen Teilen der IPCC-Berichte kann man das leider nicht behaupten. Sie sind klima-alarmistisch, insbesondere die indiskutablen IPCC-Berichte für Politiker.

Was die Berücksichtigung klima-alarmistischer und klima-skeptischer Fachstudien für die Videos angeht, bemühten wir uns besten Wissens und Gewissens um Objektivität. Es erstaunt daher vielleicht, dass kein Argument für einen anthropogenen Klimaeinfluss in den Videos vorkommt. Dies liegt schlicht daran, dass bis heute keine klima-alarmistische Studie aufzufinden ist, die fachlich ausreichende Substanz besitzt, um in ihrer Aussage ernst genommen zu werden. Insbesondere Klimamodelle sind als Zeugen ungeeignet.

Die klimaskeptischen Argumente in den Videos stützen sich auf Fachstudien von weltweit renommierten Klimawissenschaftlern, die als Skeptiker einer maßgebenden anthropogenen Klimaerwärmung bekannt sind. Zu diesen zählen neben vielen weiteren Fred Singer, Richard Lindzen, Jong-Sang Choi, Nir Shaviv, Hendrik Svensmark, Jan Veizer, Garth Paltridge,  Francois Gervais, Vincent Courtillot, Willie Soon, Roy Spencer, John Christy, Ross McKittrick, R.A. Pielke, Christopher Essex, Nicola Scafetta …. mehrere mit dem Autor persönlich bekannt und einer ein Freund des Autors. Es sind die fachlichen Zeugen unserer Klima-Videos.

Die Fach-Zuständigkeit des Drehbuchautors der Videos kann (hier) eingesehen werden. Da er bereits rund 10 begutachtete (peer reviewed) Klima-Fachpublikationen vorgelegt hat, darf er als Klimaforscher gelten. „Von der Pike auf“ war er es nicht. Sein Berufsweg als Physiker hat ihn aber in Spezialgebiete verschlagen, die in (einem Zweig) der Klimaforschung von Nutzen sind und ohne die seine peer reviewed Klima-Fachveröffentlichungen nicht möglich gewesen wären.

Erstellung und Verfügbarkeit der Videos

Die Klimavideos sind von allen Beteiligten in freiwilliger Arbeit ohne finanzielle Zuwendungen von irgend einer Seite erstellt worden. Sie sind frei verfügbar und können auf jeder Webseite verlinkt werden. Lediglich Kürzungen, Veränderungen oder eigene Hinzufügungen der Inhalte sind ausgeschlossen.

So wurden die drei Klima-Videos beispielsweise von der AfD der Öffentlichkeit  in AfD Kompakt vom 28.Nov.2017 zur Kenntnis gebracht (s. den dort angegebenen Link am Ende des zweiten Absatzes). Grund dafür war die Übereinstimmung der in den Klimavideos gemachten Sachaussagen mit denen des AfD-Parteiprogramms zum Thema „Klimawandel“.

Es sei an dieser Stelle betont, dass die Erstellung der 3 Klimavideos nicht auf Veranlassung irgend einer Institution erfolgte. Sie sind auch keine EIKE-Produkte. Veranlassung waren Diskussionen mit Zuhörern in zahlreichen Fachvorträgen des Verfassers und die Bekanntschaft des Verfassers mit seinem kongenialen Kollegen Klaus Maier. Schlussendlich dürfen nicht die unzähligen Freunde und Bekannten der beiden Video-Ersteller vergessen werden, deren Kritik an Form und Inhalten des Projekts zu vielen Verbesserungen führte. All ihnen sei an dieser Stelle herzlich gedankt.

Es soll nicht verschwiegen werden, dass die gewählte Dialogform der Videos – je nach Alter des Kritikers – zu oft sehr gegensätzlichen Beurteilungen führte. Ausschlag für uns gab dagegen letztendlich das Nutzen/Aufwand – Verhältnis, welches hier am höchsten war. Nur so konnten wir die Videos ohne nennenswerten finanziellen Aufwand erstellen. Es kam uns auf den Inhalt an. Falls unser „Opus“ daher vielleicht nicht immer den heutigen Zeitgeschmack für „fetzige“ Videos trifft, möge man es uns nachsehen.

Die beiden Energiewende-Videos sind dagegen reine EIKE-Produkte, technisch erstellt von einem Profi und dem zugehörigen Drehbuch des Autors folgend.

Wie geht es weiter?

Geplant ist ein Video über die Kernenergie – ebenfalls in Dialogform. Eigentlich hätte man dieses Video zuerst erstellen müssen, denn es gibt kaum ein Thema, über welches hierzulande so viel Desinformationen verbreitet werden, wie über die friedliche Nutzung der Kernkraft.

Als ich im Amtsgericht die Stufen erklomm und einen Blick auf den Eingang zum Sitzungssaal werfen konnte, schwante mir das Unheil schon. Vor dem Saal saß niemand – obwohl für den Termin etliche Zeugen geladen waren. Auf der Ankündigungstafel, auch Terminsrolle genannt, waren wir schon gar nicht verzeichnet.

Tja, sagte der Richter zu mir: „Die Sache um 12.30 Uhr ist aufgehoben worden. Schon letzte Woche.“ Viel mehr war ihm nicht zu entlocken. Wofür ich auch Verständnis hatte; er leitete ja gerade den vorherigen Verhandlungstermin. Ich vermute mal, dass die Abladung dann morgen oder übermorgen in der Briefpost ist.

Glücklicherweise handhaben es die meisten Gerichte etwas geschickter. Sie schicken ein Fax. Oder rufen gar mal kurz an. Aber immerhin hatte ich noch Glück im Unglück. Zu dem Amtsgericht fahre ich nur zehn Minuten, und auf dem Rückweg liegt eines meiner Lieblingsestaurants.

Earlier, I wrote on a new technet article that details migration to Office 365 groups from on prem public folders. Actually walking through that I noticed some inconveniences I figured I could improve on with a script. The main one being that the endpoint in Office 365 only supports a single Public Folder, excluding child folders.

So I wrote up a script (with resume support) that will map your Public Folders to O365 Groups and migrate them in as many batches as are required, fully automated.

You’ll end up with a nice csv file with all the details. Note:

1. this script expects you to know what you’re doing!
2. only tested with Exchange 2010 as source
3. everything on prem is left untouched
4. groups are not mail enabled, and security settings are not copied
5. contacts are not copied
6. make sure you read the code/in-script instructions between line 1 and line 48, and then if you’re curious, from line 71720

https://gitlab.com/Lieben/assortedFunctions/blob/master/archivePublicFoldersToOffice365Groups.ps1

update 05/01: improved the connection status check + reconnect for remote ExO and fixed report file path auto generation

update 11/01: moved everything to start-job so exchange sessions are always isolated (no prompting after 1-2 days) and added total migration overview display 

update 25/01: exported the remote exchange module and added it as inline code with a modification so it won’t prompt for credentials, nothing else seems to otherwise prevent such prompts. This means the module may not match Microsoft’s if they update Exchange Online. Let me know if that causes issues for you or re-create it yourself with export-pssession and replace.

Comments

How to integrate single sign on with ownCloud SAML SSO: Make your users happy by providing single sign on for your ownCloud instance.

Der Beitrag How to Integrate SAML Single Sign-On in ownCloud App erschien zuerst auf ownCloud.

Comments

Comments

Comments

Pöbeleien und Hetze im Netz können strafbar sein. Eine neue Einheit des LKA mit speziell gesicherten Computern soll solche Straftaten jetzt auch durch Bürgerhinweise finden - und verfolgen. (Polizei, Internet)

1. Das arktische Eis hat sich im vorigen Jahrzehnt stabilisiert

Tony Heller berichtet auf seinem Blog hier, dass das Volumen des arktischen Meereises während der letzten 10 Jahre um 15% zugenommen hat, nämlich von 13.000 km³ auf 15.000 km³, und dass es zu einer gewaltigen Ausdehnung von dickem Eis in die Ostsibirische See hinein gekommen war. Heller hat diesen Zuwachs in einer Schaukelgraphik eindrucksvoll veranschaulicht. Sie zeigt den Unterschied von vor 10 Jahren und heute:

[Bemerkung: Es handelt sich um eine animierte Schaukelgraphik, was sich hier nicht reproduziert darstellen lässt. Die Originalgraphik mit dem Wechselbild steht hier. Anm. d. Übers.]

Den Prophezeiungen zufolge sollte während der letzten 10 Jahre genau das Gegenteil passieren, nämlich ein Schrumpfen um 15%. Klimawissenschaftler, die vor einer Beschleunigung des Abschmelzens im ersten Jahrzehnt dieses Jahrhunderts gewarnt hatten, bleiben jetzt verblüfft und sprachlos zurück.

2. Ein La Nina-Ereignis im äquatorialen Pazifik wird die Abkühlung einleiten

Die EL Nino Southern Oscillation (ENSO), eine Maßzahl zur Darstellung der Wassertemperatur im äquatorialen Pazifik, hat inzwischen ihr kältestes Niveau seit Jahren erreicht und bereitet den Weg für eine weitere globale Abkühlung während der kommenden Monate. Noch vor wenigen Monaten haben Experten ein weiteres wärmendes El Nino-Ereignis prophezeit. Sie lagen falsch. Außerdem spricht die jüngste Vorhersage dafür, dass sich La Nina-Bedingungen bis weit in das nächste Frühjahr hinein ziehen werden:

3. Rapide Abkühlung im Pazifik

Die Oberflächentemperatur im äquatorialen Pazifik (wo sie wirklich zählt) ist seit Juni dieses Jahres 2017 um 1 bis 2 K gesunken, wie Hurrikan-Experte Phillip Klotbach jüngst twitterte:

Und weil es eine Zeitverzögerung von rund 6 Monaten gibt zwischen der Wassertemperatur des Ozeans und der via Satelliten gemessenen globalen Lufttemperatur an der Erdoberfläche stellt das La Nina-Ereignis sicher, dass 2018 global ein kälteres Jahr wird.

4. Ungewöhnliche November-Kälte in Sibirien

Schaut man nach Sibirien, tritt unerwartete Kälte in Erscheinung, wobei die Temperaturen in vielen Gebieten Sibiriens um rund 11 K unter die Mittelwerte gesunken sind. Der Weather Channel berichtet hier: „In einigen Gebieten Sibiriens war es kälter als [umgerechnet] rund minus 50°C, und das bereits im November!“

Prognostiker warnen jetzt davor, dass diese Kälte sich demnächst nach Nordamerika und Europa ausbreiten könnte.

[Wieder so ein Konjunktiv, wenn auch diesmal mit umgekehrtem Vorzeichen. In Nordamerika ist die Kälte zwar schon angekommen, aber nicht aus Sibirien. Und in Mitteleuropa…? Anm. d. Übers.]

6.Herbstliche Schnee- und Eisbedeckung auf der Nordhemisphäre nimmt zu

Die Schnee- und Eisbedeckung auf der Nordhemisphäre im Monat lag Ende Oktober um 20% über dem Mittelwert. Tatsächlich war das Mittel der letzten fünf Jahre für Oktober das höchste Mittel eines Zeitraumes von fünf Jahren seit Beginn regelmäßiger Messungen vor 50 Jahren:

Quelle

Gleiches gilt für den Monat November: Auch in diesem Monat gab es während der letzten 30 Jahre einen robusten Aufwärtstrend der Schnee- und Eisbedeckung.

7.Sonnenaktivität auf einem 200-Jahre-Tiefpunkt

Während des gegenwärtigen Sonnenzyklus‘ Nr. 24 lag die Sonnenflecken-Aktivität auf ihrem niedrigsten Niveau seit fast 200 Jahren. Anfang des 19 Jahrhunderts befand sich die Erde noch im Griff des Dalton-Minimums, einer Kaltperiode mit ähnlich geringer Sonnenaktivität:

Abbildung: Akkumulierte Sonnenflecken-Anomalie vom Mittel der 23 vorangegangenen Zyklen – bis 107 Monate in den neuen Zyklus hinein.

Der gegenwärtige Sonnenzyklus 24 ist der drittschwächste seit Beginn systematischer Beobachtungen der Sonnenzyklen im Jahre 1755. Nur die Zyklen Nr. 5 und 6 (1798 … 1823 während des Dalton-Minimums) waren noch schwächer. Eine Reihe bedeutender Wissenschaftler und Dutzende wissenschaftlicher Veröffentlichungen warnen, dass die Erde tatsächlich in eine globale Abkühlungsperiode gerät. Der nächste Sonnenzyklus 25 wird den Erwartungen zufolge ebenfalls sehr schwach ausfallen.

Steht ein großer Ausbruch des Agung-Vulkans bevor?

Alles in allem gibt es noch weitere Anzeichen, die darauf hindeuten, dass die Abkühlung bereits im Gange ist oder unmittelbar bevorsteht. Obige Auflistung enthält lediglich einige Beispiele. Nicht vergessen sollte man einen möglichen Ausbruch des Agung in Indonesien. Ein großer Ausbruch würde die globalen Temperaturen ein paar Jahre lang in den Keller drücken.

Unter dem Strich: Verfallen Sie angesichts all des Hypes um eine Runaway-Erwärmung nicht auf den Gedanken, dass der Planet geröstet wird. Es gibt viel unerwartete Kälte um uns herum – Kälte, die es nie geben dürfte. Und das Einzige, was man von Alarmisten zu hören bekommen wird, um diese Kalamität zu erklären, sind viele Entschuldigungen.

Link: http://notrickszone.com/2017/12/03/7-major-signs-the-globes-surface-has-been-cooling-and-will-continue-to-cool/#sthash.IgKg7Kyg.dpbs

Übersetzt von Chris Frey EIKE

Am späten Samstagabend wurde eine 42-Jährige von zwei Jugendlichen verfolgt und ausgeraubt. 

Das erste Smartphone mit Fingerabdruckleser unter dem Displayglas kommt jetzt wirklich. Es stammt aber weder von Apple noch von Samsung.

Fingerabdruckleser unter dem Display werden 2018 Realität

Seit Jahren arbeiten Samsung, Apple und andere Hersteller an einer besseren Integration biometrischer Authentifizierungsmethoden in Smartphones, um Ergonomie und die Nutzererfahrung zu verbessern. Apple hat sich mittlerweile gegen einen Fingerabdrucksensor entschieden und will fortan auf seine 3D-Gesichtserkennung in den nächsten iPhone- und iPad-Generationen setzen.

Bei Samsung scheint es nicht sicher zu sein – beim Galaxy S9 wird wohl erst einmal weiterhin auf einen rückseitigen Fingerabdrucksensor mit besserer Positionierung gesetzt, obwohl Synaptics als langjähriger Partner endlich den Durchbruch bei Unter-Display-Fingerabdrucksensoren geschafft hat. Ein anderer großer Player hat nun aber vor Samsung eine erstes Smartphone mit dieser Lösung angekündigt: Vivo.

Vivo mag hierzulande kaum bekannt sein, allerdings gehört das Unternehmen zu den fünf weltweit größten Smartphone-Herstellern, hinter Oppo, Huawei, Apple und Samsung. Mit dem 0,7 Millimeter dünnen Synaptics FS9500 „Clear ID“-Sensor ist es endlich möglich, den Fingerabdrucksensor unter OLED-Displayglas zu verfrachten und den Scanner frontseitig zu positionieren und gleichzeitig ein nahezu rahmenloses Smartphone zu konstruieren. Es handelt sich dabei um einen optischen Sensor, bei dem das OLED-Display für den Scanprozess punktuell beleuchtet wird. Der Scanner überprüft das angefertigte Bild des Fingerabdrucks und gewährt bei authentifiziertem Abdruck Zugriff aufs Smartphone.

Fingerabdruckleser unter Displayglas: Schneller als Apples Face-ID

In einem Beitrag auf Forbes.com erläuterte Analyst Patrick Moorhead seine ersten Erfahrungen mit einem Vorserien-Gerät. Er beschreibt den Sensor als „schnell und einfach“. Laut Hersteller Synaptics sei der Scanner doppelt so schnell wie eine 3D-Gesichtserkennung, etwa wie Apples Face-ID. Dem Hersteller zufolge sei der Fingerandruckleser zwei bis dreimal günstiger als Apples 3D-Gesichtsscanner.

Vivo dürfte nicht das einzige Smartphone-Unternehmen sein, der sich den neuen Fingerabdruckleser von Synaptics zunutze machen wird. Samsung, als langjähriger Partner des Unternehmens, könnte ihn eventuell verwenden, auch wenn es im Sommer hieß, dass die Südkoreaner sich von Synaptics abgewandt hätten. Vielleicht sehen wir die Technologie auch im Oneplus 6 oder einem Huawei P11?

Here are some pics @anshelsag and I took of the Vivo smartphone with the Synaptics in-display fingerprint reader. The CMOS image sensor is .7mm thick and reads the fingerprint right through the OLED display. The experience was faster than I expected. pic.twitter.com/u1NFpXtFQM

— Patrick Moorhead (@PatrickMoorhead) December 14, 2017

Weiterlesen:

• Fingerabdruck-Spezialist, den Samsung nie kaufte, ist ein Hit
• Fürs Galaxy S8? Synaptics stellt Fingerabdrucksensor vor, der hinter Glas funktioniert
• Samsung Galaxy S9: Das soll das Smartphone-Topmodell an Bord haben – und so soll es aussehen

Teilweise resultiert diese Unsicherheit aus der unbekannten Geschwindigkeit, mit der Autonome Fahrzeuge (AVs) sich entwickeln werden, unterliegt dies doch nicht der Kontrolle der Regierung, und teilweise aus den hohen Stromkosten aufgrund der Klimapolitik. Das Herbst-Budget 2017 hat den echten Willen gezeigt, die Kosten der Politik zu limitieren, aber eine Bestimmung zur Kostensenkung könnte erforderlich sein, um die Entwicklung von AVs zu beschleunigen.

Ich bin gerade zurück aus Tokio, wo ich Vorträge über die Britische Energiepolitik gehalten habe. Ein Thema, das in meinen Vorträgen nicht zur Sprache kam, wohl aber wiederholt in den nachfolgenden Diskussionen mit japanischen Analysten, war die Stärke und Ernsthaftigkeit des Versprechens von Außenminister Michael Gove, um nicht elektrisch betriebene Fahrzeuge auslaufen zu lassen (hier). – Man fragte mich oft „wird UK dies tatsächlich und pünktlich versuchen?“ Wie es mir scheint, lautet die Antwort, dass zwar UK nicht den Zeitplan einhalten könnte, dies aber dennoch versuchen wird, und dass das Interesse an dieser Technologie groß ist. Natürlich ist es vollkommen richtig, die Verkündung mit Mr. Goves eigenen politischen Interessen aufzurechnen, aber Elektrofahrzeuge sind wirklich vielversprechend, schon aufgrund der Tatsache, dass die Elektrifizierung jedweder Prozesse an sich interessant und wünschenswert ist.

Außerdem schneiden britische Städte beim Vergleich der Luftgüte in denselben schlecht ab gegenüber Städten in anderen entwickelten Ländern. Japan beispielsweise hat anders als die EU Dieselfahrzeuge für den Personentransport abgelehnt und begrenzt deren Betrieb in urbanen Gebieten sogar hinsichtlich der Auslieferung von Gütern (es gibt dort sehr strikte „kein-Leerlauf“-Bestimmungen). Die Elektrifizierung einiger Transportmittel würde einen echten Unterschied ausmachen und wäre möglicherweise in der britischen Öffentlichkeit populär, vor allem hinsichtlich des Umstandes, dass der Enthusiasmus für Diesel einst EU-Politik war, im Zusammenhang mit dem VW-Skandal jetzt jedoch nicht nur fehlgeleitet, sondern auch korrupt ist.

Aber welche realistischen Aussichten gibt es hinsichtlich der Zunahme von EVs bei uns und international? Einige Hinweise auf eine Antwort können in den Fossil Fuel Price Projections (30.11.17) der UK-Regierung gefunden werden, findet sich doch darin eine nützliche synthetische Graphik, welche verschiedene Prophezeiungen zusammenbringt bzgl. des Ersatzes des Ölverbrauchs durch EVs:

Bis zum Jahre 2030 sehen die verschiedenen Studien eine Reduktion von nicht mehr als 4 mb [million barrel] pro Tag voraus, verglichen mit einer vorhergesagten globalen Nachfrage zu jener Zeit zwischen 90 und 109 mb pro Tag. Dies ist offensichtlich eine moderate Reduktion, und das Arbeitsministerium sagt dazu, was ziemlich verständlich ist: „Selbst unter den optimistischsten Szenarien sieht BEIS keinen Beweis, dass das Volumen von Rohöl im Jahre 2030 ausreicht, die Preise im Jahr 2030 vollkommen umzugestalten“.

Nach dem Jahr 2025 ist das hervorstechendste Merkmal der Schätzungen der Grad, mit dem sie divergieren. Man sollte daraus ablesen, dass es dabei große Unsicherheiten gibt. Dies ist kaum überraschend, aber es ist gut, dies jetzt schwarz auf weiß vor sich zu haben.

Hinter dieser Unsicherheit stehen mindestens zwei grundlegende Faktoren. Erstens, die Schwierigkeit der Abschätzung des Tempos, mit der Autonome Fahrzeuge AVs für die Märkte sicher und attraktiv werden. Um wirklich erfolgreich zu sein, werden EVs zu AVs werden müssen, also zu Fahrzeugen, welche ihre Passagiere befördern und dann selbst an zentralen Ladestationen mit Netzanbindungen hoher Kapazität aufgeladen werden können. So werden die hohen Kosten der Einrichtung lokaler Verteiler-Netzwerke umgangen, welche das Aufladen zu hause erlauben.

Zweitens und viel problematischer für die Elektrifizierung des Transportwesens ist neben anderen Maßnahmen die Tatsache, dass die Klimapolitik den Stromsektor so schwer preislich belastet mittels Vorschrift zur Erzeugung des Stromes aus Erneuerbaren, dass die hohen Kosten die Elektrifizierung in allen Bereichen einschließlich des Transportwesens behindern werden.

Diese peinliche Lage wird zu einem Test werden der Verpflichtung der Regierung bzgl. EVs, um nicht zu erwähnen, wie ernst es Mr. Gove meint. Falls es eine elektrische Zukunft für das Transportwesen auf der Straße gibt, muss der Strom billig sein. Angesichts der Bestimmung im Herbst-Budget, dass es keine neuen Subventionen geben werde, dürfte die gegenwärtige Politik so etwas kaum zuwege bringen. Dazu wären weitere Maßnahmen hinsichtlich der Kosten der bestehenden Politik zwingend erforderlich.

Link: https://www.thegwpf.com/42069-2/

Übersetzt von Chris Frey EIKE

Sicherheitsforscher haben Windows Hello erfolgreich ausgetrickst und sich an damit gesicherten Computern angemeldet. Das funktioniert aber nur mit bestimmten Hard- und Softwarekonstellationen.

Gehostet wird am liebsten in der Cloud. Die bringt allerdings einige Herausforderungen und Fragen mit. Ein Interview über die vielen Facetten des Hosting-Marktes – und worauf es ankommt.

Managed Root-Server, deutsche Rechenzentren und 24-7-Geschäftskundenservice – was viele Jahre als Standard für businesskritische Projekte galt, gestaltet sich in den letzten Jahren mit zunehmender technologischer Geschwindigkeit immer undurchsichtiger. Was ist überhaupt der Unterschied zwischen Private-, Public- und Hybrid-Cloud und ist da Docker und Kubernetes schon mit drin? Was brauche ich als Betreiber einer E-Commerce-Plattform oder eines großen Online-Portals überhaupt und warum sollte ich nicht einfach direkt zu Google Cloud oder Amazon AWS gehen, wo doch alle so vom „echten“ Cloud-Hosting schwärmen?

In einer Interview-Serie beschäftigen wir uns mit den verschiedenen Facetten des Cloud-Hostings. Von klassischen virtuellen Maschinen über Managed Private Cloud und Openstack, Hybrid-Cloud-Strategien bis hin zu Public Clouds und zukünftigen, container-basierten Cloud-Lösungen auf Basis von Docker und Kubernetes.

Zum Start haben wir mit dem Kölner Business-Hoster Plusserver gesprochen. 1999 gegründet, zählt die Plusserver GmbH mit ihren inzwischen über 400 Mitarbeitern und 105 Millionen Euro Jahresumsatz (Stand 2016) zum Urgestein der deutschen Managed-Hosting-Szene. Nach starkem Wachstum in den letzten Jahren, zahlreichen Firmen-Zukäufen und zuletzt einem Rückkauf der Unternehmensanteile durch das Management-Team, ist der Hoster jetzt wieder unabhängig und stellt sich neu auf. Nicht nur darüber sprechen wir mit CMO Niko Bender und CPO Thomas Ebbers. 

t3n.de: Angeblich läuft jeder dritte der deutschen Top-100-Online-Shops auf Plusserver-Infrastruktur. Warum sind die inzwischen nicht alle längst zu den globalen Playern Amazon AWS oder Google Cloud umgezogen?

Niko Bender: Nicht das Werkzeug, sondern die Fertigkeit des Handwerkers entscheidet. Als Managed-Cloud-Hoster sind wir für das Management und nicht nur für die Infrastruktur verantwortlich. Kunden wollen sich auf ihr Kerngeschäft fokussieren und suchen Beratung, Service und Betrieb. Gemeinsam klären wir Fragen wie: Welche Infrastruktur wird für welchen Workload benötigt? Wie sieht es in puncto Datenschutz aus? Wie konzipiere ich meine Lösungen maximal flexibel und welche Architektur ist am effizientesten? Eine Public Cloud ist beispielsweise nicht per se günstiger und besser. Hier prüfen wir mit dem Kunden, was technisch und auch kaufmännisch sinnvoll ist. Natürlich kommt auch die Frage nach dem Datenschutz und der Sicherheit auf. Wie sieht es beispielsweise im Falle eines DDoS-Angriffs aus? Monitoring, Reporting, Acting und Service-Management müssen in die Prozesse des Kunden eingebunden werden. Das sind Aufgaben, die Hoster vollumfänglich verantworten.

t3n.de: Thomas, du suchst als Verantwortlicher für eure Produktstrategie auch nach neuen Trends in der Cloud-Hosting-Branche: Welche Chancen siehst du für euch als alteingesessener Geschäftskunden-Hoster in den nächsten Jahren?

Thomas Ebbers: Die digitale Transformation sehe ich als große Chance für die Branche, da sie das Outsourcing von klassischen Applikationen vorantreibt, welche bislang nur sehr schwer adressiert werden konnten. Dabei suchen Kunden die Unterstützung von kompetenten Ansprechpartnern, die ihnen helfen, die richtige Technologie auszuwählen. Unsere Chance als Hoster ist hierbei, dass wir dem Kunden die Wahl bieten können zwischen klassischer Colocation und Managed Hosting und dazu aber auch verschiedene Public Clouds unterstützen. Aktuell ist das Microsoft Azure, im ersten Quartal 2018 kommt noch Amazon AWS hinzu, im Laufe des Jahres auch Googles Cloud-Plattform.

t3n.de: Was sind dabei die Herausforderungen?

Die Herausforderung als Geschäftskunden-Hoster sind vor allem die verschiedenen Kundenprofile. Auf der einen Seite gibt es die, für die die „klassische IT“ ein bekanntes Terrain ist. Auf der anderen die, die mit agiler Softwareentwicklung arbeiten. Sie wollen Entwickler-getriebene Plattformen und legen das Hauptaugenmerk auf die Applikation. Die Methoden unterscheiden sich grundsätzlich. Dennoch müssen wir es als Hoster schaffen, beide Seiten adäquat zu unterstützen.

t3n.de: Ihr betreibt ja immer noch einige der größten Rechenzentren in Deutschland und habt damit sicher einen nicht unerheblichen Aufwand auf der Kostenseite. Wie passt es da zusammen, dass ihr zeitgleich Microsoft-Cloud-Provider seid und teilweise gar nicht mehr selbst hostet?

Niko Bender: Streng genommen ist Cloud doch auch nur ein Rechenzentrum. Wie so oft im Leben gibt es nicht die eine richtige Lösung – weshalb wir nach wie vor an eine Kombination von klassischem Hosting und Public Cloud glauben. Wir positionieren uns als Managed-Cloud-Anbieter.

Unsere Rechenzentren verstehen wir vermehrt als Hub, welcher im Sinne eines Universaladapters die verschiedenen Hosting-Technologien kombinierbar macht. Zum Beispiel eine Private Cloud, Container-Services auf dedizierter Hardware und AWS oder Azure. Dazu bauen wir Direktanbindungen mit minimaler Latenz zu den großen Hyperscalern auf. Wir erleben auch viele Kunden, die Teile ihrer Daten in Deutschland betrieben haben wollen. Wir helfen dann, die Workloads zu orchestrieren.

Dedizierte Umgebungen bieten oftmals Kosten- und Funktionsvorteile, weshalb wir überzeugt sind, dass auch klassisches Hosting weiterhin benötigt wird. Wir versuchen immer, die individuellen Wünsche der Kunden zu berücksichtigen und haben deswegen auch unser Portfolio etwa um Azure und Azure Stack erweitert. Letzteres zeigt, dass klassisches Hosting ja auch nicht bedeutet, dass keine Innovationen mehr Einzug erhalten. Openshift ist ein weiteres Beispiel dafür. Dazu kommt, dass wir in unserem eigenen Rechenzentrum die Qualität im Griff haben.

t3n.de: Ihr bietet unter anderem auch eine „Open-Source-Cloud“ auf Openstack-Basis an. Inzwischen gibt es immer häufiger Stimmen in der Hosting-Szene, die Openstack als zu komplex gewachsenes und instabiles Projekt gescheitert sehen – wie seht ihr das mit euren Erfahrungen aus der Praxis? Gibt es noch einen Markt für Openstack oder wird die Host-Plattform in Zeiten von Containern und Microservices bald sowieso immer unwichtiger?

Thomas Ebbers: Ein klares Jein. Der Openstack-Markt wächst weiterhin. Das Projekt hat eine große Komplexität und hat einiges an Momentum verloren. Die Entwicklung hat ein Plateau erreicht, auf dem es jetzt heißt „fix the basics“, was natürlich nicht für einen so großen Hype sorgt. Openstack ist eine offene und zugleich umfassende Plattform und für viele nach wie vor unerlässlich. Container-orchestrierte Ansätze scheinen viele Herausforderungen einfacher zu adressieren. Openstack war ein guter Wegbereiter und hat einen Paradigmenwechsel hervorgerufen.

Beim Einsatz von Openstack oder Containern kommt es natürlich auch auf den Kundenwunsch an. Schließlich gibt es einerseits die, die mit dem Thema vertraut sind und dementsprechend Chancen und Risiken kennen. Ihnen geht es darum, dass sie einen Partner mit Betriebs-Know-how auf Augenhöhe suchen. Auf der anderen Seite gibt es natürlich auch Kunden, die nur einzelne Services rausbrechen und einer Frischzellenkur unterziehen. Im Backend wird jedoch noch mit althergebrachten Technologien wie zum Beispiel Oracle gearbeitet, weshalb ein Partner gesucht wird, der beide Welten verheiratet.

t3n.de: Einer der großen Trends in den letzten Jahren ist DevOps – das Zusammenwachsen von Anwendungsentwicklung und Hosting/Betrieb einer Anwendung. Wie DevOps-fit seid ihr selbst und wie helft ihr euren Kunden, ihren Betrieb zu automatisieren?

Thomas Ebbers: Durch die Zusammenarbeit mit großen E-Commerce-Kunden waren wir schon früh mit dem Thema konfrontiert. Durch Azure hat das Thema auch nochmals deutlich an Fahrt gewonnen. Wir kennen daher die Herausforderung und sind DevOps-ready. Jetzt wollen wir das Thema massentauglich machen.

Um das Thema einem breiteren Publikum näher zu bringen, braucht es jedoch einen größeren Wandel. Es müssen spezielle Organisations- und Teamstrukturen geschaffen werden, damit die jeweiligen Fachteams sich auf ihr Spezialgebiet fokussieren und agil arbeiten können. Deshalb setzen wir auf Teams, welche weitestgehend autark arbeiten, jedoch die gemeinsamen Basics wie die Technologie, Kultur und den Organisationsrahmen nutzen können. Wir stehen mit unseren Kunden eng im Austausch und haben zum Ziel, einen nahtlosen Übergang zu schaffen. Wir wollen den Wandel vorleben, anstatt ihn „per Beschluss“ vorzusetzen.

t3n.de: Für die CTOs unter unseren Lesern: Womit sollte ich mich als Enterprise-Kunde mit DevOps-Interesse am besten beschäftigen? Habt ihr einen Favoriten wie Ansible, Salt, Puppet oder besser gleich alles in Microservices (Docker/Kubernetes) aufbauen, dass man möglichst wenig scripten muss?

Thomas Ebbers: Wir sehen den Markt sehr uneinheitlich. Man kann einen Gewinner ausloben, es bleibt jedoch eine Momentbetrachtung. Und einen Standard zu definieren, steht uns nicht zu. Ansible bietet zwar weniger Features, scheint für viele jedoch der einfachere Start. Unser Ansatz ist, uns möglichst kompatibel aufzustellen und keinen Kunden in ein Korsett zu pressen, in das er nicht passt.

Beim Thema Microservices beobachten wir ein großes Interesse und viele Projekte. Und trotz der Komplexität scheint sich Kubernetes mehr und mehr durchzusetzen. Auch hier ist die große Frage: Was ist die Kundensituation? Wird eine Struktur komplett neu aufgebaut, sind Microservices in Containern sicher attraktiv. Bei heterogenen Strukturen zeigt sich aber oftmals ein anderes Bild. Die richtige Kombination macht’s also.

t3n.de: Inwieweit spielen Container-basierte Hosting-Ansätze bei euch heute schon eine Rolle? Auf dem Papier wollen ja immer alle Docker und Microservices – oft scheitert es aber an so kleinen Details wie dem passenden Build-System, Deployment-Workflow, Entwicklungsprozessen und grundlegender „cloud-readyness“ der Kundenanwendungen. Habt ihr Kunden-Beispiele mit Vorbild-Charakter, die für geschäftskritische Anwendungen komplett auf eine Container- und Microservice-Architektur setzen und glücklich sind?

Thomas Ebbers: Container sind schon ein Teil unseres Portfolios. Wir bieten Docker Swarm – nativ und mit VM-Isolation – an und entwickeln eine Openshift-Plattform. Zukünftig sehen wir auch VMware- und Azure-Stack-Implementierungen.

Kunden haben wir derzeit einige, die in das Thema reinwachsen. Beispielsweise ein großer Verlag, der auf schnelle Release-Zyklen setzt. Oftmals scheitert es in der Tat aber an Dingen wie dem Deployment-Prozess. Nerdige Entwickler finden Gefallen daran, jeden Tag alles neu zu erschaffen, Business-Owner haben großes Interesse an Stabilität und Skalierbarkeit. Hier kommt wieder unsere beratende Funktion als Hoster zum Einsatz, wo wir in Punkten wie Frameworks, aber auch beim Abholen der Unternehmer unterstützen können. Wir können zeigen, wie Sektor-Releases via Fireman/Jenkins über Plattformen hinweg mit einer gesicherten Produktion stattfinden können.

Aber man muss auch deutlich sehen: Nicht jeder ist soweit! Oft muss die komplette Plattform überarbeitet werden und wir versuchen, dem Kunden mit unserem Netzwerk von Agenturen und Softwareentwicklern zur Seite zu stehen.

t3n.de: Ein Praxisbeispiel: Wenn ich als Startup-Kunde mit einer geschäftskritischen Webanwendung (zum Beispiel ein Magento-Shop), die heute schon ganz ordentlich mit etwa zwei Millionen Visits pro Monat auf mehreren Root-Servern läuft, zu „Cloud-Hosting“ wechseln möchte, um ausfallsicherer und saisonal skalierbarer zu werden und am Ende eventuell sogar noch Kosten zu sparen – was würdet ihr mir als Einstieg empfehlen? Erstmal ein paar Managed Server, Private, Public oder Hybrid-Cloud?

Niko Bender: Private, Public, Hybrid-Cloud oder Microservices hören sich nicht nur nach einer Menge von Möglichkeiten an, das ist auch komplex. Daher ist keine pauschale Antwort möglich. Die genaue Analyse und Entwicklung einer individuellen Architektur ist unsere Dienstleistung. Unser Ansatz ist dann, mit dem Kunden in einem Workshop zu erarbeiten, welche Anforderungen und Wünsche es gibt. Im Vorfeld entwickeln wir gemeinsam einen „Schlachtplan“, der auch Punkte wie die kaufmännische Flexibilität adressiert.

Wenn eine bestehende Plattform existiert, die auf Basis von Microservices überarbeitet werden soll, um agiler zu werden und Kosteneinsparungen zu ermöglichen, dann sollte eine „Parallelbereitstellung“ erfolgen. Dementsprechend kann es in der Tat sinnvoll sein, eine klassische Umgebung aufzubauen, die als Absprungbasis fungiert und das aktuelle Geschäft sicherstellt. Wenn diese Umgebung bei einem Hoster läuft, der auch Microservices bietet und miteinander kombinieren kann, besteht die Chance, einen weichen Übergang sicherzustellen und kein hartes Umschalten zu provozieren. So kann nach und nach ein Übergang erfolgen, ohne das alles auf eine Karte gesetzt werden muss.

t3n.de: Bei Plusserver bietet ihr auf den ersten Blick extrem viele „Managed Services“ über reines Hosting hinaus an – zum Beispiel „Full-Service-Migration Ihrer Hosting-Infrastruktur“ und „Softwareentwicklung“ – sind das nicht zu viele Gerichte auf der Speisekarte, um überall gut zu sein?

Thomas Ebbers: Genau unser breites Portfolio bietet uns die Möglichkeit, auf den Kundenbedarf einzugehen. Durch Übernahmen anderer Hoster haben wir viel Experten-Know-how dazu gewonnen und integriert und damit Fach-Teams aufgebaut. Die Integration der Teams in die Unternehmensstruktur war eine große Herausforderung. Prozesse mussten optimiert und Know-how weitergegeben werden. Um eine gute Zusammenarbeit zu gewährleisten, haben wir die einzelnen Dienste und Produkte standardisiert – ähnlich einem Lego-Baukasten mit vielen Bausteinen, die kombiniert werden können. Um im Bild zu bleiben: Unsere Entwickler und Architekten designen eine Umgebung und leiten einen maßgeschneiderten „Lego-Bauplan“ ab, welcher unserem Kunden eine hohe Flexibilität und ein gutes Preis-Leistungs-Verhältnis bietet. Deshalb haben unsere Kunden den Vorteil, alles aus einer Hand zu bekommen und dennoch auf unterschiedliche Möglichkeiten beziehungsweise Lösungswege setzen zu können. So stellen wir sicher, dass wir auf die individuellen Bedürfnisse eingehen und niemanden in ein Korsett pressen.

t3n.de: Als zunehmend großes Risikopotential beim Betreiben von reichweitenstarken, geschäftskritischen Portalen gelten heutzutage DDoS-Attacken und Sicherheitslücken in der eingesetzten Kunden-Software – wie stellt ihr sicher, dass auch eure etwas größeren, schwerfälligeren Kunden bestmöglich abgesichert sind? Habt ihr eine Basisabsicherung in Form von vorkonfiguriertem Monitoring, Web-Application-Firewalls oder eine vorgeschaltete Schicht an Erkennungs- und Abwehrmechanismen?

Thomas Ebbers: DDoS-Attacken sind in den letzten Jahren ein extrem wichtiges Thema geworden. Wir sehen keine kleinen Attacken mehr. Gleichzeitig werden auch kleinere Unternehmen angegriffen, die sich bis jetzt eher in Sicherheit gewogen haben. Grundsätzlich setzen wir auf Kooperationen mit führenden Anbietern wie Akamai, Link11, F5, Fortinet, Riorey und Greenbone. Einen zentralen „Feuerlöscher“ haben wir auch, jedoch bewerben wir ihn im Gegensatz zu vielen anderen nicht, da Kunden Garantien und Verlässlichkeit erwarten. Unser Ansatz ist es, im Ernstfall einen Schutz zu bieten, mit verlässlicher und garantierter Leistung – angepasst auf den Kunden.

Die Web-Application-Firewall, das Intrusion-Detection-System, das Intrusion-Prevention-System und ein Pentest müssen individuell an die Kunden-Applikation angepasst werden. Sonst gibt es keinen Schutz oder eine nicht funktionierende Applikation. Wir setzen auch hier auf das oben erwähnte Lego-Baukasten-Prinzip, kombinieren die richtigen Bausteine und ziehen Experten mit Erfahrung zu Rate.

t3n.de: Wir haben uns die letzten Veränderungen in eurer Gesellschafterstruktur angeschaut: Kann man grob zusammengefasst sagen, dass ihr nach Jahren des Wachstums gerade wieder zurück zu euren Wurzeln findet?

Niko Bender: Mit dem Management-Buy-out fühlt es sich tatsächlich ein wenig so an – wir sind wieder selbstständig! In puncto Standardisierung, Prozesse und Skaleneffekte haben wir viel von unseren Wurzeln, dem sogenannten Mass-Hosting gelernt und dies für unsere Branche passend adaptiert. Jetzt haben wir die Möglichkeit, uns zu fokussieren und in einer Phase der Marktkonsolidierung die Zügel in die Hand zu nehmen. Durch den Druck von Hyperscalern gibt es aktuell einen Umbruch in der Branche. Durch die neue Struktur sind wir in der Lage, tiefergehende Veränderungen zu vollziehen, zum Beispiel die erwähnte Integration weiterer Public-Cloud-Anbieter wie Amazon AWS oder Googles Cloud-Plattform.

t3n.de: Mit euren über 400 Mitarbeitern, verteilten Standorten, verschiedenen Marken und jeder Menge Produkten ist es vermutlich nicht immer leicht, den Überblick zu behalten. Gibt es irgendetwas Ungewöhnliches, das bei euch besonders gut funktioniert? Setzt ihr zum Beispiel auf interdisziplinäre Teams, agile Management-Methoden, interne Barcamps, Dev-Camps oder Hunde im Office?

Niko Bender: Wir sind uns dessen bewusst, dass unser Wachstumskurs auch die Herausforderung mitbringt, den Startup-Gedanken lebendig zu halten. Unsere DNA soll pragmatisch, direkt und herzlich sein – wir haben schließlich rheinische Wurzeln.

Um diesem Anspruch gerecht zu werden, setzen wir auf flache Hierarchien und standortübergreifende Zusammenarbeit mit Teams, was in dieser Größe nur funktioniert, wenn man die richtigen Strukturen schafft. Auch hier haben wir eine Art „Lego-Baukasten“ geschaffen, damit eine reibungslose Zusammenarbeit gewährleistet werden kann. So haben wir beispielsweise standortübergreifende Meta-Teams für Spezialgebiete, die gemeinsam an Themen arbeiten und die gleichen Tools nutzen, damit alle Teil derselben Firma sind und wir dieselbe Qualität für unseren Kunden sicherstellen.

Zur Kommunikation nutzen wir regelmäßig Videokonferenzen und Jabber. Als übergreifendes Ticketsystem kommt Request Tracker zum Einsatz. Außerdem organisieren wir regelmäßig Events und haben ein eigenes HR-Team, das sich um das nicht nur inhaltliche Onboarding neuer Mitarbeiter kümmert. Für das Onboarding bei Akquisitionen haben wir noch mal ein eigenes Team. Ein cooles Unternehmen hat natürlich auch einen coolen Standort.  Das wisst ihr ja selbst, da ihr ja gerade erweitert habt. Deshalb beziehen wir in Köln bald ein neues Büro in zentraler Lage und wollen uns damit im Kampf um Fachkräfte durchsetzen. Und ab und zu haben wir tatsächlich auch mal einen Hund im Büro.

t3n.de: Vielen Dank für das Gespräch!

Passend dazu: Cloud-Hosting-Anbieter im Überblick

Nach Feierabend geht für viele Beschäftigte die Arbeit irgendwie weiter – dienstliche Mails werden auch spät am Abend noch beantwortet. Schluss damit, fordert ein Arbeitnehmervertreter. Aus Sorge vor zu hoher Arbeitsbelastung fordert Porsche-Betriebsratschef Uwe Hück die Löschung dienstlicher E-Mails während der Freizeit. Mailkonten von Mitarbeitern sollten im Zeitraum zwischen 19 und 6 Uhr sowie am Wochenende und im Urlaub gesperrt werden, sagte Hück der Deutschen Presse-Agentur in Stuttgart. „Abends noch Mails vom Chef lesen und beantworten, ist unbezahlte Arbeitszeit, die den Stress erhöht – das geht gar nicht.“ Mails, die in dieser Zeit eintreffen, sollten automatisch an den Absender zurückgeschickt werden und nicht mehr in der Mailbox des Mitarbeiters vorhanden sein, also automatisch gelöscht werden.

Keine E-Mails zwischen 18 und 6 Uhr

Hück peilt eine entsprechende Betriebsvereinbarung an, die eine solche Mailsperre vorsieht. Das Vorhaben wäre eine Verschärfung von Regeln des Porsche-Mutterkonzerns VW. Bei dem Wolfsburger Autobauer können Tarifbeschäftigte unter der Woche zwischen 18 und 6 Uhr sowie an Wochenenden keine Dienstmails mehr bekommen oder versenden. Gelöscht werden diese aber nicht – am Morgen ist die elektronische Post dann zu lesen. Das sei „vergleichbar mit einem Funkloch“, sagt ein VW-Betriebsratssprecher.

So eine Regel geht Hück nicht weit genug. „Was nützt dir eine Mailsperre, wenn du ins Büro kommst und erstmal Unmengen an Mails abarbeiten musst.“ Wichtige Mails müsste der Absender halt tagsüber noch einmal schicken, so der Betriebsrat. Allerdings soll es Ausnahmeregeln geben, etwa für die Spätschicht oder für Kollegen, zu deren Jobs die Kommunikation mit China oder den USA gehört, also Märkten in anderen Zeitzonen.

Lösch-Angebot wird genutzt

Ein in Ansätzen ähnliches System gibt es beim Autobauer Daimler. Dort können Mitarbeiter ihr Mailkonto so einstellen, dass die elektronische Post im Urlaub automatisch gelöscht und der Absender informiert wird. Das beruht aber auf Freiwilligkeit – eine Pflichtvorgabe gibt es nicht. Das Lösch-Angebot werde durchaus genutzt, so ein Daimler-Sprecher. Eine Statistik über die Nutzung gebe es aber nicht. Das sei eine individuelle Entscheidung des einzelnen Mitarbeiters, die „gefördert und respektiert“ werde. Bei BMW wiederum gibt es ein „Recht auf Nichterreichbarkeit nach Feierabend, im Urlaub und am Wochenende“. Zwischendurch blockiert werden die Mailserver bei den Münchnern aber nicht.

Verschärfte Schutzbedingungen für die Belegschaft sind nach Darstellung von Porsche-Betriebsratschef Hück auch betriebswirtschaftlich sinnvoll. „Der Fachkräftemangel wird sich verschärfen, die Suche nach Mitarbeitern wird immer schwieriger – also muss man doch die Belegschaft hegen und pflegen, damit sie möglichst lange im Unternehmen bleibt.“ Würde man hingegen nichts tun gegen die hohe Arbeitsbelastung, würde sich die Personalnot in der Wirtschaft verschärfen. „Ohne bessere Schutzbedingungen würde eine Welle an Burnouts kommen“, warnte Hück.

Die E-Mail-Regeln sollen nur für die tariflich bezahlten Beschäftigten gelten, außertarifliche Mitarbeiter – etwa Führungskräfte – wären außen vor. „Wer als Manager einen hohen Bonus bekommt, der kann auch abends noch eine Mail beantworten.“ dpa

Alles fing so gut an: Dein Shopsystem passte zu den Anforderungen deines Shops, skalierte flexibel und arbeitete gut mit Frontend und Commerce-Tools zusammen. Mit der Zeit zeigen sich aber die Schwächen der Lösung. Was nun?

Ein Ende mit Schrecken: Wenn du dein Shopsystem einfach nicht mehr liebst

Spätestens dann ist es an der Zeit, deine bisherige E-Commerce-Infrastruktur genau zu prüfen und mitunter zu wechseln. Sebastian Betz, Gründer und Geschäftsführer von ABOUT YOU, erklärt, welche Gründe dafür sprechen:

• Zu langsames, zu instabiles Shopsystem. Ab einer Umsatzgröße von 50 Mio. Euro skaliert deine Infrastruktur nicht mehr. Sie wird langsam, unflexibel und instabil. Sowohl Standard-Systeme wie Magento als auch traditionelle Enterprise-Lösungen können dieses Problem haben.
• Zu wenig Zeit, zu viel zu tun. Infrastruktursysteme kommen in der Regel nicht ohne Inhouse-Development aus. Auch bei der Wartung und Pflege binden sie Ressourcen. Dein Team ist allerdings überschaubar und soll neben dem System auch das Shop-Frontend optimieren. Genau hier liegt das Problem: Vor lauter Wartung kommt ihr nicht zur Frontend-Entwicklung. Dabei solltet ihr einen großartigen Shop entwickeln, der die eigentliche Killer-Applikation für eure Kunden ist.
• Zu viel Lokalisationsaufwand. Internationalisierung ist im E-Commerce eine gängige Wachstumsstrategie. Allerdings muss die Technologie dabei mitspielen und die Umsetzung lokaler Marktregeln ermöglichen. In vielen Shop-Systemen ist das Hinterlegen solcher lokalen Informationen jedoch aufwendig und kostspielig.
• Zu wenig Userfokus. Kann dein Shop schon Voice-Suchen bewältigen? Push-Nachrichten senden? In allen Kanälen eine gute User-Experience liefern? Diese Anwendungen erwarten eure Kunden. Allerdings begrenzen euch ältere Lösungen in der Entwicklung.
• Ihr wollt eine Plattform sein, kein Shop. Euer Angebot speist sich aus verschiedenen Quellen und Dropshipping-Partnern, soll aber in der Außenwirkung wie aus einem Guss wirken. Wenn die Infrastruktur das nicht leistet, ist das außen sichtbar. So zündet der Plattformansatz nicht.

Schönheit vor Alter: Die neue Shop-Infrastruktur von ABOUT YOU

Aus diesen fünf Gründen hat ABOUT YOU von Beginn an auf eine eigene Infrastruktur gesetzt. Das selbstentwickelte System erlaubte es uns, flexibel und stabil mit unseren Plattformen ABOUT YOU und EDITED zu wachsen, sowohl was die Zugriffe als auch die internationalen Rollouts angeht. Die Infrastruktur namens BACKBONE ist unter der Marke ABOUT YOU CLOUD künftig auch für jeden anderen Händler Enterprise-ready verfügbar. Und sie löst genau die Probleme, die du mit deiner alten Infrastruktur hattest.

Das bietet dir die neue API-basierte E-Commerce-Infrastruktur:

• Product & Catalogue Management
  • Verclusterung von Produkten zu Kategorien
  • Multi-Shop Funktion
  • Multi-Sprach und -Price Management inkl. Übersetzungsprozess
  • Produktsuche
• Orders & Stock Management
  • Bestell-Verwaltung
  • Real-Time Stock Management
  • Push-Mitteilungen zu Sendungen & Retouren
• Warehousing & Logistics Management
  • Multiple Warehouses
  • Multiple Dropshipping Partner
  • Internationale Auswahl an Carriern

First Date: So gehen wir die Zusammenarbeit an

Entscheidest du dich für die ABOUT YOU CLOUD, finden wir den für dich besten Weg. Dazu stellen wir dir eine Solution-Agentur zur Seite. Sie koordiniert den Systemwechsel.

Gemeinsam sprecht ihr darüber, was dein Shop und du zum Glücklichsein braucht: Welche Features, welche Partner und Anbindungen sollen vorhanden sein? Nehmt ihr euer Frontend mit oder braucht ihr ein Neues? ABOUT YOU CLOUD integriert mit Spryker, Frontastic, Hornetshop und allen anderen Frontends, auch mit deinem derzeitigen.

Wenn alles geklärt ist, übernehmen wir die Cloud-Konfiguration und versorgen dich mit unseren Staging-, Integration- und Production-Systemen. Du fügst deine Partner und Tools per Klick hinzu und bekommst bei eventuellen Entwickleraufgaben Support von der Solution-Agency.

Beziehungsalltag: Das erwartet dich nach der Integration

Die lästige Systempflege und -Wartung übernehmen wir. Die Lösung wird von uns auf dem aktuellen Stand gehalten. Unser internes Security-Team geht mögliche Sicherheitslücken täglich proaktiv an. Weil aber auch andere kluge Ideen haben, haben wir ein Bug Bounty Programm auf HackerOne laufen.

Sharing is Caring. Deshalb rollen wir Features für alle Kunden der ABOUT YOU CLOUD gleich aus, egal ob wir eine Funktion für unsere eigenen Plattformen entwickeln, für einen anderen Kunden oder für dich. Somit profitiert der jeweilige Auftraggeber von günstigen Developer-Konditionen. Natürlich kannst du auch eigene Features programmieren und integrieren oder uns für eine exklusive Killerfunktion beauftragen.

Nicht zuletzt lebt jede gute Langzeitbeziehung aber von persönlicher Nähe. Deshalb stellen wir dir einen festen Key-Account-Manager zur Seite. In dringenden Fällen bieten wir dir außerdem einen 24/7-Support und ein Klärfallteam. Du bist also in den besten Händen.

Hier mehr erfahren

 

Eine 25-Jährige schlug zuerst auf ihre Freundin (21), dann bekamen auch Ersthelfer Schläge ab. Nun stand sie vor dem Amtsgericht. 

Die sächsische Polizei hat neue Panzer bestellt. Auf den Sitzen prangt Frakturschrift. Das Innenministerium hat dafür eine absurde Erklärung.

Nach der Pleite von Panono war unklar, ob Vorbesteller ihre Kamera noch bekommen. Jetzt hat der neue Besitzer einen Kompromiss vorgeschlagen: Bisher leer ausgegangene Crowdfunding-Unterstützer können die 360-Grad-Kamera zu Produktionskosten kaufen. (Panono, Digitalkamera)

Wir haben hier einen potentiellen Kunden, der uns innerhalb von 3 Monaten bereits 81 E-Mails mit Fragen zu uns und unseren Produkten geschickt hat.

Rekord!

Dem ehemaligen Leiter der Musikhochschule droht wegen Vergewaltigungsvorwürfen eine lange Haftstrafe. Seine Frau kämpft nun öffentlich für ihn. Sie spricht sogar von Mobbing.