Due to Microsoft .NET Framework Security Updates, some BizTalk Server installations may be affected. Access denied or Class not registered errors.

BizTalk engine will still process messages, including sending and receiving them.

The symptoms:

• You can’t see, stop or start host instances
• You can’t refresh applications
• Gives access denied or Class not registered errors while trying to load some panels inside BizTalk Server Administration Console
• Random errors in BizTalk Server Administration Console while browsing
• Other weird issues while deploying applications via Deployment Framework for BizTalk (BTDF)

.NET Framework (4.6.2) has received some security updates on 20th July 2018. These updates refresh some assemblies that are in use by BizTalk Server! Microsoft states that a fix is coming mid July 2018, but, at this moment, I’m not seeing these “fixes” in my machine…

The actual fix;

You need to uninstall ALL your .NET Framework updates for version 4.6.2 that were installed after 19th of July 2018! Follow these simple steps to uninstall them (if you don’t know how to do it):

1. Open Control Panel
2. Select Program and Features
3. On the left pane, select “View installed updates”
4. Uninstall every update that targets .NET Framework 4.6.X that were installed AFTER 19th July 2018

IMPORTANT NOTE: Uninstalling some of them may require a reboot. DO NOT REBOOT UNTILL ALL UPDATES ARE UNINSTALLED!

Below are some updates that were identified by users as source of their problems:

• BizTalk Server 2013 R2: KB4338600, KB4338601
• BizTalk Server 2010: KB4338602
• Other versions: KB4338600, KB4338605, KB4338613, KB4338814, KB4338424, KB4338419

The one that was causing my BizTalk Server Administration Console to fail was KB4338606. As you can see, this update isn’t listed above. Those updates were identified by other users, they may not, by any means, be the origin of your problems. This is why I prefer to uninstall them all! Remember, your mileage my vary.

If you have any questions or if you need help to figure this out, feel free to post a comment! I’ll try my best to help you out!

The post [FIX] BizTalk Server 2010, 2013, 2013 R2 & 2016 errors “Class not registered (WinMgmt)” or “Access denied” appeared first on Blog IT.

This tutorial will show you how to include your non-compilable items into a nuget package (nupkg). This steps apply to any type of file.

DISCLAIMER: You must have a nuspec file and a targets file. If you don’t have one yet, download one from somewhere and change the metadata accordingly.

Let’s start!

1. Open up your solution in Visual Studio
2. Open your solution’s nuspec file and look for <files> tag
3. You need to reference all folders and all files that you want to include in your nuget. Example below:

<files>
    <file src="lib\net452\your_compiled_assembly.dll" target="lib\net452" />
    <file src="Your_Folder\*.pp" target="content\Your_Folder"/>
    <file src="Your_Folder\Your_Sub_Folder\*.*" target="content" />
    <file src="*.xdt" target="content" />
 </files>

4.  After you added all files into nuspec config, now you can open your targets file. Don’t forget to import targets into your csproj file like the example below

<Import Project="your_targets_file.targets" Condition="Exists('your_targets_file.targets')" />

5. Now to targets file, you must index ALL files that you want to add to your nuget. This step is very important

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 <TargetName="CreatePackage">
   <PropertyGroup>
   <Configuration>Release</Configuration>
   <PackageSource>bin\$(Configuration)\Package</PackageSource>
   <NuSpecPath>$(MSBuildProjectName).nuspec</NuSpecPath>
   </PropertyGroup>
   <RemoveDirDirectories="$(PackageSource)"/>
   <MSBuildProjects="$(MSBuildProjectFullPath)" Targets="Rebuild"Properties=" TargetFrameworkVersion=v4.0; OutputPath=bin\$(Configuration)\net40;Configuration=$(Configuration)" BuildInParallel="$(BuildInParallel)"/>


   <Copy SourceFiles="bin\$(Configuration)\net40\$(AssemblyName).dll" DestinationFolder="$(PackageSource)\lib\net40"/>
   <Copy SourceFiles="$(NuSpecPath)" DestinationFolder="$(PackageSource)"/>
   <Copy SourceFiles="Your_Folder\Your_Class_File.cs.pp" DestinationFolder="$(PackageSource)\Your_Folder"/>
   <Copy SourceFiles="Your_Folder\Yet_Another_Class.cs.pp" DestinationFolder="$(PackageSource)\Your_Folder"/>
   <Copy SourceFiles="Your_Folder\Your_Sub_Folder\A_Class.cs.pp" DestinationFolder="$(PackageSource)\Your_Folder\Your_Sub_Folder"/>
   <Copy SourceFiles="Your_Images_Folder\Your_Image.jpeg" DestinationFolder="$(PackageSource)\Your_Images_Folder"/>
   <Copy SourceFiles="Your_root_file.xml" DestinationFolder="$(PackageSource)"/>
 </Target>
