Windows 10 End of Life: What Are Your Upgrade Options?

2025-05-06T00:00:00+00:00

As technology evolves, so do operating systems. Microsoft has announced the end of support for Windows 10, meaning that after October 14, 2025, your device will no longer receive critical security updates. This blog post will discuss what this means for you and your upgrade options to Windows 11.

You can search for all Microsoft software lifecycles on the Microsoft Lifecycle Policy page.

Support will end on October 14, 2025, for these editions of Windows 10:

Windows 10 Enterprise & Education
Windows 10 Home & Pro
Windows 10 IoT Enterprise
Windows 10 Enterprise LTSB 2015
Windows 10 Team (Surface Hub)

You can see a list of all Microsoft products whose support will end in 2025 on Microsoft’s website.

What Does End of Life Mean?

End of life (EOL) for an operating system means that the software vendor will no longer provide updates, security patches, or technical support. While your computer will still function, it will be more vulnerable to security threats. Continuing to use an unsupported operating system puts your data at risk.

Why Upgrade to Windows 11?

Windows 11 is the latest version of Microsoft’s operating system. It offers several benefits, including:

Enhanced Security: Windows 11 includes the latest security features to protect your data and privacy. Regular security updates are the biggest reason to upgrade.
Modern Interface: A refreshed design intended to offer a more user-friendly experience.
Improved Performance: Optimized for better speed and efficiency.
New Features: Access to innovative tools and functionalities.

Options for Upgrading to Windows 11

You have a few options when it comes to upgrading from Windows 10 to Windows 11.

Check System Compatibility

First, determine if your current computer meets the minimum system requirements for Windows 11. You can use Microsoft’s PC Health Check app to see if your device is compatible. You can download it directly at https://aka.ms/GetPCHealthCheckApp.

1. Upgrade Your Existing Device

If your computer is compatible, you can upgrade to Windows 11 directly. This process involves downloading and installing the new operating system. Ensure you have backed up your important files before starting the upgrade.

You can download the OS and read more about the upgrade process here.

2. Purchase a New Device

If your current computer does not meet the system requirements, or if you prefer a new device, consider purchasing a new computer with Windows 11 pre-installed. This ensures you have the latest hardware and software.

3. Bypass the Hardware Checks

When a computer is relatively new you can use known registry hacks to bypass the hardware in the compatibility checks. I have done this many times. Sometimes it is worth the savings and hassle of migrating to a new PC and sometimes it is not.

Microsoft has quietly removed information in its support documentation regarding installing Windows 11 via a (not recommended) workaround that allowed the OS to be hosted on a PC that doesn’t meet the hardware requirements.

If you are interested in bypassing the requirement checks, you can read more about it here.

Considerations When Upgrading

Before making a decision, consider the following:

Cost: Upgrading your existing computer may be more cost-effective than buying a new one, but consider the long-term benefits of a new device.
Data Backup: Always back up your data before any major system changes. If you have a Microsoft Live ID, just make sure your actual data is in our OneDrive Cloud Storage and create a backup of folders like Desktop, Documents, Music, Pictures, Videos, and Downloads. Once you log in to the new computer with your Live ID, all your data and settings should download automatically.
Software Compatibility: Ensure your essential applications are compatible with Windows 11, especially business applications like QuickBooks and others, which could be costly to upgrade but necessary.

Conclusion

The end of life for Windows 10 means it’s time to consider upgrading to Windows 11. Whether you upgrade your existing device or purchase a new one, staying up to date with the latest operating system is crucial for security and performance. Evaluate your options, consider your needs, and make the choice that best suits you.

SSH Key Auth using KeeAgent with Git Bash and Windows CLI OpenSSH

2022-08-08T00:00:00+00:00

In a previous blog post we showed how to configure KeePass and KeeAgent on Windows to provide SSH key agent forwarding with confirmation while using PuTTY and other PuTTY agent compatible programs. In this post we’ll expand on that by showing how to use the same key agent to provide SSH key auth when using Git Bash and the Windows command line OpenSSH.

Git Bash support

Open KeePass, click on Tools → Options, select the KeeAgent tab.

Create C:\Temp if it does not exist.

Check the two boxes in the Cygwin/MSYS Integration section.

Directly after each box, fill in the path: C:\Temp\cygwin-ssh.socket for the Cygwin compatible socket file, and C:\Temp\msys-ssh.socket for the msysGit compatible socket file.

Click OK.

Open Git Bash.

Create the file ~/.bash_profile with the contents:

test -f ~/.profile && . ~/.profile
test -f ~/.bashrc && . ~/.bashrc

Create the file ~/.bashrc with the contents:

export SSH_AUTH_SOCK="C:\Temp\cygwin-ssh.socket"

Close and reopen Git Bash.

You should now be able to SSH with Git Bash using your loaded SSH key and a dialog box should appear to approve the use of the key.

Windows command line OpenSSH support

Open KeePass, click on Tools → Options, select the KeeAgent tab.

Scroll down and click on the box next to “Enable agent for Windows OpenSSH (experimental).”

Click OK.

Open a Windows Command Prompt.

You should now be able to SSH with Windows CLI using your loaded SSH key and a dialog box should appear to approve the use of the key.

Windows SSH key agent forwarding confirmation

2022-07-26T00:00:00+00:00

At End Point we use SSH keys extensively, primarily for authentication with servers for remote shell access as well as with Git services including GitHub, GitLab, and Bitbucket. Most of the time the servers we are attempting to reach are blocked from direct access and require that we go through an intermediate “jump server”.

Because of this need to jump from server to server we utilize SSH key forwarding that allows us to use the private key stored on our local system to authenticate with each of the servers in the chain. When we reach our destination server we can use the same private key to authenticate with the Git hosting service and perform git commands without having to enter a password.

One of the best practices when using SSH key forwarding is to use an option called key confirmation. When key confirmation is turned on, each time a request is made to use the private key that is loaded in the SSH agent a prompt will appear on your local machine to approve the use of the key. This reduces the ability for an attacker to use your private key without approval.

For the longest time SSH key confirmation was not available on Windows. One of the most popular SSH clients on Windows is PuTTY and its agent (pageant) does not support the option. Many other SSH key compatible Windows applications use PuTTY’s agent for SSH key caching and as a result these applications also lack the ability for key confirmation.

KeePass and KeeAgent

To use key confirmation on Windows we need to utilize two programs, KeePass and KeeAgent. KeePass is an open source password manager and KeeAgent is a plugin for KeePass that provides a PuTTY-compatible SSH key agent. It also appears that KeeAgent has support for integration with the Windows shell, Cygwin/MSYS, and Git Bash.

The instructions below will assume that you already have a SSH key in PuTTY that you’d like to use with key confirmation and that you have previously used PuTTY with key forwarding.

You should start by installing KeePass. Then install KeeAgent.

Once both are installed create a new KeePass database, or use your existing database if you are already a KeePass user.

Add a new entry to the database and name it SSH key. Enter your SSH key password into the Password and Repeat fields.

Then click on the KeeAgent tab and check ‘Allow KeeAgent to use this entry’.

In the Private Key section select External File and point it at your PuTTY private key. If you have entered the correct password on the first tab you should see your key comment and fingerprint listed. Then press OK.

Verify that confirmation is enabled by clicking on Tools -> Options and selecting the KeeAgent tab.

Press OK.

Then go to File -> Save. Close KeePass and re-open it. You’ll be asked to enter your KeePass password and then you can verify that the agent is loaded with your key by clicking Tools -> KeeAgent.

Now when we use PuTTY or another PuTTY agent-compatible program we’ll be presented with a confirmation dialog. Clicking Yes will allow the key to be used.

Notice that the default selected option is No. This is different than the standard openssh-askpass on Linux, which defaults to Yes. If you’re typing along in a fury and the confirmation window pops up and you hit Enter or space, it will decline the use of your SSH key, rather than accepting it.

If you have enabled SSH key forwarding in the PuTTY options for the connection you’ll be using you can then SSH to other servers using the same key and each time you do so the confirmation will be presented to you.

If you close KeePass the key agent will be closed and unavailable for future connections. Re-opening KeePass will allow the key to be used again.

If you use Windows and SSH agent forwarding but have never tried agent confirmation to protect against malicious use of your secret key, give KeePass and KeeAgent a try!

.NET Conf 2021 is coming!

2021-10-27T00:00:00+00:00

It’s that time of the year again! It has been almost one year since .NET 5 was launched at .NET Conf 2020, unifying .NET Framework and .NET Core into a single open-source and cross-platform framework. With .NET 6 around the corner, it’s time to prepare for the new edition, .NET Conf 2021, starting on November 9th.

This edition will be the 11th online conference, and the Agenda will mainly focus on the .NET 6 launch and the new C# 10, along with some coding challenges and community sessions. The event is organized by both the .NET community and Microsoft. The main changes that will likely be discussed at the conference, based on what we’ve seen through the previews, might include:

Mobile development

We will see several changes to how web mobile app development works under .NET 6. With a smaller, optimized, and optional SDK for mobile based on Xamarin, now called Multi-platform App UI or MAUI, developing an app that targets multiple mobile platforms should be simpler than ever.

Hot reload (after some struggling)

The Hot Reload feature, which will allow us to make and apply changes to the code at execution time, will be finally available in .NET 6. There was some noise about it in the past days since Microsoft made a decision to lock it to Visual Studio 2022, which is a Windows-limited mostly-paid product. But after the open source community made it clear they were angry about it, Microsoft reversed the change and the feature will be available for all platforms.

Blazor 6

The new version of Blazor will also have improvements. One of the main features is the implementation of ahead-of-time compilation, that allows generating WebAssembly code during the publishing process. That way, the application performance is increased, since it can run natively instead of needing a .NET IL interpreter.

LTS (Long Term Support)

.NET 6 is a Long Term Support version, which means that it will have support for at least 3 years after its release. The current version, .NET 5, is a General Availability (GA) version, which means its support will likely end six months after the next release is available.

Several improvements were introduced to different aspects of the framework, including AOT compilation or the Minimal API Framework. There are also improvements to the build speed as we can see in the chart below. A complete list of breaking changes can be seen here.

Bonus: Although not part of the event itself, the new version of Visual Studio will also be available from November 8th, and it will be launched on an online event that Microsoft is preparing with several presentations from the development team.

As we did last year, the .NET team at End Point Dev will be listening to the talks and presentations from the conference, and trying out the new features that will be publicly available on November 9th. Exciting days ahead! We hope to see you there.

Automating Windows Service Installation

2021-04-23T00:00:00+00:00

Photo by Science in HD on Unsplash

For me, setting up a service started as a clean one-liner that used InstallUtil.exe, but as time went on, I accumulated additional steps. Adding external files & folders, setting a custom Service Logon Account, and even an SSL cert had to be configured first before the service could be used. An entire checklist was needed just to make sure the service would start successfully. That’s when I realized a proper installation method was needed here. This article will go over how to make a dedicated .msi installer for a Windows Service that can do all these things and more.

Creating an installer can be tricky, because not all the available features are easy to find. In fact, the setup project itself is not included by default in Visual Studio; you need to install an extension in order to create one. But once the installer is created, we can use it to do things like:

Configure the installer to copy the build output of a project to the C:\Program Files (x86) folder, as well as add custom files & folders to the installation
Add custom CLI flags to the installer to specify the Service Logon Account at install time
Add an installer class to the service and use the installation lifecycle hooks to write custom code that gets run at any stage of the installation.

A Note On Compatibility

For .NET Core and .NET 5.0 projects, you won’t be able to add an installer class. To use either .NET Core or .NET 5.0 to make a service instead, you’d need to make a different kind of project called a Worker Service. A Worker Service differs from a traditional Windows Service in that it’s more like a console application that spawns off a worker process on a new thread. It can be configured to run as a Windows service, but doesn’t have to be. So instead of using an installer, for a Worker Service you’d publish the project to an output directory and then use the SC.exe utility to add it as a Windows service:

dotnet publish -o C:\<PUBLISH_PATH>
SC CREATE <WORKER_NAME> C:\<PUBLISH_PATH>

Creating a Windows Setup Project

In order to create a .msi installer in Visual Studio 2019, you’ll need to install the Microsoft Visual Studio Installer Projects extension. While it’s not provided with a default installation of Visual Studio 2019, it’s an official Microsoft extension. Once you’ve installed it, you’ll be able to create any of the following projects:

To create an installer, you can create a new Setup Project. The build output from this project will be your .msi installer. The setup project has a few different views, which you can use to configure what the installer needs to accomplish. These views can be accessed by right-clicking on the project in the Solution Explorer and expanding View from the context menu:

