This month, we released several new capabilities to help you stay ahead of threats, create a more productive workplace, and keep you in the flow of work.
The post New to Microsoft 365 in February—advancing security and empowering a modern workplace appeared first on Microsoft 365 Blog.
With Windows 7 end of support less than a year away, now is the time to make the shift to Windows 10 and Office 365. Microsoft has resources to make that move as smooth as possible.
The post Now is the time to make the shift to Microsoft 365 appeared first on Microsoft 365 Blog.
On Tuesday, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 18342 or greater). The Preview SDK Build 18342 contains bug fixes and under development changes to the API surface area.
The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.
In this Preview SDK we’ll be adding a blend mode to the effect graph of the AcrylicBrush called Luminosity. This blend mode will ensure that shadows do not appear behind acrylic surfaces without a cutout. We will also be exposing a LuminosityBlendOpacity API available for tweaking that allows for more AcrylicBrush customization.
By default, for those that have not specified any LuminosityBlendOpacity on their AcrylicBrushes, we have implemented some logic to ensure that the Acrylic will look as similar as it can to current 1809 acrylics. Please note that we will be updating our default brushes to account for this recipe change.
Events generated by TraceLoggingProvider.h (e.g. via TraceLoggingWrite macros) will now always have Id and Version set to 0.
Previously, TraceLoggingProvider.h would assign IDs to events at link time. These IDs were unique within a DLL or EXE, but changed from build to build and from module to module.
Note: The following recent removals have been made since earlier flights.
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler<PushNotificationChannelsRevokedEventArgs> ChannelsRevoked;
}
public sealed class PushNotificationChannelsRevokedEventArgs
}
namespace Windows.UI.Composition {
public sealed class CompositionProjectedShadow : CompositionObject {
float MaxOpacity { get; set; }
float MinOpacity { get; set; }
float OpacityFalloff { get; set; }
}
public sealed class CompositionProjectedShadowCaster : CompositionObject {
Visual AncestorClip { get; set; }
CompositionBrush Mask { get; set; }
}
public enum CompositionProjectedShadowDrawOrder
public sealed class CompositionProjectedShadowReceiver : CompositionObject {
CompositionProjectedShadowDrawOrder DrawOrder { get; set; }
CompositionBrush Mask { get; set; }
}
public sealed class CompositionRadialGradientBrush : CompositionGradientBrush {
Vector2 GradientOrigin { get; set; }
}
public interface ICompositorPartner_ProjectedShadow
}
namespace Windows.AI.MachineLearning {
public sealed class LearningModelSession : IClosable {
public LearningModelSession(LearningModel model, LearningModelDevice deviceToRunOn, LearningModelSessionOptions learningModelSessionOptions);
}
public sealed class LearningModelSessionOptions
public sealed class TensorBoolean : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorBoolean CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorBoolean CreateFromShapeArrayAndDataArray(long[] shape, bool[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorDouble : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorDouble CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorDouble CreateFromShapeArrayAndDataArray(long[] shape, double[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat16Bit CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, short[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, int[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, long[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorString : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorString CreateFromShapeArrayAndDataArray(long[] shape, string[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, ushort[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, uint[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, ulong[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
}
namespace Windows.ApplicationModel {
public sealed class Package {
StorageFolder EffectiveLocation { get; }
StorageFolder MutableLocation { get; }
}
}
namespace Windows.ApplicationModel.AppService {
public sealed class AppServiceConnection : IClosable {
public static IAsyncOperation<StatelessAppServiceResponse> SendStatelessMessageAsync(AppServiceConnection connection, RemoteSystemConnectionRequest connectionRequest, ValueSet message);
}
public sealed class AppServiceTriggerDetails {
string CallerRemoteConnectionToken { get; }
}
public sealed class StatelessAppServiceResponse
public enum StatelessAppServiceResponseStatus
}
namespace Windows.ApplicationModel.Background {
public sealed class ConversationalAgentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
public sealed class PhoneLine {
string TransportDeviceId { get; }
void EnableTextReply(bool value);
}
public enum PhoneLineTransport {
Bluetooth = 2,
}
public sealed class PhoneLineTransportDevice
}
namespace Windows.ApplicationModel.Calls.Background {
public enum PhoneIncomingCallDismissedReason
public sealed class PhoneIncomingCallDismissedTriggerDetails
public enum PhoneTriggerType {
IncomingCallDismissed = 6,
}
}
namespace Windows.ApplicationModel.Calls.Provider {
public static class PhoneCallOriginManager {
public static bool IsSupported { get; }
}
}
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ConversationalAgentSession : IClosable
public sealed class ConversationalAgentSessionInterruptedEventArgs
public enum ConversationalAgentSessionUpdateResponse
public sealed class ConversationalAgentSignal
public sealed class ConversationalAgentSignalDetectedEventArgs
public enum ConversationalAgentState
public sealed class ConversationalAgentSystemStateChangedEventArgs
public enum ConversationalAgentSystemStateChangeType
}
namespace Windows.ApplicationModel.Preview.Holographic {
public sealed class HolographicKeyboardPlacementOverridePreview
}
namespace Windows.ApplicationModel.Resources {
public sealed class ResourceLoader {
public static ResourceLoader GetForUIContext(UIContext context);
}
}
namespace Windows.ApplicationModel.Resources.Core {
public sealed class ResourceCandidate {
ResourceCandidateKind Kind { get; }
}
public enum ResourceCandidateKind
public sealed class ResourceContext {
public static ResourceContext GetForUIContext(UIContext context);
}
}
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivityChannel {
public static UserActivityChannel GetForUser(User user);
}
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
public enum GattServiceProviderAdvertisementStatus {
StartedWithoutAllAdvertisementData = 4,
}
public sealed class GattServiceProviderAdvertisingParameters {
IBuffer ServiceData { get; set; }
}
}
namespace Windows.Devices.Enumeration {
public enum DevicePairingKinds : uint {
ProvidePasswordCredential = (uint)16,
}
public sealed class DevicePairingRequestedEventArgs {
void AcceptWithPasswordCredential(PasswordCredential passwordCredential);
}
}
namespace Windows.Devices.Input {
public sealed class PenDevice
}
namespace Windows.Devices.PointOfService {
public sealed class JournalPrinterCapabilities : ICommonPosPrintStationCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class JournalPrintJob : IPosPrinterJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
public sealed class PosPrinter : IClosable {
IVectorView<uint> SupportedBarcodeSymbologies { get; }
PosPrinterFontProperty GetFontProperty(string typeface);
}
public sealed class PosPrinterFontProperty
public sealed class PosPrinterPrintOptions
public sealed class ReceiptPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class ReceiptPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
void StampPaper();
}
public struct SizeUInt32
public sealed class SlipPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class SlipPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
}
namespace Windows.Globalization {
public sealed class CurrencyAmount
}
namespace Windows.Graphics.DirectX {
public enum DirectXPrimitiveTopology
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
HolographicViewConfiguration ViewConfiguration { get; }
}
public sealed class HolographicDisplay {
HolographicViewConfiguration TryGetViewConfiguration(HolographicViewConfigurationKind kind);
}
public sealed class HolographicViewConfiguration
public enum HolographicViewConfigurationKind
}
namespace Windows.Management.Deployment {
public enum AddPackageByAppInstallerOptions : uint {
LimitToExistingPackages = (uint)512,
}
public enum DeploymentOptions : uint {
RetainFilesOnFailure = (uint)2097152,
}
}
namespace Windows.Media.Devices {
public sealed class InfraredTorchControl
public enum InfraredTorchMode
public sealed class VideoDeviceController : IMediaDeviceController {
InfraredTorchControl InfraredTorchControl { get; }
}
}
namespace Windows.Media.Miracast {
public sealed class MiracastReceiver
public sealed class MiracastReceiverApplySettingsResult
public enum MiracastReceiverApplySettingsStatus
public enum MiracastReceiverAuthorizationMethod
public sealed class MiracastReceiverConnection : IClosable
public sealed class MiracastReceiverConnectionCreatedEventArgs
public sealed class MiracastReceiverCursorImageChannel
public sealed class MiracastReceiverCursorImageChannelSettings
public sealed class MiracastReceiverDisconnectedEventArgs
public enum MiracastReceiverDisconnectReason
public sealed class MiracastReceiverGameControllerDevice
public enum MiracastReceiverGameControllerDeviceUsageMode
public sealed class MiracastReceiverInputDevices
public sealed class MiracastReceiverKeyboardDevice
public enum MiracastReceiverListeningStatus
public sealed class MiracastReceiverMediaSourceCreatedEventArgs
public sealed class MiracastReceiverSession : IClosable
public sealed class MiracastReceiverSessionStartResult
public enum MiracastReceiverSessionStartStatus
public sealed class MiracastReceiverSettings
public sealed class MiracastReceiverStatus
public sealed class MiracastReceiverStreamControl
public sealed class MiracastReceiverVideoStreamSettings
public enum MiracastReceiverWiFiStatus
public sealed class MiracastTransmitter
public enum MiracastTransmitterAuthorizationStatus
}
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Wpa3 = 10,
Wpa3Sae = 11,
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class ESim {
ESimDiscoverResult Discover();
ESimDiscoverResult Discover(string serverAddress, string matchingId);
IAsyncOperation<ESimDiscoverResult> DiscoverAsync();
IAsyncOperation<ESimDiscoverResult> DiscoverAsync(string serverAddress, string matchingId);
}
public sealed class ESimDiscoverEvent
public sealed class ESimDiscoverResult
public enum ESimDiscoverResultKind
}
namespace Windows.Perception.People {
public sealed class EyesPose
public enum HandJointKind
public sealed class HandMeshObserver
public struct HandMeshVertex
public sealed class HandMeshVertexState
public sealed class HandPose
public struct JointPose
public enum JointPoseAccuracy
}
namespace Windows.Perception.Spatial {
public struct SpatialRay
}
namespace Windows.Perception.Spatial.Preview {
public sealed class SpatialGraphInteropFrameOfReferencePreview
public static class SpatialGraphInteropPreview {
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition, Quaternion relativeOrientation);
}
}
namespace Windows.Security.Authorization.AppCapabilityAccess {
public sealed class AppCapability
public sealed class AppCapabilityAccessChangedEventArgs
public enum AppCapabilityAccessStatus
}
namespace Windows.Security.DataProtection {
public enum UserDataAvailability
public sealed class UserDataAvailabilityStateChangedEventArgs
public sealed class UserDataBufferUnprotectResult
public enum UserDataBufferUnprotectStatus
public sealed class UserDataProtectionManager
public sealed class UserDataStorageItemProtectionInfo
public enum UserDataStorageItemProtectionStatus
}
namespace Windows.Storage.AccessCache {
public static class StorageApplicationPermissions {
public static StorageItemAccessList GetFutureAccessListForUser(User user);
public static StorageItemMostRecentlyUsedList GetMostRecentlyUsedListForUser(User user);
}
}
namespace Windows.Storage.Pickers {
public sealed class FileOpenPicker {
User User { get; }
public static FileOpenPicker CreateForUser(User user);
}
public sealed class FileSavePicker {
User User { get; }
public static FileSavePicker CreateForUser(User user);
}
public sealed class FolderPicker {
User User { get; }
public static FolderPicker CreateForUser(User user);
}
}
namespace Windows.System {
public sealed class DispatcherQueue {
bool HasThreadAccess { get; }
}
public enum ProcessorArchitecture {
Arm64 = 12,
X86OnArm64 = 14,
}
}
namespace Windows.System.Profile {
public static class AppApplicability
public sealed class UnsupportedAppRequirement
public enum UnsupportedAppRequirementReasons : uint
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
User User { get; }
public static RemoteSystemWatcher CreateWatcherForUser(User user);
public static RemoteSystemWatcher CreateWatcherForUser(User user, IIterable<IRemoteSystemFilter> filters);
}
public sealed class RemoteSystemApp {
string ConnectionToken { get; }
User User { get; }
}
public sealed class RemoteSystemConnectionRequest {
string ConnectionToken { get; }
public static RemoteSystemConnectionRequest CreateFromConnectionToken(string connectionToken);
public static RemoteSystemConnectionRequest CreateFromConnectionTokenForUser(User user, string connectionToken);
}
public sealed class RemoteSystemWatcher {
User User { get; }
}
}
namespace Windows.UI {
public sealed class UIContentRoot
public sealed class UIContext
}
namespace Windows.UI.Composition {
public enum CompositionBitmapInterpolationMode {
MagLinearMinLinearMipLinear = 2,
MagLinearMinLinearMipNearest = 3,
MagLinearMinNearestMipLinear = 4,
MagLinearMinNearestMipNearest = 5,
MagNearestMinLinearMipLinear = 6,
MagNearestMinLinearMipNearest = 7,
MagNearestMinNearestMipLinear = 8,
MagNearestMinNearestMipNearest = 9,
}
public sealed class CompositionGraphicsDevice : CompositionObject {
CompositionMipmapSurface CreateMipmapSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
void Trim();
}
public sealed class CompositionMipmapSurface : CompositionObject, ICompositionSurface
public sealed class CompositionProjectedShadow : CompositionObject
public sealed class CompositionProjectedShadowCaster : CompositionObject
public sealed class CompositionProjectedShadowCasterCollection : CompositionObject, IIterable<CompositionProjectedShadowCaster>
public sealed class CompositionProjectedShadowReceiver : CompositionObject
public sealed class CompositionProjectedShadowReceiverUnorderedCollection : CompositionObject, IIterable<CompositionProjectedShadowReceiver>
public sealed class CompositionRadialGradientBrush : CompositionGradientBrush
public sealed class CompositionSurfaceBrush : CompositionBrush {
bool SnapToPixels { get; set; }
}
public class CompositionTransform : CompositionObject
public sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
public sealed class Compositor : IClosable {
CompositionProjectedShadow CreateProjectedShadow();
CompositionProjectedShadowCaster CreateProjectedShadowCaster();
CompositionProjectedShadowReceiver CreateProjectedShadowReceiver();
CompositionRadialGradientBrush CreateRadialGradientBrush();
CompositionVisualSurface CreateVisualSurface();
}
public interface IVisualElement
}
namespace Windows.UI.Composition.Interactions {
public enum InteractionBindingAxisModes : uint
public sealed class InteractionTracker : CompositionObject {
public static InteractionBindingAxisModes GetBindingMode(InteractionTracker boundTracker1, InteractionTracker boundTracker2);
public static void SetBindingMode(InteractionTracker boundTracker1, InteractionTracker boundTracker2, InteractionBindingAxisModes axisMode);
}
public sealed class InteractionTrackerCustomAnimationStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerIdleStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInertiaStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInteractingStateEnteredArgs {
bool IsFromBinding { get; }
}
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
public static VisualInteractionSource CreateFromIVisualElement(IVisualElement source);
}
}
namespace Windows.UI.Composition.Scenes {
public enum SceneAlphaMode
public enum SceneAttributeSemantic
public sealed class SceneBoundingBox : SceneObject
public class SceneComponent : SceneObject
public sealed class SceneComponentCollection : SceneObject, IIterable<SceneComponent>, IVector<SceneComponent>
public enum SceneComponentType
public class SceneMaterial : SceneObject
public class SceneMaterialInput : SceneObject
public sealed class SceneMesh : SceneObject
public sealed class SceneMeshMaterialAttributeMap : SceneObject, IIterable<IKeyValuePair<string, SceneAttributeSemantic>>, IMap<string, SceneAttributeSemantic>
public sealed class SceneMeshRendererComponent : SceneRendererComponent
public sealed class SceneMetallicRoughnessMaterial : ScenePbrMaterial
public sealed class SceneModelTransform : CompositionTransform
public sealed class SceneNode : SceneObject
public sealed class SceneNodeCollection : SceneObject, IIterable<SceneNode>, IVector<SceneNode>
public class SceneObject : CompositionObject
public class ScenePbrMaterial : SceneMaterial
public class SceneRendererComponent : SceneComponent
public sealed class SceneSurfaceMaterialInput : SceneMaterialInput
public sealed class SceneVisual : ContainerVisual
public enum SceneWrappingMode
}
namespace Windows.UI.Core {
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
UIContext UIContext { get; }
}
}
namespace Windows.UI.Core.Preview {
public sealed class CoreAppWindowPreview
}
namespace Windows.UI.Input {
public class AttachableInputObject : IClosable
public enum GazeInputAccessStatus
public sealed class InputActivationListener : AttachableInputObject
public sealed class InputActivationListenerActivationChangedEventArgs
public enum InputActivationState
}
namespace Windows.UI.Input.Preview {
public static class InputActivationListenerPreview
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionManager {
public static bool IsSourceKindSupported(SpatialInteractionSourceKind kind);
}
public sealed class SpatialInteractionSource {
HandMeshObserver TryCreateHandMeshObserver();
IAsyncOperation<HandMeshObserver> TryCreateHandMeshObserverAsync();
}
public sealed class SpatialInteractionSourceState {
HandPose TryGetHandPose();
}
public sealed class SpatialPointerPose {
EyesPose Eyes { get; }
bool IsHeadCapturedBySystem { get; }
}
}
namespace Windows.UI.Notifications {
public sealed class ToastActivatedEventArgs {
ValueSet UserInput { get; }
}
public sealed class ToastNotification {
bool ExpiresOnReboot { get; set; }
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
string PersistedStateId { get; set; }
UIContext UIContext { get; }
WindowingEnvironment WindowingEnvironment { get; }
public static void ClearAllPersistedState();
public static void ClearPersistedState(string key);
IVectorView<DisplayRegion> GetDisplayRegions();
}
public sealed class InputPane {
public static InputPane GetForUIContext(UIContext context);
}
public sealed class UISettings {
bool AutoHideScrollBars { get; }
event TypedEventHandler<UISettings, UISettingsAutoHideScrollBarsChangedEventArgs> AutoHideScrollBarsChanged;
}
public sealed class UISettingsAutoHideScrollBarsChangedEventArgs
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
public static CoreInputView GetForUIContext(UIContext context);
}
}
namespace Windows.UI.WindowManagement {
public sealed class AppWindow
public sealed class AppWindowChangedEventArgs
public sealed class AppWindowClosedEventArgs
public enum AppWindowClosedReason
public sealed class AppWindowCloseRequestedEventArgs
public sealed class AppWindowFrame
public enum AppWindowFrameStyle
public sealed class AppWindowPlacement
public class AppWindowPresentationConfiguration
public enum AppWindowPresentationKind
public sealed class AppWindowPresenter
public sealed class AppWindowTitleBar
public sealed class AppWindowTitleBarOcclusion
public enum AppWindowTitleBarVisibility
public sealed class CompactOverlayPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class DefaultPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class DisplayRegion
public sealed class FullScreenPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class WindowingEnvironment
public sealed class WindowingEnvironmentAddedEventArgs
public sealed class WindowingEnvironmentChangedEventArgs
public enum WindowingEnvironmentKind
public sealed class WindowingEnvironmentRemovedEventArgs
}
namespace Windows.UI.WindowManagement.Preview {
public sealed class WindowManagementPreview
}
namespace Windows.UI.Xaml {
public class UIElement : DependencyObject, IAnimationObject, IVisualElement {
Vector3 ActualOffset { get; }
Vector2 ActualSize { get; }
Shadow Shadow { get; set; }
public static DependencyProperty ShadowProperty { get; }
UIContext UIContext { get; }
XamlRoot XamlRoot { get; set; }
}
public class UIElementWeakCollection : IIterable<UIElement>, IVector<UIElement>
public sealed class Window {
UIContext UIContext { get; }
}
public sealed class XamlRoot
public sealed class XamlRootChangedEventArgs
}
namespace Windows.UI.Xaml.Controls {
public sealed class DatePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class FlyoutPresenter : ContentControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class InkToolbar : Control {
InkPresenter TargetInkPresenter { get; set; }
public static DependencyProperty TargetInkPresenterProperty { get; }
}
public class MenuFlyoutPresenter : ItemsControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public sealed class TimePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class TwoPaneView : Control
public enum TwoPaneViewMode
public enum TwoPaneViewPriority
public enum TwoPaneViewTallModeConfiguration
public enum TwoPaneViewWideModeConfiguration
}
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapControl : Control {
bool CanTiltDown { get; }
public static DependencyProperty CanTiltDownProperty { get; }
bool CanTiltUp { get; }
public static DependencyProperty CanTiltUpProperty { get; }
bool CanZoomIn { get; }
public static DependencyProperty CanZoomInProperty { get; }
bool CanZoomOut { get; }
public static DependencyProperty CanZoomOutProperty { get; }
}
public enum MapLoadingStatus {
DownloadedMapsManagerUnavailable = 3,
}
}
namespace Windows.UI.Xaml.Controls.Primitives {
public sealed class AppBarTemplateSettings : DependencyObject {
double NegativeCompactVerticalDelta { get; }
double NegativeHiddenVerticalDelta { get; }
double NegativeMinimalVerticalDelta { get; }
}
public sealed class CommandBarTemplateSettings : DependencyObject {
double OverflowContentCompactYTranslation { get; }
double OverflowContentHiddenYTranslation { get; }
double OverflowContentMinimalYTranslation { get; }
}
public class FlyoutBase : DependencyObject {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
XamlRoot XamlRoot { get; set; }
}
public sealed class Popup : FrameworkElement {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
}
}
namespace Windows.UI.Xaml.Core.Direct {
public enum XamlPropertyIndex {
AppBarTemplateSettings_NegativeCompactVerticalDelta = 2367,
AppBarTemplateSettings_NegativeHiddenVerticalDelta = 2368,
AppBarTemplateSettings_NegativeMinimalVerticalDelta = 2369,
CommandBarTemplateSettings_OverflowContentCompactYTranslation = 2384,
CommandBarTemplateSettings_OverflowContentHiddenYTranslation = 2385,
CommandBarTemplateSettings_OverflowContentMinimalYTranslation = 2386,
FlyoutBase_ShouldConstrainToRootBounds = 2378,
FlyoutPresenter_IsDefaultShadowEnabled = 2380,
MenuFlyoutPresenter_IsDefaultShadowEnabled = 2381,
Popup_ShouldConstrainToRootBounds = 2379,
ThemeShadow_Receivers = 2279,
UIElement_ActualOffset = 2382,
UIElement_ActualSize = 2383,
UIElement_Shadow = 2130,
}
public enum XamlTypeIndex {
ThemeShadow = 964,
}
}
namespace Windows.UI.Xaml.Documents {
public class TextElement : DependencyObject {
XamlRoot XamlRoot { get; set; }
}
}
namespace Windows.UI.Xaml.Hosting {
public sealed class ElementCompositionPreview {
public static UIElement GetAppWindowContent(AppWindow appWindow);
public static void SetAppWindowContent(AppWindow appWindow, UIElement xamlContent);
}
}
namespace Windows.UI.Xaml.Input {
public sealed class FocusManager {
public static object GetFocusedElement(XamlRoot xamlRoot);
}
public class StandardUICommand : XamlUICommand {
StandardUICommandKind Kind { get; set; }
}
}
namespace Windows.UI.Xaml.Media {
public class AcrylicBrush : XamlCompositionBrushBase {
IReference<double> TintLuminosityOpacity { get; set; }
public static DependencyProperty TintLuminosityOpacityProperty { get; }
}
public class Shadow : DependencyObject
public class ThemeShadow : Shadow
public sealed class VisualTreeHelper {
public static IVectorView<Popup> GetOpenPopupsForXamlRoot(XamlRoot xamlRoot);
}
}
namespace Windows.UI.Xaml.Media.Animation {
public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration {
bool IsShadowEnabled { get; set; }
}
}
namespace Windows.Web.Http {
public sealed class HttpClient : IClosable, IStringable {
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryDeleteAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryGetAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryGetAsync(Uri uri, HttpCompletionOption completionOption);
IAsyncOperationWithProgress<HttpGetBufferResult, HttpProgress> TryGetBufferAsync(Uri uri);
IAsyncOperationWithProgress<HttpGetInputStreamResult, HttpProgress> TryGetInputStreamAsync(Uri uri);
IAsyncOperationWithProgress<HttpGetStringResult, HttpProgress> TryGetStringAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryPostAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryPutAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TrySendRequestAsync(HttpRequestMessage request);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TrySendRequestAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
}
public sealed class HttpGetBufferResult : IClosable, IStringable
public sealed class HttpGetInputStreamResult : IClosable, IStringable
public sealed class HttpGetStringResult : IClosable, IStringable
public sealed class HttpRequestResult : IClosable, IStringable
}
namespace Windows.Web.Http.Filters {
public sealed class HttpBaseProtocolFilter : IClosable, IHttpFilter {
User User { get; }
public static HttpBaseProtocolFilter CreateForUser(User user);
}
}
The post Windows 10 SDK Preview Build 18342 available now! appeared first on Windows Developer Blog.
I don’t know why but it seems like some weeks are just busier than others for everybody. And y’all have obviously been busy, because this week I got so many notifications about Agile, DevOps, GitHub and Azure DevOps articles in my inbox that it was hard to keep up.
The post Top Stories from the Microsoft DevOps Community – 2019.03.01 appeared first on Azure DevOps Blog.
Today, March 1, we released the February 2019 Cumulative Update for Windows 10 version 1809 and Windows Server 2019.
This release contains the following quality and reliability improvements.
The Preview of Quality Rollup is available via Windows Update, Windows Server Update Services, and Microsoft Update Catalog.
You can get the update via the Microsoft Update Catalog. For Windows 10 update 1809, the .NET Framework updates are part of the Windows 10 .NET Framework Cumulative Update.
| Product Version | Cumulative Update KB |
|---|---|
| Windows 10 1809 (October 2018 Update) | Catalog 4486553 |
| .NET Framework 3.5, 4.7.2 | 4486553 |
The last few .NET Framework Cumulative updates are listed below for your convenience:
The post .NET Framework March 1, 2019 Cumulative Update for Windows 10 version 1809 and Windows Server 2019 appeared first on .NET Blog.
Let's say you've developed a predictive model in R, and you want to embed predictions (scores) from that model into another application (like a mobile or Web app, or some automated service). If you expect a heavy load of requests, R running on a single server isn't going to cut it: you'll need some kind of distributed architecture with enough servers to handle the volume of requests in real time.
This reference architecture for real-time scoring with R, published in Microsoft Docs, describes a Kubernetes-based system to distribute the load to R sessions running in containers. This diagram from the article provides a good overview:
You can find detailed instructions for deploying this architecture in Github. This architecture uses Azure-specific components, but you could also use their open source equivalents if you wanted to host them yourself:
For more details on this architecture, take a look at the Microsoft Docs article linked below.
Microsoft Docs: Real-time scoring of R machine learning models
"EditorConfig helps maintain consistent coding styles for multiple developers working on the same project across various editors and IDEs." Rather than you having to keep your code in whatever format the team has agreed on, you can check in an .editorconfig file and your editor of choice will keep things in line.
If you're a .NET developer like myself, there's a ton of great .NET EditorConfig options you can set to ensure the team uses consistent Language Conventions, Naming Conventions, and Formatting Rules.
var/explicit type, use expression-bodied member. async methods must end in "Async".If you're using Visual Studios 2010, 2012, 2013, or 2015, fear not. There's at least a basic EditorConfig free extension for you that enforces the basic rules. There is also an extension for Visual Studio Code to support EditorConfig files that takes just seconds to install.
ASIDE: If you are looking for a decent default for C#, take a look at the .editorconfig that the C# Roslyn compiler team uses. I don't know about you, but my brain exploded when I saw that they used spaces vs tabs.
But! What if you want this coding formatting goodness at the dotnet command line? You can use "dotnet format" as a global tool! It's one line to install, then it's available everywhere for all your .NET Core apps.
D:githubhanselminutes-core> dotnet tool install -g dotnet-format
You can invoke the tool using the following command: dotnet-format
Tool 'dotnet-format' (version '3.0.2') was successfully installed.
D:githubhanselminutes-core> dotnet format
Formatting code files in workspace 'D:githubhanselminutes-corehanselminutes-core.sln'.
Found project reference without a matching metadata reference: D:githubhanselminutes-corehanselminutes.corehanselminutes-core.csproj
Formatting code files in project 'hanselminutes-core'.
Formatting code files in project 'hanselminutes.core.tests'.
Format complete.
You can see in the screenshot below where dotnet format used its scandalous defaults to move my end of line { to its own line! Well, if that's what the team wants! ;)
Of course, dotnet format is all open source and up at https://github.com/dotnet/format. You can install the stable build OR a development build from myGet.
Sponsor: Manage GitHub Pull Requests right from the IDE with the latest JetBrains Rider. An integrated performance profiler on Windows comes to the rescue as well.
When someone mentions the words “Internet of Things,” often the first picture that comes to mind is some sort of device with the Internet “built-in.” However, a built-in design involves months or years of design work and applies only to devices that have yet to come to market. How do businesses leverage IoT for the billions of devices already in the field without creating a large security risk? Within the Azure Sphere team, we have a term for those scenarios that is called “brownfield” deployments. Josh Nash, our product planner, is guest blogging today to tell you more about brownfield IoT and how Azure Sphere can safely connect devices already deployed in the field.
Happy reading!
- Ed Nightingale
As a product planner, I have spent thousands of hours meeting with partners and customers to understand their needs to ensure that our product is not only secured, but also practical and useful. Our first focus is often on new devices, which are devices that have Azure Sphere deeply integrated into the product platform. We refer to these devices as “greenfield” scenarios. These scenarios shine as Azure Sphere’s value proposition resonates soundly, and the implementation is comparatively more straightforward due to the flexibility before a design is considered final. OEMs can focus on how to integrate Azure Sphere within a device’s internal design to meet power, performance, and functionality goals. Devices already in service without connectivity represent a “brownfield” opportunity to create meaningful, new connected experiences across a wide range of equipment. This blog post outlines the challenges of these brownfield devices and how Azure Sphere can help.
The act of connecting enterprise equipment represents an opportunity to enable markedly better outcomes by enabling scenarios and innovative business models for the enterprise such as preventive maintenance, just-in-time reporting, and even role-based access to equipment and data. But there are millions of devices in enterprises around the world that were either put into service before connectivity for non-IT devices was considered feasible or were intentionally not connected because they were deemed too mission critical to be subjected to the unsafe world of the Internet.
While connecting these unconnected devices creates positive outcomes and opportunities for the enterprise, in either case, there are risks associated with connecting these devices. Whether the devices predated connectivity or were deemed too important to connect, the outcome is the same - their lack of connectedness is their security model, a concept known as air-gap security. However, as capabilities improve to solve optimization and other resourcing decisions with the cloud, the value of connectedness increases. At the same time, the risk of connecting air-gap devices is at least as high as before. Businesses need a mechanism to balance the equation, mitigating risk by infusing a new security model into the system design. As the value of connectedness increases, enterprises need a mechanism to securely connect these devices that are already in service.
Microsoft announced Azure Sphere at RSA last year to enable secure, connected, microcontroller- (MCU-) based devices. Azure Sphere unlocks IoT by establishing a foundation on which an enterprise can trust a device to run securely in any environment. Based on the Microsoft whitepaper, “The 7 Properties of Highly Secure Devices,” Azure Sphere delivers device security by combining hardware, operating system software, and cloud services that has been purpose-built for secure IoT applications. Azure Sphere is raising the bar for manufacturers and enterprises to enable secure connectivity in new devices by delivering the seven properties, but it can do more.
Azure Sphere can also deliver secured connectivity to established devices already in service. By utilizing existing ports on an unconnected device, Azure Sphere can be built into a “guardian module” that can be paired with existing equipment to enable secured connectivity that rebalances the opportunity versus risk debate in favor of device connectivity. The key to security in these scenarios is that Azure Sphere, not the device, communicates with the cloud. By separating the device from the network, a guardian module enabled by Azure Sphere can protect the equipment from attack, ensure data is only transmitted between trusted cloud and device communications partners, and ensure the software of the module and the equipment remains intact and secured.
With Azure Sphere in a guardian module, enterprises can enable a variety of secured operations between the device and the cloud. From a device health and security perspective, the device can utilize the Azure Sphere Security Service for certificate-based authentication, failure reporting, and over-the-air software updates. When a guardian module passes authentication, it receives a certificate signed by the Azure Sphere Security Service that can be used to identify the device as genuine in communicating with cloud services. These communications between the guardian module and the cloud could comprise of data coming off the device to signal events or inform decision-making, and they could also represent messages from the cloud to trigger activity from the device itself.
In both directions, applications running on Azure Sphere can be used to validate that messages are properly formed before they are passed to or from the brownfield device and Azure Sphere ensures that the guardian module can only communicate with trusted endpoints. The Azure Sphere Security Service can also be used as a distribution point for software updates not only to the Azure Sphere OS and guardian module manufacturer’s device software, but also for updates to the downstream, previously unconnected device’s software. In this situation, the enterprise can avoid costly truck rolls to update software on their equipment. With a guardian module enabled by Azure Sphere, these brownfield devices can reap most of the benefits of a device that integrated Azure Sphere into its design.
With an Azure Sphere-enabled device, enterprise customers can more confidently connect existing devices to the cloud and unlock scenarios related to preventive maintenance, optimizing utilization, and even role-based access control. When linking a multitude of devices together in the cloud, the possibilities are almost endless.
To start the discussion on how Azure Sphere can help your business, email us at nextinfo@microsoft.com.
Azure Spatial Anchors, a mixed reality service that enables you to build a new generation of mixed reality applications that are collaborative, cross-platform, and spatially aware, is now in public preview. Across industries, developers and businesses are using mixed reality in their daily workflows and giving us feedback on what they’d like to see next. When we look across all the mixed reality solutions that customers have built, two things stand out: they want to easily share their mixed reality experiences and place applications in the context of the real world. Learn about two application patterns gaining momentum across industries, and how Azure Spatial Anchors can help you deliver them with greater ease and speed.
Microsoft Azure Sentinel is available in preview in the Azure portal. Security can be a never-ending saga—a chronicle of increasingly sophisticated attacks, volumes of alerts, and long resolution timeframes where today’s Security Information and Event Management (SIEM) products can’t keep pace. We’ve reimagined a new cloud-native SIEM tool called Microsoft Azure Sentinel to provide intelligent security analytics at cloud scale while making it easy to collect security data across your entire hybrid organization; from devices, to users, to apps, to servers on any cloud.
Metric Alerts with Dynamic Thresholds is now available in public preview. Dynamic Thresholds significantly enhance Azure Monitor Metric Alerts so you no longer need to manually identify and set thresholds. The alert rule now leverages advanced machine learning (ML) capabilities to learn metrics' historical behavior while identifying patterns and anomalies that indicate possible service issues. Metric Alerts with Dynamic Threshold is currently available for free during the public preview.
AzCopy v10 is now available in public preview. Azure Blob Storage offers three different access tiers for saving money depending on storage requirements. Get high-performance, reliable data transfers that work with mixed access tiers inside an Azure storage account using the latest AzCopy, a console tool to help with uploading blobs to Azure Storage.
Integrated Service Environment is now available in every region for which Logic Apps is currently available. In critical business scenarios, you need to have the confidence that your data is flowing between all the moving parts. The core Logic Apps offering is a multi-faceted service for integrating between data sources and services, but sometimes you also need to have a dedicated service to ensure that your integration processes are as performant as can be. That’s why we developed the Integration Service Environment (ISE), a fully isolated and dedicated environment for all enterprise-scale integration needs. Integration Service Environments are available in every region that Logic Apps is currently available in except for West Central US, Brazil South and Canada East.
Announcing the general availability of Java support in Azure Functions 2.0; enabling a wide range of options for you to build and run your Java apps in the 50+ regions offered by Azure around the world. Azure Functions provides a productive programming model based on triggers and bindings for accelerated development and serverless hosting of event-driven applications. It enables developers to build apps using the platform (Windows, Mac, or Linux), programming languages, and tools of their choice; with an end-to-end developer experience that spans from building and debugging locally, to deploying and monitoring in the cloud.
Announcing the general availability of Azure Lab Services - computer labs in the cloud. Provisioning and managing a lab’s underlying infrastructure makes preparing the right lab experience for your users difficult. With Azure Lab Services, you can easily set up and provide on-demand access to preconfigured virtual machines (VMs) to teach a class, train professionals, run hackathons or hands-on labs, and more. Azure Lab Services GA pricing goes into effect on May 1, 2019. Learn more about using Azure Lab Services in this post from the Premier Developer blog: Azure Lab services scheduling now Available.
Announcing support for running Azure Cognitive Services containers for Text Analytics and Language Understanding containers on edge devices with Azure IoT Edge so you can run workloads locally. Whether you don’t have a reliable internet connection, or want to save on bandwidth cost, have super low latency requirements, or are dealing with sensitive data that needs to be analyzed on-site, Azure IoT Edge with the Cognitive Services containers gives you consistency with the cloud. These container images are directly available to try as IoT Edge modules on the Azure Marketplace.
The Internet of Things (IoT) has expanded the world of computing far beyond mobile and PC, bringing a new and ever-growing class of cloud-connected devices that is on track to reach 20 billion devices by 2020. Announcing new IoT partnerships for global-scale IoT solutions with new devices and cloud services that further increase the strategic value of IoT.
Learn more in this post by Julia White, Corporate Vice President, Microsoft Azure on the Official Microsoft Blog: Microsoft at MWC Barcelona: Introducing Microsoft HoloLens 2.
Azure Backup Instant Restore capability for Azure Virtual Machines (VMs) is now available. If you use Azure Backup, Instant Restore helps you quickly recover VMs from the snapshots stored together with the disks. In addition, you get complete flexibility in configuring the retention range of snapshots at the backup policy level depending on the requirements and criticality of the virtual machines associated; giving users more granular control over their resources. We are enabling and rolling out this experience on a region-by-region basis.
Developers can now access the latest Cognitive Services Speech SDK which now supports: selection of the input microphone through the AudioConfig class, expanded support for Debian 9, Unity in C# (beta) on Windows x86 and x64 (desktop or Universal Windows Platform applications), and Android (ARM32/64, x86), and more. Read about all the updates made to the Cognitive Services Speech SDK made in February.
TypeScript is becoming increasingly popular in the JavaScript community. Announcing a set of tooling improvements for TypeScript support in Azure Functions so you can more easily develop with TypeScript when building your event-driven applications. With this set of changes to the Azure Functions Core Tools and the Azure Functions Extension for Visual Studio Code, Azure Functions now supports TypeScript out of the box. Included with these changes are a set of templates for TypeScript, type definitions, and npm scripts.
Optimize your device workflow for easier management and clarity. Introducing a new “Device Templates” navigation tab that replaces the existing “Application Builder” tab, as well as updated patterns for viewing or editing device templates. We've begun a flighted rollout of a new the device modeling.
Implementing IaaS security best practices is an essential step to securing your IaaS resources. Get specific recommendations for improving your IaaS security posture, focus on data protection, strengthen network security, and streamline security management including threat protection. Read the Azure Government Security documentation to understand features and variations for Azure Government.
Every organization has a unique journey to the cloud, based on the organization’s history, business specifics, culture, and maybe most importantly, their starting point. Typically in your migration journey, you use a mixture of tools, so you need to understand the options available in order to select the right tool for the specific workloads. The Azure migration center provides a good model and helpful resources to get you started on your migration to the cloud and to make sure you can create the proper frame for your migration.
Simplify your Azure development with a collection of Azure CLI scripts accessible right at your fingertips.
With the latest enhancements to Cognitive Services’ Computer Vision service, you can extract insights, unlock new workflows, and easily customize and deploy your model without requiring machine-learning expertise.
There are numerous IoT use cases in different industries with common categories like predictive maintenance, connected vehicles, anomaly detection, asset monitoring, and many others. Azure IoT is a complete stack of IoT solutions; a collection of Microsoft managed cloud services that connect, monitor, and control billions of IoT assets. See how to implement an end-to-end Azure IoT solution and use Azure Database for PostgreSQL to store IoT event data in the JSONB format.
In this article, Francesca shares 3-5 lessons learned while building neural networks for time series (leading up to 2-day trainings at AI Conference NYC and Strata Data Conference in San Francisco). With clear explanations, standard Python libraries, readers discovers tips and tricks to develop deep learning models for their own time series forecasting projects.
This is the first in a series of blog posts that will go into depth on how to use popular OSS on top of Azure Kubernetes service. In this post, Scott Coulton runs through how to install istio with Helm and how to deploy two versions of the same application and route traffic on weight (percentage). The post also contains all of the source code and a demo application so you can go and test the topic out for yourself.
This article demonstrates how to configure Azure Resource Locking using Azure Role Based Access Control (RBAC) enables us to restrict access to resources and resource actions, which helps prevent inadvertent resource deletion and modification.
Running a Docker container in Micro Focus Enterprise Server 4.0 is new and provides portability, performance, agility, and isolation. See how to effectively run and manage a mainframe CICS application in a Docker Container using the Windows 2016 Datacenter and the Containers VM now available from the Azure Marketplace.
Suppose we have to design a black box that displays a “thumbs up” or “thumbs down” depending on hundreds of different combinations of inputs. This post describes how to conduct exploratory data analysis using R and Azure Machine Learning Studio to train a “black-box” model in a case when it is difficult to explain how the model characterizes the relationship between the features and the target variable.
Cloud Advocate, Jay Gordon gives you an introduction to Azure Resource Manager Templates and how to begin using them with Azure Cloud Shell. You'll see the number of options available to quickly create Azure resources.
Paresh Mundade, a Senior PM in the Azure ExpressRoute team, gives the guys an update on the service and a glimpse into the roadmap of planned features.
Learn about the new SDKs for Azure Cosmos DB with the JavaScript SDK used as an example as well as learn about CORS (Cross-Origin Resource Sharing) via a simple JavaScript app for demonstration. See a new, low-cost database offer in the Azure portal, watch an Azure DevOps build task setup, get some cost saving tips, and learn about support for multi-region strong consistency.
Learn about the new improvements for Azure Cosmos DB SDKs, including the new, idiomatic .NET SDK with a friendlier, more intuitive programming model, better testability, better performance, .NET Standard 2.0 support. Plus, it is now open sourced.
Azure Maps is the de facto location intelligence platform natively hosted in the Microsoft Azure cloud. Chris Pendleton, PM Lead for the service, gives us an overview of what Azure Maps is, who uses Azure Maps, how Azure Maps is being used across our customer base, and how you can start using Azure Maps today.
learn how to get started with Azure Front Door. Azure Front Door easily makes your applications globally available and secure.
In this video of the Azure Portal "How To" series, learn how to easily create, share, and use dashboards in the Azure Portal. Learn more about the series: Introducing the Azure portal “how to” video series
In this video, get a high-level overview of Identity Protection, a feature of Azure Active Directory. You’ll learn about different types of detections, risks and risk policies that exist in Identity Protection. It explains the benefits of the risk policies, recent UX enhancements, powerful APIs, improved risk assessment and overall alignment along risky users and risky sign-ins. In addition, this series also videos on How to deploy Identity Protection & How to use Identity Protection.
In this episode, Martin Woodward and Jeffrey Palermo dive right into the topic of Azure DevOps with GitHub; discussing some of the changes since Microsoft acquired GitHub, whether you should choose to work with Azure Repos or GitHub, and how to use Azure DevOps Services with GitHub.
The Internet of Things (IoT) is becoming mainstream as companies see market-making benefits from IoT and deploying at scale – from transforming operations and logistics, remote monitoring, and predictive maintenance at the edge, to new consumer experiences powered by connected devices. In all of these solutions, IoT data and AI are producing powerful insights that lead to new opportunities. Microsoft and SAP have announced an expansion of their partnership to include physical devices and assets with a new collaboration in the IoT space. SAP Leonardo IoT will integrate with Azure IoT services, providing customers with the ability to contextualize and enrich their IoT data with SAP business data and to seamlessly extend their SAP solution-based business processes to the Azure IoT Edge platform.
The Azure Marketplace is the premier destination for all your software needs – certified and optimized to run on Azure. Find, try, purchase, and provision applications & services from hundreds of leading software providers. You can also connect with Gold and Silver Microsoft Cloud Competency partners to help your adoption of Azure. In the second half of January we published 70 new offers.
This time on Azure This Week, Lars talks with JT from Microsoft about the brand new HoloLens 2 and how it will be cloud connected, Azure DevOps Projects Kubernetes support gets new features, and you can now protect Azure VMs by using Storage Spaces Direct with Azure Site Recovery.
Organizations deploying IoT solutions often ask similar questions as they address security—What is the risk my organization takes on as we adopt IoT? How much security do we need for our scenario? Where should we invest for the biggest impact? To answer those questions, Microsoft co-authored and edited the Industrial Internet Consortium (IIC) IoT Security Maturity Model (SMM) Practitioner’s Guide. The SMM leads organizations as they assess the security maturity state of their current organization or system, and as they set the target level of security maturity required for their IoT deployment. Once organizations set their target maturity, the SMM gives them an actionable roadmap that guides them from lower levels of security maturity to the state required for their deployment.
Because not all IoT scenarios require the same level of security maturity, the goal of the SMM is to allow organizations to meet their scenario needs without over-investing in security mechanisms. For example, a manufacturing or an oil and gas solution involving safety needs an especially high maturity state.
The SMM complements Microsoft’s body of existing research and standards for IoT security, such as the “Seven Properties of Highly Secure Devices.” While the research in the Seven Properties paper provides a comprehensive deep dive into device security, the SMM takes a broader view of IoT security. This comprehensive model is used in the IoT security space to assess the maturity of organizations’ systems including governance/process, technology, and system security management. Other models typically address IT but not IoT, or IoT but not security, or security but not IoT. The SMM covers all these aspects and leverages other models where appropriate.
While the SMM’s intended audience is owners of IoT systems, decision makers, and security leaders, we expect assessment companies, and assessments groups within organizations, to be the main practitioners of the model. The SMM allows decision makers and security leaders to understand and consistently apply assessments performed by different groups. It also provides flexibility for industry extensions (currently being explored with several industry groups and associations) and allows for different types of visualization of the model results.
The SMM is organized as a hierarchy and includes domains, subdomains, and practices. This hierarchical approach enables the maturity and gap analysis to be viewed at different levels of detail, making it easier for organizations to prioritize gaps.
The SMM also makes an important distinction between security levels and security maturity states, helping organizations to understand the differences between what their goals need to be and where they are in their security journey. In the SMM, a security level is a measure of how much security you have. The SMM does not dictate what the appropriate security level should be for your organization. Rather, it provides guidance and structure so organizations can identify considerations for different security maturity states appropriate for their industry and systems.
Security maturity, on the other hand, is a measure of how well your security technology, processes, and operations meet your organization’s specific needs. The SMM helps you determine how much security you need, based on cost, benefit, and risk. The model allows you to consider various factors such as the specific threats to your organization's industry vertical, regulatory, and compliance requirements, the unique risks present in the environments your IoT operates in, and your organization's threat profile.
As you begin working with the SMM, it guides you through each step of the assessment using the model. Your organization begins by establishing a target state or identifying a relevant industry profile you want to target. Your organization then conducts an assessment to capture a current maturity state. By comparing the target and current states, organizations identify gaps. Based on the gap analysis, business and technical stakeholders can establish a roadmap, take action, and measure the progress. Organizations improve their security state by making continued security assessments and improvements over time. No matter how far along you are with IoT security, the model will help you close gaps that bring you to your desired security maturity.
Once you begin working with the SMM, it guides you through a rigorous approach to defining how well your security state meets your needs. To help you identify actionable areas to improve and to avoid blind spots in your plan, the SMM introduces domains, subdomains, and practices. You can gauge how well your organization is doing in each domain, subdomain, and practice along two dimensions — comprehensiveness and scope. Comprehensiveness is a measure of the depth and with higher levels indicating higher degree of maturity of a process or technology. Scope allows for identifying general, industry, and system specific requirements, ensuring the SMM can be tailored to your industry and use case with more precision than previous models could achieve.
SMM Hierarchy
The domains in the SMM include governance, enablement, and hardening. These domains determine the priorities of security maturity enhancements at the strategic level.
The subdomains reflect the means of obtaining the priorities at the planning level. The practices define typical activities associated with subdomains identified at the tactical level.
The SMM includes practice tables grouped by domains and subdomains. Each SMM practice includes a table describing what must be done to reach a given comprehensiveness level at the general scope. For each comprehensiveness level, the table describes the objective and general considerations, a description of the level, practices that should be in place to achieve that level, and indicators of accomplishment to help assessors determine if the organization has met the requirements of the level.
Of course, general guidelines are often difficult to apply to specific scenarios. For that reason, an example follows each table using various industry use cases to demonstrate how an organization might use the table to pick a target state or to evaluate a current state. The guide also contains three case studies that show IoT stakeholders how to apply the process. The case studies include a smarter data-driven bottling line, an automotive gateway supporting Over the Air (OTA) updates, and consumer residential settings using security cameras. As our work on the SMM continues, we will work with industry organizations and associations to define industry profiles for the SMM.
If you want more information on exactly how the SMM works or how you can begin, the best spot to start is with the model itself: evaluate or improve your IoT security with the SMM today. To learn more about the SMM from its authors, watch our SMM introduction webinar.
For details on building your secure IoT solution on the trusted Azure IoT cloud services, see our Azure IoT Security Architecture for more information or start your free trial to get immediate hands on experience.
Today we are excited to launch two new key capabilities to Azure Firewall.
Azure Firewall is a cloud native firewall-as-a-service offering which enables customers to centrally govern all their traffic flows using a DevOps approach. The service supports both application (such as *.github.com), and network level filtering rules. It is highly available and auto scales as your traffic grows.
Microsoft has a rich signal of both internal threat intelligence data, as well as third party sourced data. Our vast team of data scientists and cybersecurity experts are constantly mining this data to create a high confidence list of known malicious IP addresses and domains. Azure firewall can now be configured to alert and deny traffic to and from known malicious IP addresses and domains in near real-time. The IP addresses and domains are sourced from the Microsoft Threat Intelligence feed. The Microsoft Intelligent Security Graph powers Microsoft Threat Intelligence and provides security in multiple Microsoft products and services, including Azure Security Center and Azure Sentinel.
Threat intelligence-based filtering is default-enabled in alert mode for all Azure Firewall deployments, providing logging of all matching indicators. Customers can adjust behavior to alert and deny.
Figure 1 – Azure Firewall concept architecture
Logging analysis of threat data and actionable insights are all crucial and central themes to planning, building, and operating applications and infrastructure.
Azure Firewall provides full integration with Azure Monitor. Logs can be sent to Log Analytics, Storage, and Event Hubs. Azure Log Analytics allows for the creation of rich dashboards and visualization. Along with custom data queries this powerful integration provides a common place for all your logging needs, with vast options to customize the way you consume your data. Customers can send data from Azure Monitor to SIEM systems such as Splunk, ArcSight and similar third party offerings.
Figure 2 – Azure Firewall detecting a compromised VM using threat intelligence and blocking these outbound connections
Figure 3 – Azure Firewall detecting port scan attempts using threat intelligence and blocking these inbound connections
Along with threat intelligent-based filtering, we are adding support for service tags which have also been a highly requested feature by our users. A service tag represents a group of IP address prefixes for specific Microsoft services such as SQL Azure, Azure Key Vault, and Azure Service Bus, to simplify network rule creation. Microsoft today supports service tagging for a rich set of Azure services which includes managing the address prefixes encompassed by the service tag, and automatically updating the service tag as addresses change. Azure Firewall service tags can be used in the network rules destination field. We will continue to add support for additional service tags over time.
Azure Firewall public REST APIs can be used by third party security policy management tools to provide a centralized management experience for Azure Firewalls, Network Security Groups, and network virtual appliances (NVAs). In September 2018, we announced the private preview for Barracuda’s new service, AlgoSec CloudFlow and Tufin. We are happy to announce that AlgoSec CloudFlow is now available as a public beta. Learn more and join at the Algosec website.
We want to thank all our customers for their amazing feedback since Azure Firewall became generally available in September 2018. We continue to be amazed by the adoption, interest, positive feedback, and the breadth of use cases customers are finding for our service. Please do keep your feedback coming and we look forward to continuing to advance the service to meet your needs.
This is an exciting week for us at Microsoft. At RSA Conference 2019, we are announcing new and exciting capabilities in Azure and Microsoft 365. With this blog post, we wanted to share with you what we have been working on for Azure Security Center. Azure Security Center now leverages machine learning to reduce the attack surface of internet facing virtual machines. Its adaptive application controls have been extended to Linux and on-premises servers, and extends the network map support to peered virtual network (VNet) configurations.
One of the biggest attack surfaces for workloads running in the public cloud are connections to and from the public Internet. Our customers find it hard to know which Network Security Group (NSG) rules should be in place to make sure that Azure workloads are only available to required source ranges. Security Center can now learn the network traffic and connectivity patterns of your Azure workload and provide you with NSG rule recommendations for your internet facing virtual machines. This helps you better configure your network access policies and limit your exposure to attacks.
Azure Security Center uses machine learning to fully automate this process, including an automated enforcement mechanism, enabling its customers to better protect their internet facing virtual machines with only a few clicks. These recommendations also use Microsoft’s extensive threat intelligence reports to make sure that known bad actors are blocked.
Adaptive application control is an intelligent, automated end-to-end application whitelisting solution from Azure Security Center. It helps you control which applications can run on your VMs located in Azure, which, among other benefits, helps harden your VMs against malware. Security Center uses machine learning to analyze the applications running on your VMs and helps you apply the specific whitelisting rules using this intelligence.
We are extending adaptive application controls in Azure Security Center to include Linux VMs and servers/VMs external to Azure (Windows and Linux) in audit mode. This means that Azure Security Center will identify applications running on your servers which are not in compliance with the Azure Security Center generated whitelisting rules and will audit those violations. This will enable you to detect threats that might otherwise be missed by antimalware solutions; to comply with your organization's security policy that dictates the use of only licensed software and to audit unwanted software that is being used in your environment.
Azure Security Center’s network map has added support for virtual network peering, a configuration in which traffic flows between Azure Virtual Networks through the Microsoft backbone, as if they were virtual machines in the same virtual network, through private IP addresses only. The support includes displaying allowed traffic flows between peered VNets and peering related information on Security Center’s network map.
With these additions, Azure Security Center strengthens its role as the unified security management and advanced threat protection solution for your hybrid cloud workloads. We encourage you to take advantage of these new capabilities for all your Internet-exposed Azure resources. If you have not started using Azure Security Center in your Azure subscription, get started today.
Microsoft clients for Azure Event Hubs have always had two levels of abstraction. There is the low-level client, which includes event sender and receiver classes which allow for maximum control by the application, but also force the application to understand the configuration of the Event Hub and maintain an event receiver connected to each partition. Built on top of that low-level client is a higher-level library, Event Processor Host, which hides most of those details for the receiving side. Event Processor Host automatically distributes ownership of Event Hub partitions across multiple host instances and delivers events to a processing method provided by the application.
Service Fabric is another Microsoft-provided library, which is a generalized framework for dividing an application into shards and distributing those shards across multiple compute nodes. Many customers are using Service Fabric for their applications, and some of those applications need to receive events from an Event Hub. It is possible to use Event Processor Host within a Service Fabric application, but it is also inelegant and redundant. The combination means that there are two separate layers attempting to distribute load across nodes, and neither one is aware of the other. It also introduces a dependency on Azure Storage, which is the method that Event Processor Host instances use to coordinate partition ownership, and the associated costs.
Service Fabric Processor is a new library for consuming events from an Event Hub that is directly integrated with Service Fabric, it uses Service Fabric's facilities for managing partitions, reliable storage, and for more sophisticated load balancing. At the same time it provides a simple programming interface that will be familiar to anyone who has worked with Event Processor Host. The only specific requirement that Service Fabric Processor imposes is that the Service Fabric application in which it runs must have the same number of partitions as the Event Hub from which it consumes. This allows a simple one on one mapping of Event Hub partitions to application partitions, and lets Service Fabric distribute the load most effectively.
Service Fabric Processor is currently in preview and available on NuGet at the “Microsoft.Azure.EventHubs.ServiceFabricProcessor” web page. The source code is on GitHub in our .NET Event Hubs client repository. You can also find a sample application available on GitHub.
From the developer's point of view, there are two major pieces to creating an application using Service Fabric Processor. The first piece is creating a class that implements the IEventProcessor interface. IEventProcessor specifies methods that are called when processing is starting up for a partition (OpenAsync), when processing is shutting down (CloseAsync), for handling notifications when an error has occurred (ProcessErrorAsync), and for processing events as they come in (ProcessEventsAsync). The last one is where the application's business logic goes and is the key part of most applications.
The second piece is integrating with Service Fabric by adding code to the application's RunAsync method, which is called by Service Fabric to run the application's functionality. The basic steps are:
Create an instance of EventProcessorOptions and set any options desired.
Create an instance of the IEventProcessor implementation. This is the instance that will be used to process events for this partition.
Create an instance of ServiceFabricProcessor, passing the options and processor objects to the constructor.
Call RunAsync on the ServiceFabricProcessor instance, which starts the processing of events.
For more details follow our programming guide which is available on GitHub. Did you enjoy this blog post? Don't forget to leave your thoughts and feedback in the comment section below. You can also learn more about Event Hubs by visiting our product page.
Have you ever wondered where those service notifications in the Azure Portal and the Azure Status page come from? Curious why some messages appear to have more information than others? Interested in learning more about what goes into an outage statement? This is your chance to find out!
The Azure Communications team will be hosting a special "Ask Me Anything" (AMA) session on Reddit and Twitter. The Reddit session will be held on Monday, March 11th, from 10:00 AM to noon PST. Customers can participate by posting to the /r/Azure subreddit when the AMA is live. The Twitter session will follow soon after on Wednesday, March 13th, from 10:00 AM to noon PST. Be sure to follow @AzureSupport before March 13th and tweet us during the event using the hashtag #AzureCommsAMA.
We are among the first responders during times of crisis - the ones who draft, approve, and publish most customer-facing communications when outages happen. You've probably seen our messages on the Azure Service Health blade in the Portal, the Azure Status webpage, or even on the @AzureSupport Twitter handle. We'd like to think we bridge the gap between customers and the action happening behind the scenes.
Our communications are very crisis-oriented. When there is any kind of service interruption with the Azure platform, we are responsible for making sure our customers are provided with timely and accurate information. This includes information about outages, maintenance updates, and other good-to-know information for customers. We do not, however, manage any advertising or promotional communications.
We have three primary channels for communicating with customers: Azure Service Health in the Portal, the Azure Status webpage, and @AzureSupport on Twitter.
Azure Service Health - Azure Service Health provides personalized guidance directly to customers when issues with the Azure platform affect their resources. Customers can review a personalized dashboard in the Portal, set up targeted notifications (email, SMS, webhook, etc.), receive support, and share details easily.
Azure Status webpage - This public-facing webpage (which does not require signing in) is only used to provide updates for major incidents or when there are known issues preventing access to Azure Service Health in the Portal. Customers should only refer to this page if they are not able to access Azure Service Health.
@AzureSupport on Twitter - In many ways, the @AzureSupport Twitter handle is a dynamic component of our communications process. Twitter allows engineering and support teams to gauge the pulse of the Azure platform through customer engagements on Twitter and act as a complementary resource to the Azure Status webpage. If necessary, @AzureSupport can even be used as a communications medium when Azure Service Health or the Azure Status webpage are not available.
We’re going to be honest – we want there to be as little a disconnect as possible between customers and the action happening behind the scenes. An AMA provides us with an opportunity to connect with customers on a more intimate, informal level, and allows us to receive feedback directly from customers about some of the real-time decisions that are made during times of crisis. Hosting a multi-channel AMA through both Reddit and Twitter allows us to connect with a broad social community while providing customers with an experience based on transparency that is second to none.
If you’re on Reddit, subscribe to the /r/Azure subreddit by Monday, March 11th, at 10:00 AM PST. Pochian Lee, Drey Zhuk, and others from the Azure Communications team will be answering questions on Reddit until noon. Just log in and post your questions to get started. If you’re on Twitter, be sure to follow @AzureSupport before Wednesday, March 13th. Starting at 10:00 AM PST, the team will be answering questions on Twitter until noon. Just tweet your questions to @AzureSupport during the event and be sure to include the #AzureCommsAMA hashtag so we don't miss you! While we will only be answering questions live during the event, customers are encouraged to post or tweet their questions any time starting at 10:00 AM on March 8th. This gives customers in different time zones an opportunity to participate.
The majority of our outages impact a limited subset of customers and we reach out to the impacted customers directly via the Azure Service Health blade. The Azure Status webpage provides information regarding any major impacting event that customers should be aware of on a broader scale.
If after looking in the Azure Service Health blade to see if you have been impacted by an outage, you find that your problem doesn’t match the impact that we’re observing, we would recommend that you create an Azure support case.
If you do not see a notification within the Azure Service Health blade and believe that there is an outage, please create an Azure support case.
If you believe you are impacted by an outage, then yes!
Customers can receive additional notifications via Azure Service Health and Azure Resource Health.
Azure Service Health - To get notifications during an outage, you would need to setup alerts within Azure Service Health to your preference (i.e you want to be notified for any outage affecting my virtual machines in the eastern US). Find additional information, and learn how to request notifications in this documentation.
Azure Resource Health - To get notifications based on the health of your individual resources (i.e. I want to be notified about issues for these two specific Virtual Machines), customers can configure Resource Health alerts by following the steps in this article.
We try our best to inform impacted customers of an outage using our telemetry and are actively working on improving our telemetry to make sure we alert all customers that are impacted. We’ve made great progress for certain scenarios where our automated alerting is triggered from high-fidelity monitoring within our system. We’re looking to further develop this telemetry to ensure that the right customers are informed in a timely manner.
Communications can be seen within the Azure Service Health blade.
As soon as we’re able to validate customer impact and the services involved, we inform customers immediately. We’re actively working on improving our automation and telemetry to make sure customers are aware in real-time.
We have heard this feedback before and are currently collaborating with partner teams to improve the visibility of the communications in the Azure Portal.
Be sure to subscribe to /r/Azure and follow @AzureSupport on Twitter before March 11th, 2019, in order to participate. We look forward to answering your questions live during the event!
In February, Microsoft shared an ambitious vision to continue innovating as a technology provider and to improve the experience for solution developers and service providers when engaging with Microsoft. Our partners are delivering more innovation in AI, expanding their business through more co-selling opportunities, and leveraging distribution options through our commercial marketplaces such as Azure Marketplace and AppSource.
Today, we’re very excited to begin rolling out an initial set of platform changes which open new opportunities for our partners to go to market with Microsoft. This work sets the stage for more enhancements coming this winter and spring that continue to drive partner business acceleration. Get a sneak peek on our public marketplace roadmap.
Microsoft’s Cloud Solution Provider (CSP) partner program is the largest channel program in the industry with more than 60,000 channel partners serving millions of Microsoft customers worldwide. Starting today, ISVs can choose to make their transactable Azure Marketplace offer available for distribution through the CSP channel. Partners in the CSP program will be able to sell, deploy, and bundle Azure services with Azure-optimized ISV software from the marketplace to better serve customers and grow their managed services business.
Within Partner Center’s new marketplace page, CSP partners can discover, evaluate, and learn about all the Azure Marketplace solutions available through the channel. Software-as-a-Service (SaaS) subscriptions can be established through the standard purchase workflow in Partner Center, and Azure resources such as VM or container images may be deployed and procured through the Azure management portal. All of the transactions will now be available on a consolidated invoice making legal, billing, and account support much simpler.
Publisher partners can learn how to create or update offerings for CSP channel availability.
CSP partners can also explore the marketplace page in Partner Center.
Screenshot of new marketplace discovery experience in Partner Center under the “Sell” navigation pane
As customer adoption for marketplaces continues to grow around the world, we expanded our global marketplace reach. We are pleased to share that Azure Marketplace has expanded coverage to 53 new countries, allowing partners now to sell into a total of 141 countries with 17 currencies.
Last year, we launched SaaS in Azure Marketplace with the ability to pay per month. As enterprise adoption of SaaS continues to grow, customers are looking for a variety of billing options. Today, we are pleased to highlight a new annual billing option for SaaS offers. We are also releasing a new set of tools to reduce procurement complexity for customers and ISV partners. For example, the new standard contract allows ISVs to leverage a unified and common set of terms and conditions for end customers.
Have questions or feedback? See the new or updated resources below. We also invite you to join us in the Microsoft Partner Community for discussion!
For read-heavy workloads that you are looking to scale out, you can use read replicas, which are now generally available to all Azure Database for MySQL users. Read replicas make it easy to horizontally scale out beyond a single database server. This is useful in workloads such as BI reporting and web applications, which tend to have more read operations than write.
The feature supports continuous asynchronous replication of data from one Azure Database for MySQL server (the “master” server) to up to five Azure Database for MySQL servers (the “read replica” servers) in the same region. Read-heavy workloads can be distributed across the replica servers according to your preference. Replica servers are read-only except for writes replicated from data changes on the master.
You can create or delete replica servers based on your workload’s needs. A master server can support up to five replica servers within the same Azure region. Stopping replication to any replica server makes it a standalone read-write server.
You can easily manage your replica servers using the Azure portal and Azure CLI.
From the Azure portal:
Use Azure Monitor to track replication with the “replication lag in seconds” metric:
From the Azure CLI:
az mysql server replica create -n mydemoreplica1 -g myresourcegroup -s mydemomaster
Below are some application patterns used by our customers and partners that leverage read replicas for scaling workloads.
Data from disparate data sources is processed every few minutes and loaded into the master server. The master server is dedicated for loads and processing, not directly exposing it to BI users for reporting or analytics to ensure predictable performance. The reporting workload is scaled out across multiple read replicas to manage high user concurrency with low latency.
In this architecture pattern, the application is broken into multiple microservices, with data modification APIs connecting to the master server while reporting APIs connect to read replicas. The data modification APIs are prefixed with “Set-”, while reporting APIs are prefixed with “Get-“. The load balancer is used to route the traffic based on the API prefix.
This blog post was co-authored by Sumeet Mittal, Senior Program Manager, Azure Networking.
Ensure security and limit access to your MariaDB server with the virtual network (VNet) service endpoints now generally available for Azure Database for MariaDB. VNet service endpoints enable you to isolate connectivity to your logical server from a given subnet within your virtual network. The traffic to Azure Database for MariaDB from your VNet always stays within the Azure network. Preference for this direct route is over any specific ones that route Internet traffic through virtual appliances or on-premises.
There is no additional billing for virtual network access through VNet service endpoints. The current pricing model for Azure Database for MariaDB applies as is.
Turning on VNet service endpoints does not override firewall rules that you have provisioned on your Azure Database for MariaDB, both remain applicable.
VNet service endpoints don’t extend to on-premises. To allow access from on-premises, you can use firewall rules to limit connectivity only to your public (NAT) IPs.
To learn more about VNet protection view our documentation, “Use Virtual Network service endpoints and rules for Azure Database for MariDB.”
When you connect to your server with service endpoints turned on, the source IP of database connections switches to the private IP space of your VNet. Configuration is via the “Microsoft.Sql” shared service tag for all Azure Databases including Azure Database for MariaDB, MySQL, PostgreSQL, Azure SQL Database and Managed Instance, and Azure SQL Data Warehouse. If at the present time your server or database firewall rules allow specific Azure public IPs, then the connectivity breaks until you allow the given VNet/subnet by specifying it in the VNet firewall rules. To ensure connectivity, you can preemptively specify VNet firewall rules before turning on service endpoints by using the IgnoreMissingServiceEndpoint flag.
As part of general availability, we support service endpoints for App Service Environment (ASE) subnets deployed into your virtual networks.
Today we are excited to announce the public preview of Azure Premium Blob Storage. Premium Blob Storage is a new performance tier in Azure Blob Storage, complimenting the existing Hot, Cool, and Archive tiers. Premium Blob Storage is ideal for workloads with high transactions rates or requires very fast access times, such as IoT, Telemetry, AI and scenarios with humans in the loop such as interactive video editing, web content, online transactions, and more.
Our testing shows that both average and 99th percentile server latency is significantly lower than our Hot access tier, providing faster and more consistent response times for both read and write across a range of object sizes. Your application should be deployed to compute instances in the same Azure region as the storage account to realize low latency End-to-End. For more details see, “Premium Blob Storage - a new level of performance.”
Figure 1 - Latency comparison of Premium and Standard Blob Storage
Premium Blob Storage is available with Locally-Redundant Storage (LRS) and comes with High-Throughput Block Blobs (HTBB), which provides very high and instantaneous write throughput when ingesting block blobs larger than 256KB.
You can store block blobs and append blobs in Premium Blob Storage. To use Premium Blob Storage you provision a new ‘Block Blob’ storage account in your subscription (see below for details) and start creating containers and blobs using the existing Blob Service REST API and/or any existing tools such as AzCopy or Azure Storage Explorer.
Premium Blob Storage has higher data storage cost, but lower transaction cost compared to data stored in the regular Hot tier. This makes it cost effective and can be less expensive for workloads with very high transaction rates. Check out the pricing page for more details.
Premium Blob Storage public preview is available in US East, US East 2, US Central, US West, US West 2, North Europe, West Europe, Japan East and Southeast Asia regions.
At present data stored in Premium cannot be tiered to Hot, Cool or Archive access tiers. We are working on supporting object tiering in the future. To move data, you can synchronously copy blobs from using the new PutBlockFromURL API (sample code) or AzCopy v10, which supports this API. PutBlockFromURL synchronously copies data server side, which means that the data has finished copying when the call completes, and all data movement happens inside Azure Storage.
To create a block blob storage account using the Azure Portal navigate to the ‘Create storage account’ blade and fill it in:
Example below:
Once you have created the account, you can manage the Premium Blob Storage account, including generating SAS tokes, review metrics, and more.
To create a block blob account, you must first install the PowerShell AzureRm.Storage preview module.
Step 1: Ensure that you have the latest version of PowerShellGet installed.
Install-Module PowerShellGet –Repository PSGallery –Force
Step 2: Open a new PowerShell console and install AzureRm.Storage module.
Install-Module Az.Storage –Repository PSGallery -RequiredVersion 1.1.1-preview –AllowPrerelease –AllowClobber –Force
Step 3: Open a new PowerShell console and login with your Azure account.
Connect-AzAccount
Once the PowerShell preview module is in place you can create a block blob storage account:
New-AzStorageAccount -ResourceGroupName <resource group> -Name <accountname> -Location <region> -Kind "BlockBlobStorage" -SkuName "Premium_LRS"
To create a block blob account, you must first install Azure CLI v. 2.0.46 or higher, then
Step 1: Login to your subscription
az login
Step 2: Add the storage-preview extension
az extension add -n storage-preview
Step 3: Create storage account
az storage account create --location <location> --name <accountname> --resource-group <resource-group> --kind "BlockBlobStorage" --sku "Premium_LRS"
We would love to get your feedback at premiumblobfeedback@microsoft.com.
We are very excited about being able to deliver Azure Blob Storage with low and consistent latency with Premium Blob Storage and look forward to hearing your feedback. To learn more about Blob Storage please visit our product page. Also, feel free to follow my Twitter for more updates.
Following the launch of Azure DevOps in September, we’re pleased to announce the official release of Azure DevOps Server 2019! Previously known as Team Foundation Server (TFS), Azure DevOps Server 2019 brings the power of Azure DevOps into your dedicated environment. You can install Azure DevOps Server 2019 into any datacenter or sovereign, and determine when to apply updates.
Azure DevOps includes developer collaboration tools which can be used together or independently, including Azure Boards (Work), Azure Repos (Code), Azure Pipelines (Build and Release), Azure Test Plans (Test), and Azure Artifacts (Packages). These tools support all popular programming languages, any platform (including macOS, Linux, and Windows) or cloud, as well as on-premises environments. Like with TFS, you control where you install Azure DevOps Server and when you apply updates. If you prefer to let us manage, use Azure DevOps Services which is available in more geographic regions than any other cloud hosted developer collaboration service.
The release notes describe the major updates from TFS 2018 to Azure DevOps Server 2019, but my key highlights include:
Whether your evaluating a new installation or planning an upgrade from a previous version of TFS, the following resources can help.
We are thrilled to share the release of Bot Framework SDK version 4.3 and use this opportunity to provide additional updates for the Conversational AI releases from Microsoft.
Microsoft Bot Framework lets you connect with your users wherever your users are. We offer thirteen supported channels, including popular messaging apps like Skype, Microsoft Teams, Slack, Facebook Messenger, Telegram, Kik, and others. We have listened to our developer community and addressed one of the most frequently requested features – added LINE as a new channel. LINE is a popular messaging app with hundreds of millions of users in Japan, Taiwan, Thailand, Indonesia, and other countries.
To enable your bot in the new channel, follow the “Connect a bot to LINE” instructions. You can also navigate to your bot in the Azure portal. Go to the Channels blade, click on the LINE icon, and follow the instructions there.
In the 4.3 release, the team focused on improving and simplifying message and activities handling. The Bot Framework Activity schema is the underlying schema used to define the interaction model for bots. With the 4.3 release, we have streamlined the handling of some activity types in the Bot Framework Activity Schema, exposing a simple On* methods, thus simplifying the usage of such activities. On top of the activity handling improvements, for C# we have added MVC support, allowing developers to use the standard ASP.NET core application and ApiController. As with any release, we fixed a number of bugs, continue to improve LUIS and QnA integration, and further clean our engineering practices. There were additional updates across other areas like Language, Prompt and Dialogs, and Connectors and Adapters.
This release introduces a new way to handle incoming messages through a new class called ActivityHandler. An ActivityHandler receives incoming activities, as defined in the Bot Framework Activity Schema, then delegates the handling of each activity to one or more handler functions based on the activity’s type and other properties. For example, ActivityHandler exposes methods such as:
You can find all the methods in the ActivityHandler.ts (for JavaScript) and ActivityHandler.cs (for .NET).
Using ActivityHandler, developers can handle events for incoming messages, application events, and a variety of conversation update events. This should make it easier to create common bot behaviors such as sending greetings and welcoming users.
This class provides an extensible base for handling incoming activities in an event-driven way. In JavaScript and TypeScript, the base ActivityHandler class can be used directly as main activity handler, as seen in the example code below. Developers can also derive subclasses from it to extend the core features.
Here is a small JavaScript code snippet example:
// Import the class from botbuilder sdk
const { ActivityHandler } = require('botbuilder');
// Create the bot “controller” object
const bot = new ActivityHandler();
server.post('/api/messages', (req, res) => {
adapter.processActivity(req, res, async (context) => {
// Route incoming activities to the ActivityHandler via the run() method
await bot.run(context);
});
});
// bind a handler for all incoming activities of type message
bot.onMessage(async (context, next) => {
// do stuff
await context.sendActivity(`Echo: ${ context.activity.text }`);
// proceed with further processing
await next();
});
// say hello when new members join
bot.onMembersAdded(async(context, next) => {
await context.sendActivity('Hello! I am a bot!');
await next();
});
A core tenant for the Bot Framework team is to drive parity across .NET and JS implementations. In that spirit, the .NET implementation of the ActivityHandler.cs exposes the same functionality with the given special programing language capabilities. However, ASP.NET Core provides a rich set of infrastructures supporting Web API, which can be easily integrated and used by bot developers. Therefore, in addition to the activity handling improvements, for C# we have added Web API support, allowing developers to use standard ASP.NET core application and ApiController.
Here is a simple code snippet for ASP.NET Web API Controller:
[Route("api/messages")]
[ApiController]
public class BotController : ControllerBase
{
private IBotFrameworkHttpAdapter _adapter;
private IBot _bot;
public BotController(IBotFrameworkHttpAdapter adapter, IBot bot)
{
_adapter = adapter;
_bot = bot;
}
[HttpPost]
public async Task PostAsync()
{
// Delegate the processing of the HTTP POST to the adapter.
// The adapter will invoke the bot.
await _adapter.ProcessAsync(Request, Response, _bot);
}
}
Note, the _bot passed to _adapter.ProcesAsync method is the actual bot implementation and will handle any activity sent from the adapter, which has a very similar code to the above JS sample.
QnA Maker released Active Learning, which helps developers improve their knowledge base, based on real usage. Active learning helps identify and recommend question variations for any question and allows users to easily add them to their knowledge base.
For a user query, if QnA Maker returns top N answers where the difference in confidence score is low, Active Learning is triggered. Based on collective feedback across users, QnA Maker shows suggestions for alternate questions in your knowledge base.
To learn more about how QnA Maker Active Learning works and how to use it, read the documentation, “Use active learning to improve knowledge base.”
Templates and Solution Accelerators provide a mechanism to identify high growth opportunities for our Conversational AI, Speech, and broader Azure platform. These enable our customers and partners to accelerate delivery of advanced, transformational conversational experiences typically not viewed as possible or require too much effort to deliver a high-quality experience.
In this latest release we have provided significant updates to our Templates and Virtual Assistant solution. A high level summary of changes are covered in our Release Notes.
We are happy to share the availability of a JavaScript (Typescript) version of the Enterprise Template along with a Yeoman Generator. Work has started on the equivalent for the Virtual Assistant. We’ve also added coded unit tests to all Bots created by the templates providing a way to automate unit testing of dialogs along with further enhancements to the telemetry capabilities and the associated PowerBI dashboard.
We’ve also delivered a wide range of changes to the Virtual Assistant and Skills including a new template enabling Skills to be quickly created and added to a Virtual Assistant. There is also new support for proactive experiences, enabling the assistant and Skills to proactively reach out to a user or perform long running asynchronous operations.
Also, in this release are wide ranging improvements to the Productivity Skills including email, calendar, and to-do, as well as the addition of FourSquare support to the Point of Interest Skill, and an enhanced WebChat test experience.
Web Chat is a popular component that lets developers add a messaging interface for their bot on the websites or mobile apps. Web Chat 4.3 release addresses the remaining accessibility issues and popular feature requests, like better indication of connectivity state for users with poor network connection.
To try Web Chat 4.3, follow the instructions on GitHub or explore code samples.
As we continue to improve our conversational AI tools and framework, we look forward to seeing what conversational experiences you will build for your customers. Get started today!