</Project>

6. After you added all your source files into your targets file, you are ready to pack it!!

File extensions for Transformations and generated classes:

1. A pp file extension is a class that’s generated when a nuget is installed in any solution. Usually, the class namespace is replaced by “$rootnamespace$” (without quotes) and the extension is added (yourclass.cs.pp)
2. A xdt file extension is a XML Transformation procedure.

Example of a *.pp class ready to be packed into a nuget:

namespace $rootnamespace$.App_Start
{
 using System;
 using System.Collections.Generic;
 using System.Configuration;
 using System.Linq;
...
}

That’s all folks!

The post How to add your custom content files into a nuget package (for Visual Studio) appeared first on Blog IT.

Create IT as an Internet connection of 100mbps Down/20mbps Up. Azure was capping at a 150mbps symmetrical connection.

TeamViewer VPN, Azure Site-to-Site and Point-to-Site connections were capped at 10mpbs.

Azure plans

In Azure, the most economical plans were chosen, considering our requirements. Some plans were free, some were cheaper than the others, but having VPN capabilities and all configurations supported, we chose the cheaper plans that were available with all these needed features supported.

Browsers

We used Chrome, Firefox and Edge. This was to eliminate browser differences. Not showing any differences in total execution times, we kept using Chrome as a default testing browser.

LAN Connection

Lan wise, our internal network is based on a 1gbps Local Area Network.

On-Premises Service Host

The On-Premises Service was hosted on a machine running Windows 10 Retail with latest updates installed and IIS Express. All code was made with Visual Studio 2017 Enterprise. The relevant host hardware specifications are:

1. Intel® Core™ i7-6700HQ CPU @ 2.6GHz
2. 32GB of RAM DDR4 @ 3400MHz
3. NVMe M.2 PCI-e 240GB SSD

Testing Hours

All tests were executed on working hours, 9am to 18pm, GMT.

The Writer

I’m a consultant @ Create It, a Portuguese company. If you read this, make sure I know about it! ? Hugs and kisses! This was an absolute pleasure to make ?

The post Latency test between Azure and On-Premises – Specifications appeared first on Blog IT.

Note: 5MB results must be multiplied by 10 (value x 10)

Here are the results. All of them. Don’t forget to multiply 5MB results by 10!

With the graph below, we can check how message sizes influence latency. After doing some math, these are the results:

As we can confirm, latency follows an exponential growing rate, which means, the bigger the message, even greater will be latency. We can confirm that, for each scenario, this applies.

But what does it tell me? This tells you that you need to be careful if you’re planning on sending big messages between two points. This exponential growing rate applies to all scenarios!

All values listed and noted, so we gave tests a score. This score is calculated by adding all three results (10kb, 100kb and 5mb) and dividing all by three. This will give us average execution time. For your best understanding, below is an exponential graph. This climbs faster and faster to infinity, being the horizontal axle message sizes, and the vertical one latency:

Now for the results!

As we can check, Test #2 (Local On-Premises LAN) was the winner here, latency wise. This was expected. Although this is the fastest, it’s the riskiest and NOT RECOMMENDED! It’s true that latency is reduced, but with only ~53ms difference between Azure Site-to-Site on a 100Kb message, is it worth to have a full infrastructure depending on your maintenance? And the networking gear it requires? What about having someone responsible for the room 24/7? How about costs? Think about it! Think about savings when migrating your business to Cloud!

Second place goes to HTTP without VPN (Exposed services). Not a Cloud solution, and a risky one too! If you like hackers messing with your vital business services and trying to break in from all over the world 24/7, go right ahead!

Regarding fast and safe Cloud solutions, which is the main reason of reading this document after all, the winner was Test #4 (Azure Site-to-Site VPN), getting third place on the board, by a difference of 8 points! This managed to be the safest, more efficient and with 99.9% uptime method of expanding your office or network, and have a low-latency data exchange. This is the optimal and safer solution. No hackers, no maintenance, no worries!

Consult us to migrate your business! You’re at the doorstep to your future!

For full test specifications, read here!

The post Latency test between Azure and On-Premises – Conclusions appeared first on Blog IT.

First step is to configure an Hybrid Connection in Function Apps network configuration. Then, you can run Hybrid Connection Manager (assuming you’ve downloaded it from Azure), to manage your connection.

After saving which connection you want to use, you can always confirm connection status in this window:

But wait, I see Service Bus referenced in that print screen! What’s that?