Configuring the Installation File System

To configure what files need to be installed, you can use the File System view, which provides a UI with some folders added to it:

Here, clicking on any folder on the left shows its contents over on the right. It also populates the Properties Window with the information about the folder:

In the above example, we can see that the Application Folder is being output to a folder inside C:\Program Files (x86). You can add any folders you want to the file system by right-clicking on the file system to open the Special Folders context menu:

Some default folders are shown here for convenience. But let’s say we wanted to make some files get added to the C:\ProgramData folder. To do this, select “Custom Folder” and give it a name. Then, in the Properties Window, set the value of DefaultLocation to the correct path:

From here, you can use the right half of the view to add additional folders within C:\ProgramData\DotNetDemoService based on your needs.

Another thing you’ll likely want to do is put the DLLs from your application into a folder within C:\Program Files (x86). You can easily do this by mapping the primary build output of your project to the Application Folder in the installer’s file system. To do this, right-click on the Application Folder, and add project output:

From there you’ll be prompted to select the project and output type. Select your project, and “Primary Output”:

This will copy over the DLLs for your project and all of its dependencies.

Creating an Installer class

You may be wondering if it’s possible to define custom code to be run during the installation process. It is! For any project targeting .NET Framework 4.8 and under, you can add a class that extends System.Configuration.Install.Installer, and has the [RunInstaller(true)] attribute applied to it. After doing so, you’ll then be able to hook in and override any of the installation lifecycle methods. Taking a look into the definition of the System.Configuration.Install.Installer class reveals the list of overridable lifecycle hook methods you can use to add custom logic to the installation:

public virtual void Commit(IDictionary savedState);
public virtual void Install(IDictionary stateSaver);
public virtual void Rollback(IDictionary savedState);
public virtual void Uninstall(IDictionary savedState);
protected virtual void OnAfterInstall(IDictionary savedState);
protected virtual void OnAfterRollback(IDictionary savedState);
protected virtual void OnAfterUninstall(IDictionary savedState);
protected virtual void OnBeforeInstall(IDictionary savedState);
protected virtual void OnBeforeRollback(IDictionary savedState);
protected virtual void OnBeforeUninstall(IDictionary savedState);
protected virtual void OnCommitted(IDictionary savedState);
protected virtual void OnCommitting(IDictionary savedState);

It also defines event handlers for each of these steps as well:

public event InstallEventHandler BeforeInstall;
public event InstallEventHandler Committing;
public event InstallEventHandler AfterUninstall;
public event InstallEventHandler AfterRollback;
public event InstallEventHandler AfterInstall;
public event InstallEventHandler Committed;
public event InstallEventHandler BeforeRollback;
public event InstallEventHandler BeforeUninstall;

To add an installer class to the Windows Service project, there’s a helper you can use by right clicking on the designer view of the service and selecting “Add Installer” from the context menu:

This will add a new file called ProjectInstaller.cs to your project, which has its own designer view. The designer view has a corresponding ProjectInstaller.Designer.cs file that amends the ProjectInstaller class with the code generated by the designer. You’ll notice that this designer view already defines two objects, serviceInstaller1 and serviceProcessInstaller1.

These are special installer classes that will handle all the default installation tasks for your service. serviceInstaller1 is of type ServiceInstaller and handles defining the service name and if it should auto start when the machine boots up. serviceProcessInstaller1 is of type ServiceProcessInstaller and handles setting up the Service Logon Account, which the service will run with once installed. Both of these are already set up and invoked by the designer generated code in ProjectInstaller.Designer.cs.

Since both of these special service installers extend System.Configuration.Install.Installer, you can add custom code to occur at any point of the installation on these as well. The designer view again provides a GUI helper to add this in. Double-clicking on serviceInstaller1 will automatically add a new method to ProjectInstaller:

private void serviceInstaller1_AfterInstall(object sender, InstallEventArgs e) { }

It will also put some code into ProjectInstaller.Designer.cs which adds this method to the AfterInstall event of serviceInstaller1.

Adding Installer CLI Options

It’s also possible to add custom properties that you can pass to the installer as command line arguments. These can be done by defining Custom Actions on the primary build output of your project. To do this, go to the Custom Actions view of the installer project, right click on “Install” and select “Add Custom Action” from the context menu:

This will open up a dialog that prompts you to select a file in the installer’s file system to define a custom action for. In this case, we want to define a custom action on the primary build output. This way, the custom CLI options we are about to define will be passed to the project’s installer class.

After you click “OK”, the primary build output will show up in the Custom Actions view. When you click on it, you’ll notice that the properties window has a property called CustomActionData. In short, you can use it to define custom CLI arguments like this:

CustomActionData has its own syntax, so let’s dive deeper into what this actually does. We’re mapping the value of USERNAME and PASSWORD from the installer’s Properties Collection to the InstallContext of the installer class of your project under the Username and Password keys, respectively. The square brackets denote that the value is to be taken from the Properties Collection, and the quotes allow the value of the property to contain spaces. The forward slash denotes that we are adding a new key to the context. Any command line arguments passed to the installer are added to the Properties Collection by default.

Using Custom CLI Options in the Installer Class

Now that we have defined our custom action with the CLI arguments, we can go over to the project’s Installer class and access them via the Context property. In this example, we’re using the custom properties to define the Logon account for the service, which needs to be set right before the installation happens. We can use the Install(IDictionary stateSaver) lifecycle hook method for this purpose:

public override void Install(IDictionary stateSaver)
{
    // If no username or password is specified, fall back to installing the service to run as the SYSTEM account
    if (
        string.IsNullOrEmpty(this.Context.Parameters["Username"])
        || string.IsNullOrEmpty(this.Context.Parameters["Password"])
    ) {
        this.serviceProcessInstaller1.Account = System.ServiceProcess.ServiceAccount.LocalSystem;
    }

    // Otherwise, configure the service to run under the specified account.
    else
    {
        this.serviceProcessInstaller1.Username = this.Context.Parameters["Username"];
        this.serviceProcessInstaller1.Password = this.Context.Parameters["Password"];
    }

    // Run the base class install after the service has been configured.
    base.Install(stateSaver);
}

Conditionally Installing Files

It’s also possible to make the installer conditionally install files based on a value from the Properties Collection. One example of how this can be useful would be swapping in the production or development configuration file based on the value of a command line argument. We don’t need to write any additional code to do this, we just have to add a value for the Condition property in the Properties Window for the file:

The above condition will make the file settings.production.config be installed only if the DEBUG command line argument is not defined or is set to “false”. Like the custom actions, this property is also sourced from the Properties Collection.

Conclusion

And that’s it! I found that having a dedicated .msi installer was handy for making the setup of my Windows Service completely hands-free. While some of the features you need might seem buried within context menus, the flexibility of having the installer handle the service setup is well worth the effort.

Have any questions? Feel free to leave a comment!

.NET 5 will be released at .NET Conf 2020

2020-11-04T00:00:00+00:00

.NET — A unified platform by Microsoft

Last year, at .NET Conf 2019, Microsoft announced that the new .NET 5 will have a base class library that will allow creation of any type of application for any platform — Windows, Linux, Android, iOS, and IoT. And that’s finally about to happen: .NET 5 will be launched at .NET Conf 2020, starting November 10th!

According to Microsoft, .NET 5 will take the best of .NET Core, .NET Framework, Xamarin, and Mono and merge them into one framework, offering the same experience for all developers, regardless of the type of application or platform targeted. It will also include two different compiler models: just-in-time (JIT, prepared for client-server and desktop apps) and static compilation with ahead-of-time (AOT, optimized to decrease startup times, ideal for mobile and IoT devices).

Some of the key features will be:

Windows Desktop development (WPF/Windows Forms/UWP)

This was already a part of the current .NET Core 3 release, and it will stay while getting some updates like a Chromium-based WebView control, improvements to the visual designer, and customizable task dialogs. It will also include all the latest features of C# 8.

Full-stack web development (C#/Blazor)

This feature is also present on the current .NET Core 3 version, and will be updated for this release. With Blazor, we can write full-stack web applications only using C#, removing the need to use a separate language for the frontend. While it’s still a discussed feature, the advantage of using it will depend on the type of web application we’re working on. But it’s there and it will be fully supported on .NET 5.

C# 8

This version tries to reduce the well-known (by all of us!) null reference exceptions as a source of program failures by introducing a nullability modifier for nullable reference types. Other main improvements include asynchronous streams, default interface methods and pattern matching enhancements. A full reference of all the new features can be found here.

Updates to Entity Framework

EF will now integrate with the new C# 8, allowing us to consume the query results as asynchronous streams, and automatically mapping the new non-nullable types to non-nullable fields on the database, among other improvements.

Updates to ML.NET

.NET 5 will also include the latest version of ML.NET, a free, open-source, and cross-platform machine learning framework for .NET, with some key features like the DatabaseLoader class, which allows loading the data from any relational database with a connection string, and improvements to the object detection capabilities.

And more

And of course, everything that was already on .NET Core 3 will be a part of .NET 5: multi-platform mobile development, Azure Cloud access tools, gaming development with Unity and traditional ASP.NET development, etc.

The long-term support (LTS) version of .NET Core is aimed to be launched in 2021, and it will be called .NET 6, hopefully recollecting everything that might be improved based on the feedback for this General Availability (GA) release.

The .NET development team at End Point will be attending the main talks that will happen at the .NET Conf 2020. On Day 1, the focus will be put on this new release, so stay tuned for more to come!

Job opening: Windows Systems Integrator

2020-07-23T00:00:00+00:00

We are looking for a Windows systems integrator in the New York City metropolitan region to work with us.

We are an Internet technology consulting company based in NYC, with 50 employees serving many clients ranging from small family businesses to large corporations. The company turns 25 years old this year!

This is a consulting position, so excellent verbal and written communication, troubleshooting, and time management skills are required, along with a good sense for when to quickly escalate issues to resolve them efficiently as needed.

Skills and tools

You will need to have extensive experience in the Microsoft Windows ecosystem: the MS Windows OS, Windows networking, Active Directory management via Group Policies, MS Exchange Server, MS SQL Server, etc.

The greater knowledge of and larger base of experience you have with these, the better:

Remote management & monitoring (RMM) systems, such as ConnectWise Manage and Automate
Mobile devices and mobile device management (MDM) systems, such as SOTI MobiControl, AirWatch, and MaaS360
VMware’s vSphere or Microsoft Hyper-V hypervisors
Managing firewall security policies, switches, and wireless access points (WAPs)
Storage management, connecting via iSCSI and SMB3 SAN & NAS devices
Managing cloud services and migrating to and from such services as Office 365, Azure, Amazon Web Services, and Google Cloud Platform
An understanding of disk imaging, backup, and recovery strategies
Scripting or development experience, such as PowerShell, .NET/C#, etc.

Tell us about your other skills and strengths. We’ll be interested to hear about them.

Location

This position requires (at least once COVID-19 subsides) some work in our Manhattan office along with some on-site work at customer locations in the NYC metro region. Working remotely is also possible from time to time.

Benefits

Flexible, sane work hours
Annual bonus opportunity
Paid holidays and vacation
Health insurance subsidy
401(k) retirement savings plan

How to contact us

~~Please email us an introduction to jobs@endpointdev.com to apply.~~ (This job has been filled.) Include your location, a resume/CV, your LinkedIn URL (if you have one), and whatever else helps us get to know you.

We look forward to hearing from you! Direct work seekers only, please—this role is not for agencies or subcontractors.

Equal opportunity employer

We are an equal opportunity employer and value diversity at our company. We do not discriminate on the basis of sex/gender, race, religion, color, national origin, sexual orientation, age, marital status, veteran status, or disability status.

Linux Development in Windows 10 with Docker and WSL 2

2020-06-18T00:00:00+00:00

I’m first and foremost a Windows guy. But for a few years now, moving away from working mostly with .NET and into a plethora of open source technologies has given me the opportunity to change platforms and run a Linux-based system as my daily driver. Ubuntu, which I honestly love for work, has been serving me well by supporting my development workflow with languages like PHP, JavaScript and Ruby. And with the help of the excellent Visual Studio Code editor, I’ve never looked back. There’s always been an inclination in the back of my mind though, to take some time and give Windows another shot.

With the latest improvements coming to the Windows Subsystem for Linux with its second version, the new and exciting Windows Terminal, and Docker support for running containers inside WSL2, I think the time is now.

In this post, we’ll walk through the steps I took to set up a PHP development environment in Windows, running in a Ubuntu Docker container running on WSL 2, and VS Code. Let’s go.

Note: You have to be on the latest version of Windows 10 Pro (Version 2004) in order to install WSL 2 by the usual methods. If not, you’d need to be part of the Windows Insider Program to have access to the software.

What’s new with WSL 2

This is best explained by the official documentation. However, being a WSL 1 veteran, I’ll mention a few improvements made which have sparked my interest in trying it again.

1. It’s faster and more compatible

WSL 2 introduces a complete architectural overhaul. Now, Windows ships with a full Linux Kernel which WSL 2 distributions run on. This results in greatly improved file system performance and much better compatibility with Linux programs. It’s no longer running a Linux look-alike, but actual Linux.

2. It’s better integrated with Windows

This is a small one: we can now use the Windows explorer to browse files within a WSL distribution. This is not a WSL 2 exclusive feature, it has been there for a while now. I think it’s worth mentioning though, because it truly is a great convenience and a far cry from WSL’s first release, where Microsoft specifically advised against manipulating WSL distribution file systems from Windows. If nothing else, this makes WSL feel like a first class citizen in the Windows ecosystem and shows that Microsoft actually cares about making it a good experience.

3. It can run Docker

I’ve recently been learning more and more about Docker and it’s quickly becoming my preferred way of setting up development environments. Due to its lightweightness, ease of use, repeatability, and VM-like compartmentalization, I find it really convenient to develop against a purpose-built Docker container, rather than directly in my local machine. And with VS Code’s Remote development extension, the whole thing is very easy to set up. Docker for Windows now supports running containers within WSL, so I’m eager to try that out and see how it all works.

4. A newer version means several bugfixes

Performance notwithstanding, WSL’s first release was pretty stable. I did, however, encounter some weird bugs and gotchas when working with the likes of SSH and Ruby during certain tasks. It was nothing major, as workarounds were readily available. I’ve already discussed some of them here, so I won’t bother mentioning them here again. But thanks to the fact that the technology has matured since last time I saw it, and considering the architectural direction it is going in, I’m excited to not have to deal with any number of quirks.

The development environment

Ok, now with some of the motivation out of the way, let’s try and build a quick PHP Hello World app running in a Docker container inside WSL 2, make sure we can edit and debug it with VS Code, and access it in a browser from Windows.

Step 1: Install WSL 2 and Ubuntu

Step 1 is obviously to install WSL and a Linux distribution that we like. Microsoft’s own documentation offers an excellent guide on how to do just that. But in summary, we need to:

Enable the “Windows Subsystem for Linux” and “Virtual Machine Platform” features by running these on an elevated PowerShell:

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Restart your machine.
Set WSL 2 as the default version with: wsl --set-default-version 2, also from PowerShell.
Install your desired distribution from the Microsoft Store. I chose Ubuntu 20.04 LTS.
After installing, open the “Ubuntu 20.04 LTS” app from the Start menu and it should come up with a command line console. Wait for it to finish installing. It should prompt for a username and password along the way. Choose something you won’t forget.

Optionally, you can install the Windows Terminal app to get a better command line experience. Windows Terminal can be used to interact with PowerShell and the classic CMD, as well as with our WSL distributions.

Step 2: Install Docker

Installing Docker is very straightforward. Just download the installer for Docker Desktop for Windows, execute it, and follow the wizard’s steps. Make sure that during setup the “Use the WSL 2 based engine” option is selected. In most cases, the installer will detect WSL 2 and automatically have the option selected.

Follow the official instructions for more details on the process, but it really is that simple.

Step 3: Install some useful VS Code extensions

Our objective is to create a new development environment inside a Docker container and connect to it directly with VS Code. To do that, we use a few useful extensions:

The Docker extension which allows us to browse and manage images and containers and other types of Docker assets.
The Remote - WSL extension which allows VS Code to connect to a WSL distribution.
The Remote - Containers extension which allows VS Code to connect to a container.

Step 4: Create the development container

The extensions that we installed will allow us to use VS Code to work on code from within our WSL Ubuntu as well as from the container. Specifically, we want to connect VS Code to a container. There are a few ways to do this, but I will describe the one I think is the easiest, most convenient and “automagic” by fully leveraging the tools.

Let’s begin by opening a WSL Ubuntu terminal session, which will show something like this:

Welcome to Ubuntu 20.04 LTS (GNU/Linux 4.19.104-microsoft-standard x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

...

kevin@kevin-thinkpad:/mnt/c/Users/kevin$

The project directory

Let’s change to our home, create a new directory for our new project, and change into it.

$ cd
$ mkdir php-in-docker-demo
$ cd php-in-docker-demo

Because we installed the Remote - WSL extension, we can open up this directory in VS Code with code .. Opening a terminal (Ctrl + `) in this VS Code instance opens WSL console, not Windows.

The Dockerfile

Now let’s create a new file called Dockerfile which will define what our development environment image will look like. For a no-frills PHP environment, mine looks like this:

# The FROM statement says that our image will be based on the official Ubuntu Docker image from Docker Hub: https://hub.docker.com/_/ubuntu
FROM ubuntu

# Install packages, not allowing apt to ask any questions since we can't answer.
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y software-properties-common php php-xdebug composer

# Configure Xdebug so that the VS Code debugger can use it.
RUN echo "xdebug.remote_enable=on" >> /etc/php/7.4/mods-available/xdebug.ini
RUN echo "xdebug.remote_autostart=on" >> /etc/php/7.4/mods-available/xdebug.ini

# The CMD statement tells Docker which command to run when it starts up the container.
# Here, we just call bash
CMD ["bash"]

This script will later be used to create our development container. It will have PHP, Xdebug and Composer. This is all we need for our simple Hello World app. For more complex scenarios, other software like database clients or PHP extensions can be easily installed with additional RUN statements that call upon the apt package manager.

Consider reading through Docker’s official documentation on Dockerfiles to learn more.

The configuration file

Now, to leverage VS Code’s capabilities, let’s add a development container configuration file. In our current location, we need to create a new directory called .devcontainer and, inside that, a new file called devcontainer.json. I put these contents in mine:

{
    // The name used by VS Code to identify this development environment
    "name": "PHP in Docker Demo",

    // Sets the run context to one level up instead of the .devcontainer folder.
    "context": "..",

    // Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
    "dockerFile": "../Dockerfile",

    // Add the IDs of extensions you want installed when the container is created.
    // This is the VS Code PHP Debug extension.
    // It needs to be installed in the container for us to have access to it.
    "extensions": [
        "felixfbecker.php-debug"
    ],

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    // When we run our PHP app, we will use this port.
    "forwardPorts": [5000],
}

A default version of this file can be automatically generated by running the “Remote-Containers: Add Development Container Configuration Files…” command in VS Code’s Command Palette (Ctrl + Shift + P).

The development container

Now that we have all that in place, we can create our image, run our container, and start coding our app. Bring up the VS Code Command Palette with Ctrl + Shift + P and run the “Remote-Containers: Reopen in Container” command. The command will:

Read the Dockerfile and create an image based on that. This is like running docker build -t AUTOGENERATED_IMAGE_ID .
Run a container based on that image with the settings specified in .devcontainer/devcontainer.json. In our case, all it will do is enable the container’s port 5000 to be accessible by the host. This is more or less like running: docker run -d -p 5000:5000 -v ${PWD}:/workspaces/php-in-docker-demo AUTOGENERATED_IMAGE_ID
Open a new VS Code instance connected to the container with the /workspaces/php-in-docker-demo directory open.

It will take a while, but after it’s done, we will have a VS Code instance running directly in the container. Open the VS Code terminal with Ctrl + ` and see for yourself. It will show a prompt looking like this:

root@ec5be7dd0b9b:/workspaces/php-in-docker-demo#

You can for example, run php -v in this terminal, and expect something along these lines:

PHP 7.4.3 (cli) (built: May 26 2020 12:24:22) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
    with Zend OPcache v7.4.3, Copyright (c), by Zend Technologies

This is PHP running, not in Windows, not in our WSL Ubuntu, but in the Docker container.

Hello Windows + WSL 2 + Ubuntu + Docker + PHP + VS Code

Let’s now create our app. Add a new index.php file containing something silly like:

<?php

echo "Hello Windows + WSL 2 + Ubuntu + Docker + PHP + Visual Studio Code!";

Then, in the VS Code console (remember, Ctrl + `), start up an instance of the built in PHP development server wth php -S 0.0.0.0:5000. It’s important that we use port 5000 because that’s the one that we configured our container to use.

Navigate to http://localhost:5000/ in your browser and feel good about a job well done.

Interactive debugging

When configuring our development container, we added Xdebug and the PHP Debug VS Code extension. This means that VS Code can leverage Xdebug to provide an interactive debugging experience for PHP code.

Almost everyting is set up at this point, we just need to do the usual VS Code configuration and add a launch.json file. To do so, in VS Code, press Ctrl + Shift + D to bring up the “Run” panel, click on the “create a launch.json file” link, and in the resulting “Select Environment” menu, select “PHP”.

After that, the “Run” panel will show a green triangular “Start Debugging” button next to a “Listen to XDebug” text. If you haven’t already, start up a dev web server with php -S 0.0.0.0:5000, click on the “Start Debugging” button, put a breakpoint somewhere in your index.php file, and finally open up http://localhost:5000/ in a browser.

We’re interactively debugging PHP code running on a Docker container in WSL from our Windows IDE/editor. Pretty cool, huh?

And that’s all for now. In this article we’ve learned how to set up a Linux development environment using Docker containers and WSL 2, with Windows 10 Pro. This is a nice approach for anybody who’s confortable on Windows and needs access to a Linux environment for development; and have that environment be easy to reproduce.

Resources:

End Point Security Tips: Securing your Infrastructure

2020-02-05T00:00:00+00:00

Photo from comparitech.com

Implement Security Measures to Protect Your Organization & Employees

In this post, I’ll address what I believe are the three important initiatives every organization should implement to protect your organization and employees:

Train employees on security culture.
Implement the best technical tools to aid with organizational security.
Implement recovery tools in case you need to recover from a security breach.

Habits of a Security Culture

Train everyone in your organization on these fundamentals:

The only time you should be requested to reset your password by email is when you initiate it. There are rare exceptions to this rule, such as when accounts are compromised and providers request all users reset their passwords, but those events should be publicly announced. Staff can confirm with security personnel before acting on such requests.
If you are asked to reset your password, it will typically be after you successfully logged into a website and the old one has expired.
If you receive an email and do not know the sender, do not trust the contents or open attachments. Get advice from security personnel if needed.
If you think the email is from your bank, keep in mind that banks do not ask their clients for private information via email.
If you think the social security office emailed you to obtain your personal information, keep in mind that they do not initiate or solicit private information via email.
Companies should not solicit private information unless you initiate first.
Online retailers should not ask for your private information unless you initiate first.

A Security Concern: Going Phishing!

Photo by Epic Top 10 Site

One of the more common ways to steal someone’s private information is through phishing. Phishing is like fishing: you try to catch something. In this case, the ‘fish’ is your data. Someone with malicious intent sends you email to attempt to get you to click on the link, picture, content, etc. within the email. Once you click the link or content within the email, it might take you to a website to enter or reset your password, even ask for your social security number or other personal information. The person with malicious intent would use the information collect to open accounts, purchase items online or resell your personal data. The links within the phishing email might even redirect you to a fake website that mimics a real website to collect your personal data. The goal is to confuse the email recipient into believing that the email message is legit in its attempt to collect personal information from the user.

Phishing Exercises

Photo by Christiaan Colen

One way to help the staff better their understanding of a phishing email is to practice phishing exercises by setting up an experiment to see which users would click on your test phishing email. If the user clicks on the experiment phishing email, the email administrator would notify the compliance officer and he or she would re-train the staff on how to properly differentiate real emails from phishing emails. Phishing exercises make a great activity for the employees to avoid the email scams and exert more caution in the future.

Essential Security Tools

Firewall

A firewall should be a mandatory technology for all consumers or businesses. This is basically your main door. The office or organization’s technology is what the firewall is protecting. When you sit in your office working on the computer, just imagine that you are in a fort surrounded by walls. If someone needs to come in, they must be given permission by a gatekeeper to enter the fort. The firewall is very similar. The firewall allows network traffic to go in and out of the office based on the configuration set by a network engineer. The engineer determines what network traffic comes into the office and goes out.

Companies typically test their firewall with penetration tests and network scans to determine if there are any security concerns after implementing the firewall. The testing of the firewall verifies that good security practices are implemented and the firewall is setup properly and securely.

Some hardware firewall devices to consider include:

Network Assessment & Internal Threat Protection

Why is security vulnerability testing necessary? Many organizations have legacy servers, or desktops/laptops with operating systems that are no longer supported. For example, outdated Microsoft Windows XP and 7 can be compromised by malware while browsing the Internet due to the BlueKeep vulnerability. Systems that are not patched could expose your organization to be infected with malware such as ransomware which would hold your data ransom until you pay to unlock the data.

Security vulnerability testing typically results in a report outlining problematic areas such as outdated operating systems, private data that does not belong on a file server, such as social security or credit card number (personally identifying information, or PII). If PII is needed for the organization to operate, then higher security standards and an encryption system to store the private data is needed. The security vulnerabilities testing could also check if your environment is HIPAA or PCI DSS compliant if those security standards apply to you.

Some security vulnerability testing technology includes:

Enterprise Antivirus Systems

Antivirus software is the last line of defense if malware enters your computer. The antivirus itself would not protect you 100% from being infected by malware or virus but if you have multiple layers of security in place, then the chances are much lower that your organization’s systems would not be compromised. A company called AV-Comparatives assessed some of the popular antivirus software in the market.

The battle with malware is endless. Case in point: The WannaCry malware affected over 200,000 machines across the world and spread quickly. Security researchers quickly realized the malware was spreading like a computer worm, across computers and over the network, using the Windows SMB protocol.

New variants of viruses and malware are developed every day, so the antivirus companies are also daily hard at work developing a way to block and remove malware.

Some antivirus software includes:

Web Filtering Technology

Web filtering technology blocks websites that are malicious or deemed not appropriate to visit from an organization’s network. For example, websites for gambling could be blocked to reduce employee distractions, but also to reduce access to sites popularly infected with malware, reducing the possibility of malware coming into your network.

There are many competitors out there in this competitive market, and some vendors offer free proof-of-concept testing with their product before you make a big investment. Take a look at:

Data Loss Prevention

Employees’ and businesses’ private information is sensitive and should be protected. Businesses, whether audited or not, should always protect their employee private information. 20 years ago paper was used to store private information and locked in a file cabinet, but in 2020 most private information is stored digitally. How do companies keep private information from leaving their office?

Physically you probably can’t stop someone from walking out with private information, but digitally there is technology called digital loss prevention (DLP) that can help keep confidential information from leaving the office. For example, if someone in the office decides to copy private information onto USB storage, or tries to send a social security number or credit card information via email, this can often be prevented. Prepare your business with solutions tailored for regulations involving personal information using DLP software.

Some DLP solutions to consider include:

Email Filtering

Probably one of the easiest and oldest methods to infect or phish someone is via email. There are multiple mechanisms email filtering uses to stop malicious emails: SPF and DKIM, blacklists, etc. On top of these configurable items, email filtering software vendors often release updates throughout the day to block the latest known malware or spam based on heuristics.

Cloud email services such as Microsoft Office 365 are for many businesses superior to on-premise email servers due to having all the bells and whistles to proactively protect your email environment, such as spam & virus filtering, and email archiving for retention purposes. If you need email encryption to protect sensitive emails, this feature is also available.

The distinct advantage of using hosted email service is that the cost is predictable and includes maintenance, so your email administrators do not have to worry about updating the email server software or hardware.

Email filtering technology available includes:

Two Factor Authentication (2FA)

Companies like Duo (owned by Cisco) and Google’s two-factor authentication technology are great tools to implement to improve your overall security. Beyond the usual user name and password, your smartphone or a hardware token are used to authorize the access to a website, an application, or a network. This technology is now well-established and available in most online services, and can be added to your own custom business applications.

Some starting points:

VPN (Virtual Private Network)

Virtual private network technology allows businesses to provide secure access to office systems or applications to employees who travel or work from a remote location. That is important so that data traveling to and from the source, and many details of traffic patterns, are encrypted, so that the data cannot be captured and decrypted. VPN solutions have been around for years and are an important tool to securely and safely protect data in transit.

Password Reset Systems

Why are self-service password reset systems necessary, and are they secure? They eliminate many manual password assignment mistakes, keep passwords private to the user alone, and allow an organization to integrate two-factor authentication to securely reset user passwords, such as Active Directory for Windows, or other single sign-on password. Onboarding is needed for each user, which is done by sending them an email with a link to register.

The password reset system could be an internal system only available to your organization. Another possibility is to access the system via VPN or even through a proxy server in the DMZ to allow password reset from anywhere.

Some password reset systems include:

Recovery Tools

Data and System Backups/Disaster Recovery

Data backup and disaster recovery practice is a critical component for a business to speed up the process of recovery if malware attacks your systems or if a system becomes inoperable.

If you are attacked by ransomware and all the critical systems and desktops are compromised and rendered useless, then the only way to recover is from backups. At that point, the disaster recovery preparation you made will be well worth what you invested into it. If you did not have an adequate backup or disaster recovery plan, your organization or company would have to start from scratch and rebuild all systems and desktops which could take weeks if not months to recover from. The lost wages, and possibly clients, due to unavailable systems and desktop to operate, probably would cost you far more than preparation does. The more options you have, the better the chances that you will get out of your bind and not prolong the situation.

Some backup solutions I have worked with have the flexibility to mix and match to fit your configuration needs:

Acronis Cloud Backup allows you to back up to local storage, the cloud, and off-premise, recover a system using a USB drive, back up Office 365 emails, or backup VMware or Hyper-V environments. It also allows you to recover a single file if needed.

Additional Security Recommendations

SSL/TLS Certificates

What are SSL and TLS? SSL is outdated and replaced by TLS, but people often still use the familiar SSL name. They are an encryption system to keep sensitive information sent across the Internet encrypted so that only the intended recipient can access it.

When an SSL certificate is validated, the transmitted data is not only unreadable by anyone except for the intended server, but you are relatively well assured you are communicating with the organization you expected and not with a malicious intermediary. Read more details in SSL Shopper’s Why SSL? article.

SSL certificates were historically used primarily for higher-security web servers, but now are commonly used on almost all web servers. They are also used for other remote server access, B2B server-to-server communication, VPN access, email systems, etc.

Recent Destructive Incidents

These incidents from just a few weeks in fall 2019 show that we have a long way to go in protecting our technology usage:

Speak With Us!

Keeping up with security can be a full-time job. If you need professional consulting on security tools and implementing them, contact our team today.

Keeping our Windows Server clean

2019-09-27T00:00:00+00:00

Photo by Shawn O’Neil, used under CC BY 2.0, cropped from original

Introduction

I have been running websites and web applications under Windows Server for years, for both work and personal purposes. Most of them were small websites with a few daily visitors, but one particular case (a weather website I originally created as a hobby) grew over time to around one million page views per month.

The website is mostly ASP.NET, with some services and components written in PHP and Python, and uses MySQL for persistence (as well as a bunch of XML/PNG files to cache weather forecasts and weather imagery). As months passed by, I’ve discovered that the default IIS and Windows log files will grow drastically so, while checking its content periodically to detect issues and vulnerabilities, we need to take action to preserve free disk space and server performance.

Internet Information Services log files

In our IIS public folder (by default C:\inetpub) we will have a path logs\LogFiles. Inside that folder, the IIS service will create a set of folders, one per HTTP/FTP service that is running under our instance. How fast it will grow depends on many things, mainly traffic, but also website visibility and bad requests. But it will start to sooner or later consume our free disk space.

To prevent this, we can create a batch file that can be run on a daily basis from a scheduled task.

CleanIISLogs.bat

forfiles /D -10 /P "C:\inetpub\logs\LogFiles" /S /C "cmd /c del /f /q @path"

This script traverses through all files on the folder passed by parameter that are more than 10 days old, and for each file, it executes the del command in quiet mode. This script will search for all files within the folder and all subfolders that are more than 10 days old and delete them. After running the task, we should confirm that the used space was reduced:

HTTP Error logs

There is another location where different operating system logs are stored: C:\Windows\System32\LogFiles. And when we navigate there, we will find an HTTPERR folder which will also start consuming free space as our websites are visited. The log files in that folder will save information regarding HTTP errors from any API/Service running on our IIS instance.

So depending on the web traffic our applications have, it will grow faster or slower. But in any case, I recommend creating a batch file to clean old log files using the del command, and to run that file on a daily basis by configuring a scheduled task.

CleanHTTPERRLogs.bat

forfiles /D -10 /P "C:\Windows\System32\LogFiles\HTTPERR" /C "cmd /c del /f /q @path"

This script, just as the previous one, will search for all files more than 10 days old and delete them. We don’t need to search for subfolders in this case because of Windows storing all HTTPERR logs at the same level. After running the task, we can open the folder properties and check that the used space will be the roughly the same over the days:

(I know, still 1 GB after cleanup, gotta do something about those bad requests!)

Compressing files

If we need to comply with strict security/auditing policies, and if we don’t have a backup device with enough capacity, deleting old files might not be an option. If that’s the case, we can compress the files to save space on disk.

So an alternative would be to create a script to compress the files instead of deleting them using the compact command. This is an example of a batch file that will compress all files in the IIS LogFiles folder that are more than 10 days old.

CompressIISLogs.bat

forfiles /D -10 /P "C:\inetpub\logs\LogFiles" /S /C "cmd /c compact @path"

And of course, we can create more scripts for other locations, like the C:\Windows\Temp folder for example. I mentioned earlier that my website creates a lot of XML and PNG files: I have another script whose mission is keeping those folders at bay, deleting forecast files that haven’t been used for more than one day (the local forecast will be outdated and would need to refresh it from the external web service anyway).

More resources from Microsoft

How to set up your Ruby on Rails development environment in Windows 10 Pro with Visual Studio Code and Windows Subsystem for Linux

2019-04-04T00:00:00+00:00

There’s one truth that I quickly discovered as I went into my first real foray into Ruby and Rails development: Working with Rails in Windows sucks.

In my experience, there are two main roadblocks when trying to do this. First: RubyInstaller, the most mainstream method for getting Ruby on Windows, is not available for every version of the interpreter. Second: I’ve run into issues while compiling native extensions for certain gems. One of these gems is, surprisingly, sqlite3, a gem that’s needed to even complete the official Getting Started tutorial over on guides.rubyonrails.org.

In this post, I’m going to be talking about how to avoid these pitfalls by setting up your development environment using the Windows Subsystem for Linux on Windows 10 Pro. You can jump to the summary at the bottom of the article to get a quick idea of what we’re going to do over the next few minutes.

Anyway, I’ve since learned that the vast majority of the Ruby and Rails community uses either macOS or some flavor of Linux as their operating system of choice.

Great, but what is a Windows guy like me to do under these circumstances? Well, there are a few options. Assuming they would like/need to keep using Windows as their main OS, they could virtualize some version of Linux using something like Hyper-V or VitrualBox, or go dual boot with a native Linux installation on their current hardware. Provided you can set something like these up, these solutions can work beautifully, but they can have drawbacks.

Virtual machines, depending on how you set them up and for graphical interfaces specially, can take a bit of a performance hit when compared to running the OS natively. So, having your entire development environment in one can get annoying after a while. The dual boot scenario gets rid of any performance degradation but then you have to go through the hassle of restarting anytime you want to work in a different OS. This can become a problem if you need to actively work on Windows-based projects as well.

There’s also the option of using something like Cygwin to create an environment very close to what you’d see in a Linux distribution.

Luckily for me, it turns out that Microsoft’s own Windows Subsystem for Linux is up to the task of providing a drama-free solution for working in a Linux environment within Windows. That’s why I thought I’d give it a shot in setting up my Ruby/Rails development environment. I can happily say that this exercise ended up being a resounding success.

When all was said and done, I could install, run and interactively debug Ruby and Rails apps from my editor of choice running on Windows (Visual Studio Code) and have all the editor amenities like syntax highlighting, code completion, automatic linting, etc. I could also run the app in WSL and access it via the browser on windows. Pretty much the whole shebang.

So, how did I do that? Let’s go into the detail of it with a step-by-step guide. It’s important to note though, that WSL is currently available only for Windows 10 Pro. Now let’s get started.

1. Install WSL

First of all, if you don’t already have it, we need to install a Linux distribution via the Windows Subsystem for Linux. This is as easy as firing up the Microsoft Store and searching for “WSL”. Here’s what the store greets you with:

There are multiple options here but I decided to go with Ubuntu 18.04 LTS. Ok, click it and follow the screens until you are downloading and installing it. Everything there is pretty straightforward. After the store says that the Linux distribution has been installed, it’s actually not fully installed yet. When you launch it for the first time, it’ll do some final installing that was still pending, ask you for a new UNIX username and password, and then you’ll be ready to use your newly installed Linux distribution.

Your console should look something like this now:

Installing, this may take a few minutes...
Please create a default UNIX user account. The username does not need to match your Windows username.
For more information visit: https://aka.ms/wslusers
Enter new UNIX username: kevin
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Installation successful!
To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.

kevin@KEVIN-SATELLITE:~$

Let’s look at our freshly installed distribution’s version:

kevin@KEVIN-SATELLITE:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 18.04.1 LTS
Release:        18.04
Codename:       bionic
kevin@KEVIN-SATELLITE:~$

Cool, we now have Linux running on Windows without too much hassle.

2. Install Ruby

2.1 Install RVM

Now that we have Linux, let’s go ahead and install all the stuff we need for developing Rails apps. The first thing we need as far as Ruby goes, is RVM, or Ruby Version Manager. It allows us to easily install multiple Ruby versions at the same time. A quick glance over their official web site reveals that installing RVM is pretty easy. We just have to run these two commands in our WSL Ubuntu console:

gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

\curl -sSL https://get.rvm.io | bash -s stable

After running the second command, among other things, we get something like this in the console:

...

Installing RVM to /home/kevin/.rvm/
    Adding rvm PATH line to /home/kevin/.profile /home/kevin/.mkshrc /home/kevin/.bashrc /home/kevin/.zshrc.
    Adding rvm loading line to /home/kevin/.profile /home/kevin/.bash_profile /home/kevin/.zlogin.
Installation of RVM in /home/kevin/.rvm/ is almost complete:

  * To start using RVM you need to run `source /home/kevin/.rvm/scripts/rvm`
    in all your open shell windows, in rare cases you need to reopen all shell windows.
kevin@KEVIN-SATELLITE:~$

It tells us to run one additional command in order to start using RVM so let’s do that:

source /home/kevin/.rvm/scripts/rvm

And, finally, to confirm that our RVM has installed correctly:

kevin@KEVIN-SATELLITE:~$ rvm -v
rvm 1.29.4 (latest) by Michal Papis, Piotr Kuczynski, Wayne E. Seguin [https://rvm.io]

2.2 Install a Ruby via RVM

All right, nice. Now that we have RVM installed, we are ready to install any version of Ruby that we want. Let’s see what’s available by running this:

rvm list known

RVM responds with something like this:

# MRI Rubies
[ruby-]1.8.6[-p420]
[ruby-]1.8.7[-head] # security released on head
[ruby-]1.9.1[-p431]
[ruby-]1.9.2[-p330]
[ruby-]1.9.3[-p551]
[ruby-]2.0.0[-p648]
[ruby-]2.1[.10]
[ruby-]2.2[.10]
[ruby-]2.3[.7]
[ruby-]2.4[.4]
[ruby-]2.5[.1]
[ruby-]2.6[.0-preview2]
ruby-head

...

RVM’s list known command shows us all the available Rubies that can be installed via RVM. There are a bunch of different Ruby implementations available like MRI, JRuby, IronRuby, etc. The MRI ones, listed first, stand for “Matz’s Ruby Interpreter” and represent the standard for Ruby implementations. Nowadays, it would be more accurate to call them “YARV”, but that’s a story for another day. For our purposes, let’s think of the MRI Rubies as the default Rubies. Anyway, let’s install one of the most recent ones with:

rvm install 2.5.1

With this, RVM will take its time downloading and installing Ruby 2.5.1 and all the required packages. After a while, Ruby would have been installed and we can test it with our usual:

ruby -v

Which responds with:

ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]

For those of you out there that are more on the curious side, we can run which ruby and see that the Ruby that we’re running is actually installed inside the RVM installation directory. Take a look:

kevin@KEVIN-SATELLITE:~$ which ruby
/home/kevin/.rvm/rubies/ruby-2.5.1/bin/ruby

Nice. This Ruby, since it’s the only one we have installed so far (remember that RVM allows us to have multiple versions of Ruby at the same time), will be set as our default one by RVM. You can go to RVM’s own documentation for more info on running multiple Rubies.

At this point, it’s the usual Ruby process of installing the Bundler gem and creating our skeleton Rails app. Let’s breeze through it.

3. Create a new Rails app

3.1. Set up Rails skeleton app

Now we need to install the Bundler gem by doing:

gem install bundler

We also need Rails, so…

gem install rails

Context: The problem with Windows

Installing Rails can take a while so, while the RubyGems package manager works its magic, I’d like to take the opportunity to point out one of the major pain points that we’re avoiding by not doing all this on plain Windows. When installing some gems like Rails, the package manager will not only have to download the packages, but also build some native extensions that are required for them to work.

This is where I ran into problems with Windows. Namely, these build steps would fail because, for some reason, the Windows environment does not have (at least not by default or in a way that’s easy to get) the required build and compilation tools for these to succeed.

…

Ok, now that Rails has finished installing, we can create a new app. I’ve chosen to create it inside a new railsdemo directory. So, if you’ve done the same, cd to it and create a new app with:

rails new my-rails-app --skip-spring --skip-listen

Note: File system notifications in WSL

We need to pass in the --skip-spring and --skip-listen options because, according to Rails’ official documentation, there are currently some limitations on file system notifications in the Windows Subsystem for Linux.

Ok then, let’s cd into our brand-new app’s directory and try running it with the included development web server:

kevin@KEVIN-SATELLITE:~/railsdemo$ cd my-rails-app/
Using /home/kevin/.rvm/gems/ruby-2.5.1
kevin@KEVIN-SATELLITE:~/railsdemo/my-rails-app$ rails server

Oops! Unfortunately, that doesn’t work. We get a bunch of stuff in the console ending in this:

Could not find a JavaScript runtime. See https://github.com/rails/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)

This is no biggie. All it means is that we need to install a JavaScript runtime. Let’s install Node.js to appease Rails.

sudo apt-get install nodejs

Ubuntu will ask you for your sudo password by prompting you with [sudo] password for kevin: (Obviously, instead of kevin, your username will show up there.) This is the password that you put in at the very beginning when we installed Ubuntu for the WSL. So, type it in there and let apt-get do its job. Once that’s done, let’s try running our app again with:

rails server webrick

Note: Using WEBrick instead of Puma

We’re explicitly telling Rails to use the WEBrick development server here because, currently, there’s an issue with Puma (another web server shipped with Rails) that prevents it from working in a WSL environment.

You should now see something like this in the prompt:

=> Booting WEBrick
=> Rails 5.2.1.1 application starting in development on http://localhost:3000
=> Run `rails server -h` for more startup options
[2018-12-04 16:21:10] INFO  WEBrick 1.4.2
[2018-12-04 16:21:10] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
[2018-12-04 16:21:10] INFO  WEBrick::HTTPServer#start: pid=132 port=3000

Well, this looks much better than our last try. Ok, now that the app is running, simply open up your browser of choice and navigate to localhost:3000

How cool is that? We’re running a Rails app in our WSL Linux distribution and accessing it via a browser running in Windows.

3.2. Where are my files?

So far, we’ve fired up a WSL console, created our app and served it from there. We created folders and files as part of Rails’ initialization command (rails new my-rails-app ...). Those files are definitely somewhere in our disk, but where exactly? Well that would be in our distribution’s folder within Windows. It’s hidden pretty deep within the file system but it is there. To find it, navigate to your local AppData folder in C:\Users\[YOUR_USER]\AppData\Local.

Once there, go to the Packages folder and, in there, look for a folder whose name corresponds to your installed Linux distribution. Mine shows up as a folder named CanonicalGroupLimited.Ubuntu18.04onWindows_79rhkp1fndgsc because I installed Ubuntu 18.04. It may vary slightly for different systems and distributions but, given how it’s named, it should be easily identifiable nonetheless.

All right, enter that folder and continue navigating to LocalState and then rootfs. And now, we’re finally there. This is the root of our distribution’s file system. If you navigate further through home, then a folder named after your user, you’ll find our railsdemo/my-rails-app directory. Inside it, that’s where the code of our app lives.

So, after all that spelunking, we’ve learned a few things:

Should you have multiple WSL distributions installed, they will each have a folder in the local AppData directory. That’s C:\Users\[YOUR_USER]\AppData\Local\Packages\.
Inside this folder, the folders corresponding to the installed distributions are named using their name and version, among other things. For Ubuntu 18.04, the folder is named CanonicalGroupLimited.Ubuntu16.04onWindows_79rhkp1fndgsc in my case.
The actual root of the distribution’s file system is further down that path in C:\Users\[YOUR_USER]\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu16.04onWindows_79rhkp1fndgsc\LocalState\rootfs. Once there, it’s just your usual Linux directory structure. With directories like home and the like.

Bonus: To access your local Windows file system from inside a WSL distribution, you can use the /mnt/c directory. That directory is linked to your Windows C:\ drive.

4. Using Visual Studio Code

4.1. Using VS Code to develop our Rails app

Ok, now that we managed to get all the way into the directory inside our WSL distribution where the code for our Rails app actually lives, let’s try to open it with Visual Studio Code. There’s nothing special to this, just open it like you would open any other folder in VS Code, either right click > “Open with Code” from the Windows Explorer context menu, or via the “File” > “Open Folder…” option within VS Code itself.

However you choose to do it, we end up with our app’s source code ready for editing in VS Code.

All right, that looks good. But let’s start setting up VS Code for Rails development.

VS Code has an integrated console. You can set it up so that it can use any console that’s currently installed in the system. Since we’re using WSL, let’s set that one up as the default. Press Ctrl + Shift + P to bring up the Command Palette and type in “default shell” to search for the Terminal: Select Default Shell option:

Hit Enter and select the WSL Bash from the options that pop up:

Hit Enter to make the selection. Then, press Ctrl + ` to bring up the Terminal. Our WSL console should show up and we can play around with it. As you will see, the terminal opens up in the root directory so don’t forget to navigate to where our code actually lives.

This is the same full-featured bash that we ran earlier to install Ruby and Rails and run our app in the development server. So, you can do all of that through the VS Code terminal as well. Go ahead, give it a go.

4.2. Improving the developer experience

By now, we have access to our console and a way of editing our code all within an integrated environment. At this point we’re ready to start writing some Rails code. This is, however, the bare minimum, so let’s dive into VS Code’s rich extension ecosystem in order to turn it into a powerful Rails development environment.

Press Ctrl + Shift + X and the Extensions window should show up in the sidebar. Search for “ruby” and you’ll get a bunch of results.

Indeed, there are many extensions available that aid in Ruby/Rails development but there are three in particular that I’ve found most useful:

The Ruby Extension

This is the main extension that provides support for the Ruby language in VS Code. It includes debugging, autocomplete, IntelliSense, formatting, linters, etc. To install it, just click the green install button in VS Code’s Extensions window. VS Code will then proceed to download and install the extension. It’ll then ask you to reload VS Code. After that, the extension should be installed and ready to go.

The best way to learn how to harness the full power of this tool is by reading up on their documentation. You can do this either from inside VS Code itself (in the window that opens up when you select the extension from the Extensions window) or in their official project page on GitHub.

Anyway, for this post, we’re particularly interested in interactive debugging so, as instructed by their docs, let’s install some additional gems that we’ll need for that. Run these in your terminal:

gem install ruby-debug-ide
gem install debase

With that, we’re ready as far as this extension goes. We’re going to be using it later.

The Rails Extension

This one is specific for Rails development. It includes features like code snippets, syntax highlighting support for .erb files, improvements to code navigation, among others. Install it just like any other extension, the same as we did with the Ruby extension. The only difference here is that we don’t need to install any other gems for this one to work.

The Ruby Solargraph Extension:

This extension provides a better IntelliSense and code completion experience over the base Ruby extension. Another nice thing about Solargraph is that it also includes documentation in the code completion popups. Again, you can read all about it in this extension’s page in VS Code.

We do need to install an additional gem for this one to work though, so running this is required:

gem install solargraph

4.3. Interactive debugging with VS Code

4.3.1. Adding some new code to debug

All right, once we have the Ruby extension installed and ready, setting up our project to support interactive debugging via VS Code is actually pretty straightforward, albeit with some gotchas.

Before that though, let’s actually add some code that we can debug. With Rails, this is pretty easy to do using generators. Here, run this command in your terminal:

bin/rails generate controller Greetings hello

The terminal will display something like this:

Among other things that we right now don’t care too much about, Rails has created a new Greetings controller for us with a hello action and even added a route so that we can access it via the browser.

Make sure that your dev server is running (run bin/rails server webrick if not) and let’s see what’s in there by navigating to http://localhost:3000/greetings/hello. You should see something like this:

Ok, now let’s do some trivial changes. It could be something like a simple “hello world” message getting sent from the controller to the view. It could look something like this:

# app\controllers\greetings_controller.rb
class GreetingsController < ApplicationController
  def hello
    @message = "Hello world!"
    @message.upcase!
  end
end

and…

<!-- app\views\greetings\hello.html.erb -->
<h1>Greetings#hello</h1>
<p>Find me in app/views/greetings/hello.html.erb</p>
<h1><%= @message %></h1>

Now restart your server, and navigate to http://localhost:3000/greetings/hello again. You should see something like this now:

4.3.2. Creating a launch configuration for VS Code

Now, to debug our code, we need to create a new launch configuration for VS Code. With the help of the Ruby extension, that’s pretty easy: Press Ctrl + Shift + D to bring up the Debugger window in the sidebar, then, near the top of the screen, expand the “No Configurations” drop down and select “Add Configuration…”. It looks like this:

After clicking that option, VS Code will ask you to select an environment from a list. The items that show up in this list will depend on your setup but Ruby will most definitely be there, so select that:

Once that’s done, VS Code will open a new launch.json file that it has just created under a new .vscode folder in the root directory of your project. This file’s purpose is to store all the possible launch configurations for the project that will allow them to be executed from within VS Code. You’re supposed to put things like “start up the dev server” or “run all the unit tests”, etc.

For our Rails project however, the Ruby extension has created a bunch of configurations. Feel free to take a look but right now we only care about this one:

{
    "version": "0.2.0",
    "configurations": [
        // ...
        {
            "name": "Listen for rdebug-ide",
            "type": "Ruby",
            "request": "attach",
            "cwd": "${workspaceRoot}",
            "remoteHost": "127.0.0.1",
            "remotePort": "1234",
            "remoteWorkspaceRoot": "${workspaceRoot}"
        },
        // ...
    ]
}

We can’t use it just like that though. We need to tell VS Code where the source code is located in the “remote machine” (i.e. our WSL Linux distribution). Let’s then change the remoteWorkspaceRoot field’s value to our project’s root in WSL. In my case that’s /home/kevin/railsdemo/my-rails-app.

So, the whole entry now looks like this:

{
    "name": "Listen for rdebug-ide",
    "type": "Ruby",
    "request": "attach",
    "cwd": "${workspaceRoot}",
    "remoteHost": "127.0.0.1",
    "remotePort": "1234",
    "remoteWorkspaceRoot": "/home/kevin/railsdemo/my-rails-app"
},

This configuration allows VS Code to, with the click of a button, attach to a debugger that’s already running in some other machine and inspect the code. This is essentially a configuration for debugging remotely. We need to use such a configuration because we will not be running our Rails app in the same place where VS Code is running. That is, our Rails app will be running within WSL and VS Code will be running in the good-old Windows host.

If we were working with VS Code on Linux or if we were running Ruby directly on our Windows machine, we would be able to use a simpler configuration. In fact, of the ones that were created for us just now, the one named Rails server would just do the trick.

For our case though, since we’re running the Rails app and VS Code in separate “machines” (not really, but kind of, from the perspective of the debugger), we need to use this. We need to attach to a remote debugger.

Again, feel free to look around the launch.json file that the Ruby extension has kindly provided for us as well as their docs to get further insight into how all of this works and the extent of what you can do with it.

Gotcha: Ruby versions 2.5.0 and 2.5.1 have some issues

At this point there’s one big gotcha. Ruby versions 2.5.0 and 2.5.1 have some issues that prevent doing this kind of debugging in Rails apps. You can read more about that here. Thankfully, there’s a quick workaround: Replace the require 'bootsnap/setup' line in the config\boot.rb file with something like this:

unless ( (('2.5.0'..'2.5.1').include? RUBY_VERSION) && defined?>(Debugger) )
    require 'bootsnap/setup' # Speed up boot time by caching expensive operations.
end

Basically, we’re preventing the inclusion of the bootsnap/setup gem for versions of Ruby between 2.5.0 and 2.5.1.

4.4.4. Setting code breakpoints

Ok, with all of that taken care of, let’s add a few breakpoints to our code by clicking close to the left of the line number where we want the code’s execution to stop. Red dots should show up. It could be something like this:

4.4.5. Debugging with VS Code

Now, we need to run our dev server in a way that allows for a debugger to inspect it while it executes. We can do that using the ruby-debug-ide gem that we installed earlier. The command would look like this:

rdebug-ide ./bin/rails server webrick

Run this in your WSL terminal and it should respond with something like this:

Fast Debugger (ruby-debug-ide 0.6.1, debase 0.2.2, file filtering is supported) listens on 127.0.0.1:1234

Now, back in VS Code, go back to the Debug sidebar (remember you can press Ctrl + Shift + D to get it to show up) and, in the configurations drop down that we used before, select the “Listen to rdebug-ide” option. Finally, press the green “Play” button right next to it. This one:

After doing this, a few things happen:

VS Code shows this new tool bar:

VS Code’s bottom bar turns from blue to orange to indicate that it’s in debug mode.
The previous prompt that we had in our terminal about Fast Debugger and whatnot, continues and shows the rest of the usual WEBrick output:

=> Booting WEBrick
=> Rails 5.2.2 application starting in development on http://localhost:3000
=> Run `rails server -h` for more startup options
[2018-12-05 13:18:17] INFO  WEBrick 1.4.2
[2018-12-05 13:18:17] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
[2018-12-05 13:18:17] INFO  WEBrick::HTTPServer#start: pid=931 port=3000

...

Now that the app is running and the VS Code debugger is attached to it, let’s navigate to http://localhost:3000/greetings/hello and behold…

If you take a look at VS Code now, you’ll see that code execution has stopped in the first breakpoint that we set and is waiting for us to continue. How cool is that?

VS Code’s debug mode GUI is pretty complete with a console for evaluating any expression in context, watches, listings of variables in scope, call stacks… Pretty much anything you would want or need in your debugging session.

Summary

So, in summary, here’s what we just did:

Installed a WSL distribution.
Installed RVM.
Installed a Ruby via RVM.
Created a new Rails app in the WSL distribution’s file system.
Ran the Rails app in WSL and accessed it via the browser from Windows.
Learned where the WSL file system lives within Windows.
Opened the Rails app’s source code in VS Code.
Set VS Code’s Terminal’s default shell as WSL’s bash.
Installed and set up key VS Code extensions for Ruby/Rails development like “Ruby”, “Rails” and “Solargraph”.
Created a demo controller with a simple hello world action.
Added a suite of Ruby/Rails launch configurations to VS Code via the launch.json file.
Set up an “attach” launch configuration for our Rails app.
Learned how to deal with Ruby versions 2.5.0 and 2.5.1 for debugging.
Set breakpoints in VS Code.
Launched the Rails app’s dev server from WSL in remote debug mode.
Attached our debugger from VS Code running on Windows to the Rails app running in WSL.
Had our minds blown because we accomplished all of this and now developing Ruby/Rails on Windows will be much easier and fun.

Yeah, we’ve accomplished quite a lot! We should feel pretty proud.

Few bugs will withstand the power of this combo for too long. Also, if there’s a big code base that you need to understand in order to add some features, interactive debuggers are incredibly useful for that as well.

And now, if you’re on Windows (10 Pro) and your project is written in Rails, you know how to set it all up.

Running Magento 2 in Windows with XAMPP

2019-03-22T00:00:00+00:00

Photo by Nicole De Khors · Burst, Some Rights Reserved

Magento is an open source ecommerce platform, written in PHP and relying on MySQL/MariaDB for persistence. According to BuiltWith, Magento is the third most used platform in ecommerce websites. It began its life in 2008 with its first general release, and a major update (Magento 2) was released in 2015.

And now, more than three years after, Magento 1 is slowly dying: There won’t be any more quality fixes or security updates from June 2020, and there won’t be extended support for fixes or new payment methods. So the obvious choice will be Magento 2 from now on.

But is it fully tested yet? Is it stable enough? If we already have a website running with Magento 1, what should we do? Migrating to Magento 2 is not just hitting an “Update” button: Themes are incompatible, most extensions won’t work, and of course, there’s a big set of changes to get familiar with.

So a good approach might be to get a clean Magento 2 version deployed locally, to look what we need to do to get our website updated and running, test the backend, find where the configuration sections are located, and so on. And many business users, and even some developers like myself, have Microsoft Windows installed on our computers.

Environment setup

The environment I used for this testing installation was Windows 10 Professional. As a first step, we’ll need to make sure that localhost is published in our local hosts file:

Navigate to the folder %SystemRoot%\system32\drivers\etc
Backup the existing hosts file
Open a text editor with administrator rights
Open the hosts file
Make sure the first line after the commented (#) lines is 127.0.0.1 localhost and the second is ::1 localhost
Open a cmd window with administrator rights and run the command ipconfig /flushdns

Now we’re ready to install the environment needed to run Magento. I recommend using XAMPP, a free Apache distribution for Windows that includes MariaDB, PHP, and Perl in a single package. Magento 2 currently runs with PHP 7.2 and it will not work with newer versions.

Install XAMPP 7.2 with default settings: apachefriends.org/xampp-files/7.2.15/xampp-win32-7.2.15-0-VC15-installer.exe
Download Magento 2. You will need to register on the website first: magento.com/tech-resources/download
Create a new “magento” subfolder (or whatever name you prefer) inside the htdocs folder in the XAMPP installation (usually C:\xampp) and uncompress the Magento 2 archive there.
Start the XAMPP Control Panel from the Windows start menu. In the “Apache” section, click the “Config” button and, on the menu that appears, select “PHP (php.ini)”. Remove the semicolon before the extension=intl, extension=soap, and extension=xsl texts to enable the intl, soap and xsl extensions.

Screenshot of the XAMPP Control Panel with the PHP config menu displayed.

MySQL and Magento setup

We have all the files in place and the environment ready to start configuring the database and install Magento 2.

Start the Apache and MySQL services from the XAMPP Control Panel. Wait for the green status texts to appear.
Create a “magento” (or whatever name you prefer) database in MySQL from phpMyAdmin, installed already on XAMPP: localhost/phpmyadmin
Run the Magento 2 setup from localhost/magento (replace the “magento” part of the URL with whatever name you have chosen to host Magento). If the setup program requires to do any additional configuration change, do it as instructed. Do a screenshot or save the final page contents for later use.

Example of the page that will be displayed when the Magento 2 installation finishes.

Fixing known issues

When we finish the installation process, we will have a Magento 2 instance running on our host. But we’re not ready yet! There are a couple known bugs with Magento 2 and XAMPP at the moment I’m writing this post:

The Magento admin page may not work (it shows a blank page): Fix this issue by updating the “isPathInDirectories” function inside the Validator.php file as instructed in this article.
We might not be able to upload images (like a custom logo or product pictures): Fix this issue by updating the design_config_form.xml file as shown here.

After we finish making these changes, we will need to restart the Apache service from the XAMPP control panel. And that’s it! We should be ready to open the Magento front page, and login into the backend.

An empty home page with the default theme enabled in Magento 2.

This is how the Magento 2 back-end dashboard looks like once we login.

Setting up the store: A roadmap

The purpose of this article is to get Magento 2 up and running on Windows computer, and that’s what I hope we’ve achieved so far. But just to point in a direction on what to do next, below is my usual roadmap to set up the store, add a few products and publish the catalog on the home page.

Change the default store name and logo from the section Content > Design > Configuration and choose “Edit” in the “Default store view”.
Set up the default store configuration from the section Stores > Configuration.
Create the product categories from the section Catalog > Categories. Set up a category name and its dependency from another category, or from the default master category.
Create/edit the product attributes from the section Stores > Attributes (check the option “visible in storefront” to show the products in the product page). For example, custom attributes for book products would be Author, Publisher…
Add the attributes to the default attribute set from the section Stores > Attribute. This is required for the attributes to show up when adding a new product by default.
Create a set of products from the section Catalog > Products. Set the custom variations for each product from the “Customizable options” section. Set up a short and long description, a custom SKU for each customizable option, and a tax mode.
Add a widget to the homepage to show the product catalog from the section Content > Homepage > Edit > Show/Hide Editor > Add widget > Products list. Here we can also add any content we like, including HTML tags, images, and third-party content.

Conclusion

It’s possible—and pretty straightforward—to run a Magento 2 instance in Windows with XAMPP. But this is just a kick-off, a simple overview: there’s a lot more to do if we want to get a full ecommerce website that is ready to scale up and support enterprise-level traffic, like caching optimization, load balancing, and advanced server-side monitoring.

At End Point, we have professionals with a strong background in deploying powerful, reliable, fully responsive, fast, and SEO-optimized ecommerce websites. We have experience in migrating Magento to newer versions, and even creating full Magento 2 websites from scratch. Drop us a line if you want to hear more.

Where are you with your Windows OS in 2019?

2019-02-12T00:00:00+00:00

Photo by bradleypjohnson · CC BY 2.0

It should be of little surprise that on January 14, 2020, after a decade of Windows 7, Microsoft will stop providing security updates and support for this older operating system. Windows 7 was released in 2009, and due to its stability enjoyed many years as the go-to operating system for home and business alike.

Even now, it is estimated by NetMarketShare that over 40% of businesses still rely on it. Despite Microsoft having ended mainstream support for Windows 7 in 2015, it still offered extended support because of the operating system’s popularity, and the generally slow adoption of newer releases. However, that support shall soon end, as will support for Windows Server 2008 R2 (release 2), which also remains in wide use. Organizations of all kinds will need to upgrade to newer operating systems to remain secure.

The corporate adoption of Windows 8 and 8.1 may have been slow in part due to Microsoft’s radical changes to the user interface, such as replacing navigation menus with information-filled “live” tiles. Windows 10, however, was designed as a compromise, providing a Windows 7-like Start menu, while preserving the live tile interface for accessing applications and services from the desktop. There are many compelling reasons for moving from Windows 7 to Windows 10. The most notable is that Windows 7 will no longer receive any security updates, creating serious security risk and compliance issues.

In 2018, Microsoft adopted a Semi-Annual Channel (SAC) governed by the Modern Lifecycle Policy. This means that feature updates are released to the public twice a year, around March and September. Updates are cumulative. Updating to these releases is required to remain eligible for support from Microsoft. Security updates are released monthly and quarterly as rollups, and critical updates are released as needed. This is part of Microsoft’s plan to minimize vulnerabilities and security exposure in an ever-changing digital world.

Time to change

At End Point we consider keeping our clients’ systems updated both fundamental and essential. Companies need stable systems in order to operate, and uptime is of critical importance. This is one reason we offer our RMM (Remote Management and Monitoring) services. We connect with our clients’ systems to receive custom-defined policies for patching, then monitor and test updates before we deploy them on the cycle that best suits our customer’s workflow.

We are committed to helping our clients transition safely and efficiently to Windows 10. It can be a lengthy process when accounting for the time it takes to properly test all business applications and processes before transitioning to a new OS, and the time it takes to make any necessary hardware changes and complete the update.

See the charts below to learn when service will end for various versions of Windows, and contact us for a consultation on the best ways to manage your IT to keep your organization secure.

Windows 10

OS version	Date of availability	End of service for Home, Pro, and Pro for Workstation Editions	End of service for Enterprise and Education Editions
Windows 10, version 1809	November 13, 2018	May 12, 2020	May 11, 2021
Windows 10, version 1803	April 30, 2018	November 12, 2019	November 10, 2020
Windows 10, version 1709	October 17, 2017	April 9, 2019	April 14, 2020
Windows 10, version 1703	April 5, 2017	October 9, 2018	October 8, 2019
Windows 10, version 1607	August 2, 2016	April 10, 2018	April 9, 2019
Windows 10, version 1511	November 10, 2015	October 10, 2017	October 10, 2017
Windows 10, released July 2015 (version 1507)	July 29, 2015	May 9, 2017	May 9, 2017

Enterprise LTSC/LTSB Editions

Windows 10 LTSC/LTSB editions also follow the Fixed Lifecycle policy. To learn more, see Microsoft Business, Developer and Desktop Operating Systems Policy.

OS version	Date of availability	Mainstream support end date	Extended support end date
Windows 10 Enterprise LTSC 2019 / Windows 10 IoT Enterprise LTSC 2019	November 13, 2018	January 9, 2024	January 9, 2029
Windows 10 Enterprise 2016 LTSB / Windows 10 IoT Enterprise 2016 LTSB	August 2, 2016	October 12, 2021	October 13, 2026
Windows 10 Enterprise 2015 LTSB / Windows 10 IoT Enterprise 2015 LTSB	July 29, 2015	October 13, 2020	October 14, 2025

Note: Not all features in an update will work on all devices. A device may not be able to receive updates if the device hardware is incompatible, lacks current drivers, or is otherwise outside the original equipment manufacturer’s (OEM) support period.

For more information on the Windows 10 lifecycle, see Windows 10 Client and Windows Server Semi-Annual Channel Lifecycle Policy update (February 1, 2018) or the Windows 10 release information page. To learn more about the Windows 10 mobile lifecycle, see Windows 10 Mobile.

Windows 8.1 and 7

Prior releases of the Windows operating system are likewise governed by the Fixed Lifecycle Policy. This policy comprises two phases: mainstream support and extended support. See Microsoft Business, Developer and Desktop Operating Systems Policy for more details.

OS version	End of mainstream support	End of extended support
Windows 8.1	January 9, 2018	January 10, 2023
Windows 7, service pack 1*	January 13, 2015	January 14, 2020

* Support for Windows 7 RTM without service packs ended on April 9, 2013. Be sure to install Windows 7 Service Pack 1 to continue to receive support and updates.

Prior versions of Windows, including Windows 7 and Windows 8.1, have limited support when running on new processors and chipsets from manufacturers like Intel, AMD, Nvidia, and Qualcomm. For more information, see the Microsoft Lifecycle Policy. A device may not be able to run prior versions of Windows if the device hardware is incompatible, lacks current drivers, or is otherwise outside the original equipment manufacturer’s (OEM) support period.

(Windows life cycle charts and information were taken from Microsoft’s windows support site.)

Data Center Relocation Initiatives: Daunting But Achievable

2018-12-20T00:00:00+00:00

Photo by Seeweb · CC BY-SA 2.0, cropped

Introduction

A customer asked for our help dealing with logistical nightmares they encountered during a hardware update and data center relocation project. The customer had two active data centers, and wanted to relocate one of them to a modern Tier 4 facility to improve its performance and provide redundancy for critical systems. They also wanted to consolidate or decommission equipment to reduce recurring expenses and reduce their carbon footprint. The client decided to move to a Tier 4 data center because they provide across-the-board redundancy within the data center.

Moving forward with Tier IV

Enterprises typically transition to Tier 4 data centers because they offer the highest uptime guarantees, and have no single points of failure. These facilities are fully redundant in terms of electrical circuits, cooling, and networking. This architecture is best able to withstand even the most serious technical incidents without server availability being affected. Tier IV facilities have contracts with disaster management companies who will provide them, for example, with fuel in the event that a natural disaster damages the power grid.

(More information about the four data center levels is at the end of this post.)

Key Issues

Some of the customer’s key concerns were:

1. To safely move their virtual environment to the new data center.

2. To protect assets during the relocation.

3. To completely shut down the current data center and migrate seamlessly to the new data center.

4. To update external DNS records without causing any downtime for the web applications used by their customers.

Project Planning

To manage data center relocations is challenging because there are many moving parts and variables. Typically, planning starts 6 months ahead of the scheduled relocation date. We seek to understand the role of each system by consulting in-depth with all the teams involved. We analyze each part of the client’s tech infrastructure, break it down, and strategize about the best approach for handling the migration of each component. Additional time to plan can help especially when a large group of stakeholders is involved. Successful planning requires hard and sometimes extensive work, but makes an otherwise overwhelming data center migration smooth and worry free.

Here are some of our procedures for pre-migration preparation:

1. Process the paperwork for new hardware. Identify, review, and approve all applications. Hire movers. Schedule and coordinate with internal management and key stakeholders like IT staff, system admins, contractors, circuit providers, etc.

2. Collect and analyze resource usage associated with the critical and non-critical systems and compare resource needs to resource availability at the new facility.

3. Design and schedule the migration of critical systems to the new data center. Discuss the plan with key stakeholders.

4. Make sure replicas of critical systems are up to date.

5. Set up a new environment with new hardware in the new data center and establish network connections.

6. Prepare hardware and virtualization technology in the new data center.

7. Test, retest, and burn in the new hardware (2–4 weeks of testing).

8. Create a non-essential server within the virtualization environment and test it.

A Challenge: Eliminating Downtime

To minimize or eliminate downtime requires very careful preparation. With this particular client, we had the luxury of their already having a secondary data center, which could accommodate a majority of the critical systems during the migration.

We originally planned to leverage this by simply changing the external DNS records to point to this data center during the migration, but during planning determined that the external DNS record would not replicate worldwide quickly enough to meet the uptime needs of their global operation.

Solutions

After discussing various approaches, we ended up using a load balancer. A load balancer is a network device that routes incoming traffic destined for a single destination (web site, application, or service) and ‘shares’ the incoming connections across multiple destination devices or services. In this case, the data center we were to migrate to housed the client’s critical systems like web servers, database, etc. The secondary data center housed a replica of the critical systems using a replication technology, e.g. Actifio, Rubrik, SAN mirroring, VMWare SRM, or Zerto — we used Actifio in this scenario.

The customer had multiple systems with external DNS records and public IP addresses. We did not change the public DNS names for the critical systems. We did change the public IP addresses associated with the public DNS names, to point to the load balancer, which then pointed to the appropriate data center throughout the process. This setup enabled a gradual, flexible, and fully controlled transition to the new data center.

Summary

Our client wanted to reduce their servers’ power usage 40% by consolidating into a hyper-converged system. Other goals were to reduce floor space by 50%, and monthly recurring data center charges by 50%. We transitioned them to a new hardware stack (compute, storage, network, backup environment) in a Tier 4 data center, and saved them 50% percent on data center operation costs. Additionally, during the process we corrected issues associated with disaster recovery and business continuity, leaving the client’s operations more resilient, affordable, and more secure.

Appendix: Data Center Classifications

Tier IV (Best)

Tier IV data centers have redundancies for every process and data protection stream. No single outage or error can shut down the system. To keep Tier IV ranking, data centers must have 99.995% minimum uptime per year. They come equipped with 2N+1 infrastructure (two times the amount required for operation plus a backup), which is considered “fully redundant.”

Tier III (Average)

N+1 (the amount required for operation plus a backup) fault tolerance, which means a Tier III facility can undergo routine maintenance without a hiccup in operations. 99.982% minimum uptime per annum, used for maintenance and overwhelming emergencies.

Tier II (Minimal)

99.749% minimum uptime. Tier II facilities have considerably more downtime than Tier III facilities, primarily because Tier II facilities have less redundancy. They do however have partial cooling redundancy and multiple power redundancies.

Tier I (Basic, Cheapest)

99.671% minimum uptime, with 28.8 hours of downtime each year.

Meet the End Point Windows consulting group

2018-07-27T00:00:00+00:00

As the share of internet traffic passing through mobile devices hovers around 50%, it’s easy to forget that a lot of computing still happens on desktops and laptops—and perhaps even easier to forget that the majority of those desktops and laptops are running Microsoft Windows.

At End Point, we take pride in being a multi-platform organization and using open source technologies in real-world business environments. Our internal chat service, wiki, and many other libraries and tools we employ across our client base are all open source. However, for various reasons many companies choose Microsoft’s solutions including long-time standards Windows Server, Active Directory, and Exchange.

In April 2017, Dan Briones came to End Point to head up the company’s new Windows infrastructure services. In 2018 we added two new engineers to the mix, Chris Hopkins and Charles Chang, to form a full-service Windows consulting team, all local to our New York City office on Park Avenue.

Dan Briones

Dan is the team lead and has over three decades of hands-on experience in IT systems management, systems integrations, migrations, virtualization, networking, security, orchestration, security, compliance, and maintenance, specializing in the Microsoft Windows ecosystem. He also develops applications using the .NET framework and SQL Server database. Dan works with many of our local New York clients, focusing on their network and infrastructure.

Charles Chang

Charles has 21 years of experience in IT ranging from managing Windows infrastructure, to datacenter relocation and hardware refresh initiatives, office relocation, virtualization, disaster recovery and business continuity strategy. Charles has worked extensively with major vendors such as VMware, IBM, EMC, Cisco, and Dell in building enterprise environments in the datacenter. He also has experience in implementing data loss prevention technology, web and email filtering to protect and provide a healthy infrastructure.

Chris Hopkins

Chris has 10 years of experience in IT, network support, and development. He has extensive cross-platform development and hardware knowledge. Chris excels at mail migrations, Active Directory and Windows Server environments, site-to-site website migrations, and cloud-based phone systems.

Learn more about the services our Windows consulting group offers and talk to us today about how we can help you too!

Series Digital joins End Point!

2017-06-01T00:00:00+00:00

End Point has the pleasure to announce some very big news!

After an amicable wooing period, End Point has purchased the software consulting company Series Digital, a NYC-based firm that designs and builds custom software solutions. Over the past decade, Series Digital has automated business processes, brought new ideas to market, and built large-scale dynamic infrastructure.

Series Digital launched in 2006 in New York City. From the start, Series Digital managed large database installations for financial services clients such as Goldman Sachs, Merrill Lynch, and Citigroup. They also worked with startups including Drop.io, Byte, Mode Analytics, Domino, and Brewster.

These growth-focused, data-intensive businesses benefited from Series Digital’s expertise in scalable infrastructure, project management, and information security. Today, Series Digital supports clients across many major industry sectors and has focused its development efforts on the Microsoft .NET ecosystem. They have strong design and user experience expertise. Their client list is global.

The Series Digital team began working at End Point on April 3rd, 2017.

The CEO of Series Digital is Jonathan Blessing. He joins End Point’s leadership team as Director of Client Engagements. End Point has had a relationship with Jonathan since 2010, and looks forward with great anticipation to the role he will play expanding End Point’s consulting business.

To help support End Point’s expansion into .NET solutions, End Point has hired Dan Briones, a 25-year veteran of IT infrastructure engineering, to serve as Project and Team Manager for the Series Digital group. Dan started working with End Point at the end of March.

The End Point leadership team is very excited by the addition of Dan, Jonathan, and the rest of the talented Series Digital team: Jon Allen, Ed Huott, Dylan Wooters, Vasile Laur, Liz Flyntz, Andrew Grosser, William Yeack, and Ian Neilsen.

End Point’s reputation has been built upon its excellence in e-commerce, managed infrastructure, and database support. We are excited by the addition of Series Digital, which both deepens those abilities, and allows us to offer new services.

Talk to us to hear about the new ways we can help you!

Easier IE Site Testing With RemoteIE

2014-12-02T00:00:00+00:00

Microsoft recently announced a new service which I’m finding very useful. RemoteIE lets you test your sites with IE (currently version 11) on Windows 10 Technical Preview. The service runs in Azure RemoteApp which is available for several clients including Android, iOS and Windows Phone. What’s great about this is that you do not have to install and maintain your own virtual machine with VirtualBox or VMWare.

To use RemoteIE you’ll need a valid Microsoft account—it’s easy to sign up if you don’t already one. Once you have an account and have downloaded & installed the Azure RemoteApp client of your choice it’s just a matter of starting it up and logging in. Happy Testing!

Updating Firefox and the Black Screen

2014-10-16T00:00:00+00:00

If you are updating your Firefox installation for Windows and you get a puzzling black screen of doom, here’s a handy tip: disable graphics acceleration.

The symptoms here are that after you upgrade Firefox to version 33, the browser will launch into a black screen, possibly with a black dialog box (it’s asking if you want to choose Firefox to be your default browser). Close this as you won’t be able to do much with it.

Launch Firefox by holding down the SHIFT key and clicking on the Firefox icon. It will ask if you want to reset Firefox (Nope!) or launch in Safe mode (Yes).

Once you get to that point, click the “Open menu” icon (three horizonal bars, probably at the far right of your toolbar). Choose “Preferences”, “Advanced”, and uncheck “Use hardware acceleration when available”.

Close Firefox, relaunch as normal, and you should be AOK. You can try re-enabling graphics acceleration if and when your graphics driver is updated.

Reference: here.

PostgreSQL Windows installer tip: passwords

2009-07-07T00:00:00+00:00

Updated below!

When specifying a password for the Windows PostgreSQL one-click installer, you get this message:

Please provide a password for the database superuser and service account (postgres). If the service account already exists in Windows, you must enter the current password for the account. If the account does not exist, it will be created when you click ‘Next’.

If you have already installed Postgres as a service, you will need to enter the current user postgres service user password to get past the password dialog box. Meaning, if you’re logged in to Windows as ‘selena’, you need to enter selena’s password. As a non-Windows user, this baffled me, and a few other people on this thread.

Otherwise, you can just enter a password that will be used for the ‘postgres’ database user. Hope this helps someone!

Update:

Further explanation from Dave Page, the maintainer of the Windows package:

Selena: It’s not the password for the user that you are logged in as that you need to enter, it’s the password for the service account (ie. postgres).

Unlike *nix & Mac, service accounts on Windows need to have passwords so unfortunately we need to ensure we have the correct password to install the service. Hence, if there’s an existing postgres account, we need the existing password, otherwise the account will be created with whatever password you specify.

In all OSes, we use the password entered on that page as the database superuser password.

TrueCrypt whole-disk encryption for Windows

2008-12-13T00:00:00+00:00

A few months ago I had a chance to use a new computer with Windows Vista on it. This was actually kind of a fun experience, because Windows 98 was the last version I regularly used myself, though I was at least mildly familiar with Windows 2000 and XP on others’ desktops.

Since I’ve been using encrypted filesystems on Linux since around 2003, I’ve gotten used to the comfort of knowing a lost or stolen computer would mean only lost hardware, not worries about what may happen with the data on the disk. Linux-Mandrake was the first Linux distribution I recall offering an easy encrypted filesystem option during setup. Now Ubuntu and Fedora have it too.

I wanted to try the same thing on Windows, but found only folder-level encryption was commonly used out of the box. Happily, the open source TrueCrypt software introduced whole-disk system encryption for Windows with version 5. I’ve now used it with versions 6.0, 6.1, and 6.1a on three machines under Windows Vista and XP, and it really works well, with a few caveats.

The installation is smooth, and system encryption is really easy to set up if you don’t have any other operating systems on the machine. It will even encrypt on the fly while you’re still using the computer! It’s faster if you exit any programs that would use the disk, but it still works under active use. Very impressive.

Some people have reported problems with logical (extended) partitions. Others have workarounds for dual-booting. I tried dual-booting GRUB with Windows Vista as per this blog post.

That seemed to work well, and Linux booted. Vista also started but then partway through the boot process, after the GUI started up, it noticed something had changed and it died with the largest red “ERROR” message I’ve ever seen. Microsoft makes impressive error messages!

I battled with dual-booting for a while but eventually gave up, as I was just playing around with it anyway. Sticking with TrueCrypt’s recommended Windows-only configuration, everything’s worked great. The additional CPU for encryption and decryption is negligible, and becomes increasingly so with multi-core CPUs.

Everyone with a laptop should really be using encrypted filesystems. The peace of mind is well worth the minor initial work and the one extra passphrase to enter at boot time.

As a footnote to my catch-up on the state of Windows, it’s really much easier to bear as a Unix and X Window System user with the now wide availability of open source software for Windows. I used 7zip, Audacity, Coolplayer, Cygwin, Firefox, Gimp, Git, Gnucash, Google Chrome, OpenOffice.org, Pidgin, Putty, Strawberry Perl, Vim, VirtualBox, VLC, WinMTR, WinPT (including GnuPG), WinSCP, Wireshark, and Xchat (from Silverex).

Oh, and also helpful was somebody’s nice registry edit to remap the Caps Lock key as another Control key, so I don’t go crazy. The somewhat abandoned WinPT takes some prodding to get working on a few customer machines I’ve set it up on, but otherwise all the open source software I tried worked well on Windows. I’m sure there’s much more out there too. This UTOSC presentation’s slides mentions more.

However, it’s still no replacement for a fully free system. So despite the brief investigation, I’ll be sticking with Linux. :)

64-bit Windows naming fun

2008-09-30T00:00:00+00:00

At OSNews.com the article Windows x64 Watch List describes some of the key differences between 64-bit and 32-bit Windows. It’s pretty interesting, and mostly pretty reasonable. But this one caught my eye:

There are now separate system file sections for both 32-bit and 64-bit code

Windows x64’s architecture keeps all 32-bit system files in a directory named “C:\WINDOWS\SysWOW64”, and 64-bit system files are place in the the oddly-named “C:\WINDOWS\system32” directory. For most applications, this doesn’t matter, as Windows will re-direct all 32-bit files to use “SysWOW64” automatically to avoid conflicts.

However, anyone (like us system admins) who depend on VBScripts to accomplish tasks, may have to directly reference “SysWOW64” files if needed, since re-direction doesn’t apply as smoothly.

I’ve been using 64-bit Linux since 2005 and found there to be some learning curve there, with distributors taking different approaches to supporting 32-bit libraries and applications on a 64-bit operating system.

The Debian Etch approach is to treat the 64-bit architecture as “normal”, for lack of a better word, with 64-bit libraries residing in /lib and /usr/lib as always. It’s recommended to run a 32-bit chroot with important libraries in the ia32-libs package going into /emul/ia32-linux. Ubuntu is similar, but its ia32-libs puts its ia32-libs files into /usr/lib32.

The Red Hat approach called “multilib” keeps 32-bit libraries in /lib and /usr/lib with new 64-bit libraries living in /lib64 and /usr/lib64. (I mentioned this a while back while discussing building a custom Perl on 64-bit Red Hat OSes.)

Each way has its tradeoffs, and causes a bit of trouble. That’s just the cost of dealing with multiple architectures in a single running OS, where no such support was previously needed.

But the Windows way? Putting your 32-bit libraries in C:\WINDOWS\SysWOW64 and your 64-bit libraries in C:\WINDOWS\system32? It hurts to see the names be exactly backwards. That’s really tops for confusion.

Windows 10 End of Life: What Are Your Upgrade Options?

What Does End of Life Mean?

Why Upgrade to Windows 11?

Options for Upgrading to Windows 11

Check System Compatibility

1. Upgrade Your Existing Device

2. Purchase a New Device

3. Bypass the Hardware Checks

Considerations When Upgrading

Conclusion

SSH Key Auth using KeeAgent with Git Bash and Windows CLI OpenSSH

Git Bash support

Windows command line OpenSSH support

Windows SSH key agent forwarding confirmation

KeePass and KeeAgent

.NET Conf 2021 is coming!

Mobile development

Hot reload (after some struggling)

Blazor 6

LTS (Long Term Support)

Automating Windows Service Installation

A Note On Compatibility

Creating a Windows Setup Project

Configuring the Installation File System

Creating an Installer class

Adding Installer CLI Options

Using Custom CLI Options in the Installer Class

Conditionally Installing Files

Conclusion

.NET 5 will be released at .NET Conf 2020

Windows Desktop development (WPF/​Windows Forms/​UWP)

Full-stack web development (C#/​Blazor)

C# 8

Updates to Entity Framework

Updates to ML.NET

And more

Job opening: Windows Systems Integrator

Skills and tools

Location

Benefits

How to contact us

Equal opportunity employer

Linux Development in Windows 10 with Docker and WSL 2

What’s new with WSL 2

1. It’s faster and more compatible

2. It’s better integrated with Windows

3. It can run Docker

4. A newer version means several bugfixes

The development environment

Step 1: Install WSL 2 and Ubuntu

Step 2: Install Docker

Step 3: Install some useful VS Code extensions

Step 4: Create the development container

The project directory

The Dockerfile

The configuration file

The development container

Hello Windows + WSL 2 + Ubuntu + Docker + PHP + VS Code

Interactive debugging

Resources:

End Point Security Tips: Securing your Infrastructure

Implement Security Measures to Protect Your Organization & Employees

Habits of a Security Culture

A Security Concern: Going Phishing!

Phishing Exercises

Essential Security Tools

Firewall

Network Assessment & Internal Threat Protection

Enterprise Antivirus Systems

Web Filtering Technology

Data Loss Prevention

Email Filtering

Two Factor Authentication (2FA)

VPN (Virtual Private Network)

Password Reset Systems

Recovery Tools

Data and System Backups/​Disaster Recovery

Additional Security Recommendations

SSL/TLS Certificates

Recent Destructive Incidents

Windows Desktop development (WPF/Windows Forms/UWP)

Full-stack web development (C#/Blazor)

Data and System Backups/Disaster Recovery

Enterprise LTSC/LTSB Editions