Service Bus is a technology of asynchronously sending and receiving messages from multiple publishers to multiple subscribers. This is, as you’ve probably guessed, a publish/subscribe mechanism.

This is an example of a publish/subscribe architecture. The image should be self-explanatory. A sender sends a message, and all subscribers have filters to only process the messages that they subscribe to.

Why didn’t you test this method?

Well, before you call me anything, you got to understand why.

Architecture!

This concept relies on checking the bus for new messages from time to time, with a 10 second interval for instance. Each 10 second, your program/service, or whatever you want to call it, will check the bus for new messages and retrieves them. This generates a “waiting game”, that’s why it’s called an asynchronous process. It’s not designed to be fast, but to be reliable and to connect multiple services into one giant message box.

Example:

A highway. A highway in USA connects multiple states together, and you can choose where to leave it. You can choose a city in a certain state, or a totally different city in another state, it just depends where you’re going to. This is the same. The service bus it’s like that highway. A publisher publishes a car. Each message (car) has a topic (destination), and every subscriber (city/state) retrieves a message (car) depending on their topic (destination).

This is the main reason that latency doesn’t apply here. It’s a very robust and clean way of integrating services with applications, but latency isn’t a concern here. It’s just not made to be fast. It’s made to be simple.

Conclusions and summary next post!

The post Latency test between Azure and On-Premises – Part Seven appeared first on Blog IT.

This function calls our  REST Web Service (On-Premises) via Point-to-Site VPN connection to Azure. This can be called on-demand via URL, via Run button on the image, or via Logic Apps.

Important note:
In this scenario, the client makes one single HTTP request, instead of 10 requests as previous scenarios.

This is a Logic App (Designer View). We start by a Recurrence Action, which is a timer set to run each 30 second. When recurrence action is fired, this logic app starts by calling “HttpTriggerCSharp1”, which is the function app showed previously. When this function app is finished, the logic app sends an e-mail to my Create account reporting total execution time.

Finally, this is the e-mail that is sent by our logic app. We can see that total execution time reported by the function app is 63ms. Read on for full results!

Test #6 10kb message

Called by a Logic App trigger, the client makes a HTTP request to our On-Prem Service, receiving a 10kb message, the same as before.

We can see that total execution time was 59ms. This is measured by calling the function app via Run button. We’ll be doing this due to being easier to obtain results. This same result is reported by mail if the function is called by Logic Apps. Execution time oscillated between 47ms and 70ms, being the median value ~59ms. Not bad, and slightly faster than TeamViewer VPN, but slower than direct HTTP request without VPN.

Regarding this same result and comparing it to Site-to-Site VPN, we can see that this method took more ~15ms to execute. This can have a very important influence if you are choosing between PTS and Site-to-Site for your business. Also, Site-to-Site has a more constant flow, while this test was more irregular (had more peaks).

Rest assured that this method works, if you can trade a slight latency increase over cost.

Test #6 100kb message

Now for 100kb message, we’ll repeat the same steps to obtain the results.

As we can verify, the test took 78ms to execute. It peaked 97ms and drops to 68ms. Overall, it took more ~8ms to execute than Site-to-Site but was ~22ms faster than TeamViewer. Regarding direct HTTP request without any VPN, this was slower ~17ms. That’s quite a punch there. Let’s try 5Mb.

Test#6 5mb message

Now to the ultimate 5MB test. No more words needed here.

We can see that this is a deal breaker here. The latency here is way over any other test we did. 3.8s! This may happen due to several reasons, the main ones being:

1. Function App performance not meeting our requirements,
2. The way that Azure connects PTS VPN to Function Apps,
3. Consuming a large data might be doing some memory swaps server-side.

Overall test discussion

Well, this is very surprising. Function Apps is clearly not the way for a large message. The processing is inefficient, therefore takes way too much time. PTS connection to a VM in Azure was faster by more than one second, and surprisingly cheaper!

This solution may still be in Preview, or may have bugs, or maybe it just wasn’t made for this type of usage. Regarding complexity, is clearly simpler to use than a VM, it’s serverless and scalable. You can get rid of VM and make your functions directly accessible via any web browser on any platform.

For exposing your logic in a cleaner, faster way, this is what you need. For data crunching or analytics, it’s also the cleanest way, but if you’re planning to use it to make HTTP requests to your on-prem services, you should consider other options, unless execution time isn’t on the equation.

Read the next post here about relays and service bus!

The post Latency test between Azure and On-Premises – Part Six appeared first on Blog IT.

Will this be faster that Azure Site-to-Site?

Test #5 10kb message

10Kb is our base message. PTS didn’t show any issues regarding this one.

Execution time is practically the same as before (on Site-to-Site scenario), with the same message size. 1% is not noticeable on a large batch execution. Let’s see for 100KB. If results change more drastically, then we can analyze and find a reason for this.

Test #5 100kb message

We didn’t see a big difference before. Will 100kb be the game changer?

Actually, it is! It’s ~10ms faster than before! Site-to-Site is beginning to lose to PTS.

Probable causes are:

1. Router delays due to packet queues (Site-to-Site)
2. Router processing power limitations of encrypting packets (and routing them)
3. General hardware limitations

 We start to see some differences now. ~10ms is a noticable improvement. How fast will 5MB be?

Test #5 5mb message

The ultimate test on PTS.

Well, PTS it’s not for large messages. It’s inefficient and takes a lot of time! You should only use this for a one-time-only scenario, like accessing a VM or downloading some files from Azure. Processing large messages with PTS is not recommended, as execution times increased ~1 second in average.

 Overall test discussion

This is an awkward situation. 100KB is faster than Site-to-Site, but 5MB it’s not. While processing small to medium messages you should be fine. Not recommended for production as it showed to have some unusual peaks, so latency may be compromised.

Go to next test!

The post Latency test between Azure and On-Premises – Part Five appeared first on Blog IT.

Consider it as an extended office, with VMs and Azure Functions running outside your premises, as if they were there right next to you! It’s the future.

We’ll be using the same messages, as well the same service-client logic (Via HTTP GET). Instead of using TeamViewer VPN or exposing our service, we’ll use a secure VPN connection to a gateway, that has one VM that’s running the client app associated to it.

We’ll start by doing 10kb, following 100kb and 5MB. Again, this is the most common scenario nowadays!

Test #4 10kb message

Running 10kb of data through Azure VPN Site-to-Site is surely a piece of cake.

It took ~44ms to execute! It’s roughly the same as 263bits through TeamViewer VPN! Using the same 10kb, this test scenario has a reduced execution time of~20ms! Now that’s an improvement. A secure, tight VPN to Azure, site-to-site, with reduced latency! That’s quite a hit in P2P (Peer-to-Peer) VPN connections!

Test #4 100kb message

Well, after seeing a ~20ms drop with a 10kb message, will execution times drop with a message that’s 10 times bigger?

Remember how TeamViewer VPN managed ~100ms on this test? If that’s quick, this is blazing fast! Less ~30ms than P2P VPN solution. Azure Site-to-Site connection is proving to be better than TeamViewer, and only ~9ms slower than HTTP without VPN. Let’s go for 5MB.

Test #4 5MB message

Let’s go through the ultimate test. Can we saturate the Azure VPN connection with this?

Well, that’s astonishing. For a message this size, execution time it’s greater by ~150ms only! Guess that’s the price to pay for a secure tunnel. Direct HTTP execution times are smaller, but considering risk over latency, this is a great and optimal candidate.

Overall test discussion

Well, this did prove me wrong. Initially, I had the idea that TeamViewers’ P2P VPN connection was born to be faster, but it’s not! Azure Site-to-Site is faster, safer, scalable and available to multiple devices, both on Azure and on-premises. Personally, I think this solution is optimal for enterprise integration, as is your business logic needs. For a fast and secure connection to Cloud computing, this is an excellent candidate. It has 99.9% uptime, which is great for 24/7 intensive data crunching or message exchanging.

Proceed to test #5 here!

The post Latency test between Azure and On-Premises – Part Four appeared first on Blog IT.

We’ll be exposing the REST Service (on-premises), and connecting the client application via HTTP (Azure), transmitting the same messages as previous tests.

Starting at 10kb, then 100kb and 5Mb. 10kb, only a fifth (1/5) of an average HTML file. For instance, Google main page size is 392.8 kB in total.

Exposed services. The hackers’ paradise and snoopers’ ocean. A security risk for sure. VPN protects you from all that. It’s a secure tunnel to anywhere.

Test #3 10kb message

After changing port forwarding configurations in our on-prem router, we’re able to expose our REST web service, listening on port 65443 (a random port was chosen). This will be for testing purposes only and will be removed immediately after all testing’s done (for security reasons).

Results are in! It took almost the same time as before (with TeamViewer VPN)! This is amazing, because the VPN we used added no delay whatsoever, at least for this message size! Execution times peaked at ~55ms.

Test #3 100kb message

Now for 100kb of text. Will HTTP be faster than HTTP over VPN?

WOW! Less ~40ms each! TeamViewer VPN is losing ground now! This took ~60ms each for 100kb of data. This is almost half the time that VPN took! How about 5MB of data?

Test #3 5MB message

The ultimate 5MB of text over HTTP. No explaining needed here… Image speaks by itself.

Wait, didn’t TeamViewer VPN take ~1600ms each to execute? This is very surprising, as we start to notice serious delay due to VPN! ~1.2 seconds each is what HTTP takes to execute a request and a 5MB response. If you do the math, for each 10 messages, you save ~4 seconds! That’s a lot!

 Overall test discussion

Well this is a no brainer. TeamViewer VPN didn’t stand a chance here. For 10kb of data, the results are nearly the same. Neither VPN or HTTP (no VPN) struggled with 10kb, but 100kb and 5MB came with a lot of differences. No VPN proved to be faster in larger messages, but VPN provides a safer, encrypted transmission. I call this your decision: Speed over Security. Exposed services are a serious risk, but VPN is a bit slower. In execution time, HTTP without VPN is clearly a winner here.

 Test#4 on the next post!

The post Latency test between Azure and On-Premises – Part Three appeared first on Blog IT.

The machine with the service is running via Ethernet cable, while the client machine is running via Wi-Fi. This is the most common connection scenario nowadays.

We’ll do 10kb test for initial values and escalate to 100kb and 5 MB. These messages are the same as the previous test scenario (test #1 TeamViewer VPN).

Let’s start!

Test #2 10kb message

With a 10kb message, it took ~6ms to run, for each message. Even with peaks of -10ms, it’s much faster than previous scenario with the same message. This dues to proximity and LAN connection advantages. It’s a short way between them. No need to route packets for miles. Bandwidth is a crucial factor here. To exceed a 1gbps LAN connection, you need a large file travelling through, and that’s not the case here.

In case you’re wondering, we’ve added a Reset index button and batch execution. Why?

New test functionalities for real-world applications

This is the main reason. Batch send and receive messages, calculating median execution times, and getting more real-world results. The reset index button resets the OK button count, to control the number of requests made. It isn’t rocket science. Let’s move on to 100kb.

Test #2 100kb message

Now for a 100kb message. This one took, in average and for each message, 17ms to execute. Peaked ~25ms.

The same message traveled way faster than before, and response times fell. 10 times the size, increasing ~10ms on execution time. Absolutely not bad at all!

Test #2 5MB message

This is the ultimate test. The big data travelling. The worst-case scenario. Whatever you want to call it, it’s the more intensive in terms of bandwidth.

What!? 10 messages, with 5mb, in only ~563ms each? What? That’s much faster than Azure!

Why you ask?

This happens a lot. Local Area Networks (LAN) are usually faster. The connection to the outside world is flooded with data and millions of routers in between. No wonder it takes longer. Which would take longer? Copying a 1GB file from your collegues computer, or downloading the same file from the Internet? Yep, your collegues computer. LAN connection is way faster (via Ethernet, Wi-Fi may not apply, depending on the hardware you have available).

Final overview of this scenario

Well, here we are. At this point, you must be thinking: “Oh, why the hell should I migrate my solution to Azure?”

Let me explain:

1 – Dust!

Your worst enemy inside 24/7 powered on servers. If you are not carefull, it may overheat and damage some components, and all your data or business may stop! You have to do maintenance frequently, or hire someone to do it for you!

2 – Hardware!

Your main hardware concerns. RAID (Redundant Array of Inexpensive Drives) is used worldwide for data mirroring and data safety. This has a high failure rate (depending on your configuration on the array); therefore, you can lose data for good. Resuming, you have Hard Disk Drives, Raid controllers, memory chips, motherboards, NICs, Power supplies… Everything is critical inside a server! You don’t want to be this guy when something fails.

3 – Infrastructure

Cost. It’s written all over it. Power hungry servers are heat sources, so you must have air conditioners to cool them down. The usual monthly cost of a medium sized server room is 1400$, without indirect costs! Everything in this room needs maintenance and, again, can break down. This generates downtime and can be very harmful for your business. You must have people who oversee this room (an employee or an IT company for instance).

Despite these disadvantages, this is the fastest way of exchanging data, the fastest way of sending messages. But… but what?

But it’s not scalable.

Scalability. If your business services suddenly need more CPU processing power, or more RAM, your server might be uncappable of handling it! Physical hardware limitations exist. In Azure, with few clicks, you have all the performance boost you need, with little to no downtime at all!

Replication. Server replication is a clever way of avoiding downtimes. With bigger costs for on-premises, cloud manages this for you out-of-the-box, and it’s cheaper!

“Day-to-day usage of on-premises server rooms is a thing of the past!”

Read on to the next part, Via HTTP GET (without VPN)!

The post Latency test between Azure and On-Premises – Part Two appeared first on Blog IT.