Find out what's been happening in the PowerShell community, and get "pumped up" for a week at Summit! PowerShell.org CEO Don Jones covers what's new, what's been happening, and offers sage advice for getting the most from your Summit experience.
Join Microsoft Technical Fellow Jeffrey Snover for a look at PowerShell of 2018.
Team Leadership Session
Join one of original PowerShell team members for a look at how PowerShell has evolved over time. We'll look at both the technical and environmental drivers behind many of the decisions that made PowerShell what it is today.
Text data is a pain. Whether it's checking files for SSNs, verifying that a password is complex enough, or updating every page in your web site, text is a pain. Now, you probably know that "regular expressions" could help, but aren't they really hard? Well, not if Mark Minasi's explaining them.
Is that a valid email address, or just a SQL injection attack? Does that folder full of Word files contain any credit card or bank routing numbers? Does that proposed password meet our requirements? How can I easily extract just a few important bits of weather data from a page full of raw HTML? If you've been coding or scripting for any time at all, then you already know the answer -- "regular expressions" or "regexes." But if you're like most of us, regex is one of those "I'll get around to it one day" things, and while "\d=digit, \s=white space, etc" is relatively easy to learn, regex soon becomes essentially opaque. ("Isn't that line noise?" is the one of the more polite observations one hears.)
In this "medium-deep dive," award-winning author, teacher and veteran of more text processing debacles than he prefers to remember Mark Minasi shines a light on how regex works and offers tips on how to get the best out of it. In this session, you'll learn a minimum of regex, which then enables us to get an in-depth knowledge of how the regex "engine" works -- knowledge which is the key to getting anything done in regex. Then you'll see how PowerShell's regex engine -- which is really .NET's regex engine -- can be configured and how it behaves differently from other regex engines. (It's astounding how easily you can build an infinite loop with regex, so you're REALLY going to want to know how to set up regex timeouts.) With that out of the way, we'll then cover regex syntax with lots and lots of examples, as well as some nice regex prototyping tools.
Very few tools in the computing business are as old as regex or as cross-platform, and yet in the domain of text processing virtually nothing exceeds regex's power. It would, then, be a terrible shame if you didn't have some familiarity with this old friend. In short, attend this session because Mark "sed" so!
Now and then, I get the itch to find something that's been around FOREVER, that everyone really, really OUGHT to know -- and they know it, back in that awful "stuff I really should learn one of these days" list we all have -- and make it useful and understandable.
Learn to write award winning advanced functions and script modules in PowerShell using the industry’s best practices from a former winner of the advanced category in the scripting games without having to sift through 10 years’ worth of outdated content on the Internet.
Transitioning from writing PowerShell one-liners and basic scripts to creating reusable PowerShell tools with advanced functions and script modules can be a daunting task and with all the different ways that you’ll find on the Internet to accomplish the same task, it can definitely seem overwhelming. During this session, we’ll demystify many of the intricacies of toolmaking while demonstrating the best practices for using parameters, parameter validation, cmdlet binding, supports should process, pipeline input, error handling, module manifests, and custom formatting.
Who better to learn how to write PowerShell functions and script modules from than a former winner of the advanced category in the scripting games and a multiyear recipient of both Microsoft’s MVP and SAPIEN Technologies MVP award. During this session, I’ll share my secrets for writing PowerShell advanced functions along with the lessons I’ve learned from the hundreds of tips and tricks that I receive via code reviews by the 600,000+ readers of my blog site each year.
Trying to figure out how to deploy your own custom Azure templates can be a challenge. This session gives you the fundamentals in creating Azure RM Templates to deploy IaaS environments.
Trying to figure out how to deploy your own custom Azure templates can be a challenge. In this session, Cloud and Datacenter Management MVP Will Anderson walks you through:
How Azure Resource Manager templates work.
Understanding basic JSON logical constructs to give your templates flexibility.
What tools you can use to assist in validating your construct before deployment.
You've written PowerShell scripts or functions, and maybe packaged them up in a module. Then suddenly, when you least expect it, it shows up. It's red, and it's scary. You've hit a bug. But fear not! You, too, can become a PowerShell Debugging Ninja! Come to this session to learn how! Hi-yaaaaaaaah!
You will learn:
1. "Soft" debugging skills that reduce or eliminate the need to work with a PowerShell debugger when it's not necessary.
2. "Hard" debugging skills that will help you get the most value for the least effort when working with the PowerShell debugger.
3. Best practices and tips and tricks that increase reliability and efficiency when writing and debugging PowerShell scripts and modules.
Powershell is quickly taking over the IT world. With the new releases of PowerShell being platform agnostic you can now build Apps that can manage ANYTHING and run ANYWHERE! Combining PowerShell with open source web platforms allows you to build custom Apps to manage heterogeneous infrastructures.
There is no ‘out of the box’ perfect solution available on the market today that can help you manage your infrastructure your way. It costs too much, it's too complex, there is no way to customize it... we can always find things wrong, or have a better way of doing things... it's human nature. So, I say put your money where your mouth is, and build one yourself! You know your requirements better than anyone else! And, if you know PowerShell you are in luck! Let's continue this journey together.
I have worked with many tools in the past, and they have never been quite right. I’ve always wanted more information, and extra button, remove some piece of data that I didn't care about, but the problem is that I didn’t understand the language it was written in, or didn’t have access to the source code. So I quit. I quit waiting for someone to do what I needed done, and I started building PowerShell applications to help manage my Information systems.
The concept is simple, use powershell to collect data to be stored in a central location, a lightweight web application to display the data, and some business logic to apply relevant changes to the specific environments. The individual components break down into manageable pieces to include; A Queue Manager, Task Manager, Database, Web Application, and a Management service. A Task Manager can be deployed into any environment and is the workhorse of the application. It communicates with the database to input data and to get data to perform the specific workflows you have designed. All log files and related artifacts are securely stored on a CIFS share available for viewing in the User Interface.
With great success, comes more challenges! Having this great distributed system was great when starting, but quickly became a pain to manage! Manually updating scripts on VM’s halfway across the world is not fun, so I wrote a management service to keep all of my systems in sync. Runtime environments needed to be managed as well as source control on the executable files. Insert Docker to resolve the runtime environment, it’s a bit overkill, but does a fantastic job at creating an exact, repeatable workspace to execute scripts.
What other product will let you build and manage your complex environment of on premise, and cloud infrastructure across product lines like VMware, Active Directory, custom REST API’s, security scanning tools, and more?
In this talk I plan to break down all of the components that are used to construct a scaleable PowerShell application, as well as describe their roles. I will review some of the problems I have encountered as I have built my custom solution for my environment, as well as lead the audience to a path where they can get started. My hope is to have an engaging audience so we can discuss the importance of the CI/CD pipeline when managing this type of system, as well as the risks of introducing this level of automation into their environment.
In Game of Thrones’ current season, humans battle for control of the Seven Kingdoms, yet they may end up banding together against “The Others”. How does this relate to PowerShell? If you love DSC, but want to look at DSC’s integration with other config management tools, then this session is for you.
You know me as “thedevopsdiva”, or maybe you know me as the co-author of the DSC Book. In any case, you know that I have a penchant for using DSC for configuration management. In this session, you will learn some basics about terminology used in other configuration management tools, such as Chef, Puppet, and Ansible. You will learn the similarities and differences between the DSC platform and these other tools, and I’ll explore the transition between pure DSC and “the others” using DSC for configuration management.
DSC is typically node specific. This talk explores a case example where both standard and custom DSC resources will be leveraged to break out of managing many MOF files or partial DSC configurations. One MOF in Azure can be used to dynamically configure all devices throughout your environment.
Desired State Configuration (DSC) is a powerful DevOps tool enabling you to provide a consistent, standardized configuration throughout your environment. On its own DSC has a narrow focus on individual target nodes requiring you to author many Management Object Format (MOF) files, or get creative with partial DSC configurations. This talk aims to strip back some of the mystery of DSC and explore a case example where we’ll leverage both standard and custom DSC resources to create one “smart” MOF capable of dynamically evaluating devices throughout your environment, and configuring them appropriately. We’ll tie all of this into Azure Automation to show you how you can leverage its capability to rapidly create new devices and ensure their standardization moving forward.
This talk will cover a project to write a set of cmdlets for an Infoblox dns appliance. Code is split between cmdlets for the interface and parameter validation, and classes for modeling all the REST calls. Will also cover the CD pipeline via appveyor with tests against an Azure appliance.
Classes, the new feature in PowerShell 5.0, was added just for writing DSC resources right? Not so! Come see how classes can be used as part of a PowerShell cmdlet, providing code separation, easier parameter validation, and more. This session will cover a working module that uses class definitions alongside standard PowerShell cmdlets to integrate with a REST API. Learn how using defined classes makes integration between get and set cmdlets easier and potentially safer. It will also cover the release pipeline for testing and deployment, with a little Azure Resource Manager template design thrown in for fun. All code for this session will be available on GitHub.
This session will cover:
- How to build a REST Uri and payload from user-provided parameter values
- How to model objects and build class definitions and methods to reflect actions on those objects
- How to build cmdlets that interface with both the user and the class definitions, isolating code for improved readability
- How to build a test environment in Azure for running Pester tests and deploy to the PS Gallery with Appveyor
This has been an amazing side project that I've been working on for over a year. I've learned a ton about classes, github, appveyor, azure, etc. and I'm eager to share all that. Current project code can be found here: github.com/murrahjm/Infoblox-Classy
In PowerShell Core we can use OpenSSH as the transport layer to carry our remoting sessions between our systems. In this session we’ll look at OpenSSH architecture, Authentication methods, including key authentication, sshd configuration, and troubleshooting methods when things go wrong!
In this session we’ll cover the following:
- OpenSSH Architecture
- Authentication methods
- Key based authentication
- sshd Configuration
- Troubleshooting OpenSSH
One of PowerShell's greatest strengths is its ability to glue pretty much any technologies together. We'll use that strength to pull data from a number of services, connecting the resulting dots with a graph database that could be used as a lightweight CMDB.
We'll talk about:
* Different interfaces PowerShell can use, from modules to .NET libraries
* Graph databases like Neo4j, and how these can be useful for sysadmins
* A practical (janky) CMDB, and why these can be useful
## Why the topic:
I'm a fan of CMDBs that have useful data. They can drive automation, monitoring and alerting, reporting, and anything else that benefits from visibility.
It just so happens that:
* This is a great way to illustrate the various ways to talk to things in PowerShell (modules, web APIs, .NET libraries, binaries, etc.)
* Graph databases are awesome, and map to real life systems more easily than the cumbersome fun of primary keys, foreign keys, and strict schemas
* Neo4j has a free, cross platform community edition, and there's a simple PowerShell module to work with it
* We can instill other important lessons, e.g. modules/abstraction, community/sharing
* We can provide a practical example that folks without a reasonable CMDB could borrow and extend
* Heavy weight, expensive, actual CMDBs are a poor fit for shops adopting DevOps practices and principles
Classes are a powerful capability in PowerShell and are meant to provide a more familiar developing experience to more traditional programmers. You will not experience calm skies and quiet seas though. This talk will show you where the dragons lurk and help you navigate the stormy seas.
Classes were introduced in PowerShell 5 and mainly to aid in writing DSC resources but can be used with non-DSC modules as well. This talk will go over some of the hidden gotchas when developing with classes including:
* Importing issues
* Verbose / Debug oddities
* Sharing classes between modules
I've developed and released a large PowerShell project (PoshBot) that primarily consists of PowerShell classes. While I could have written the module using traditional functions and cmdlets, I wanted an excuse to try classes out on a new project. Using classes was not a smooth experience and I want to share some of my challenges.
PowerShell Team: PowerShell Core
We see a lot talks on testing PowerShell with Pester, but are the tests we write good tests? What makes a test "good"? How do we measure how effective our tests are? This talk will help you answer these questions, including why testing is important and how to apply these principles to your project.
Learn how attackers are using PowerShell and how to defend against those attacks.
PowerShell Core is about choice and the transport layer for remoting is one of those choices. In this session we’ll look at remoting in Multiplatform environments, configuring both OpenSSH and WinRM based remoting and how we can leverage remoting to really scale up our administrative capabilities.
Even though there is an abundance of DSC resources, there is always room for more. Perhaps there is some Windows feature or setting that hasn't been covered yet. Or you have a home-grown application that needs a resource. In this demo-heavy session you will learn everything you need to know about designing and deploying a DSC resource. We'll start with the legacy DSC resource model and finish with a modern, high-quality DSC resource. Lots of code, best practices and demos abound.
In this fast paced “how-to” presentation, Let Jason Helmick take you the creation and implementation of JEA endpoints for secured administration and help you reduce the number of admins with excessive privilege. You will also learn how to gradually and safely implement JEA based on best practices.
PlatyPS solves a long standing pain of writing PowerShell external help xmls. Now you can write help in markdown and verify that it reflects the code. PlatyPS brings modern markdown-based workflows to the PowerShell help authoring. We will take a deep dive in the PowerShell help engine and platyPS.
PlatyPS solves a long standing pain of writing PowerShell external help xmls.It provides a way to
* Write PowerShell External Help in Markdown
* Generate markdown help for your existing modules
* Keep markdown help up-to-date with your code
* Generate help artifacts (maml xmls and online help archives) from markdown and ship them with your modules
Traditionally PowerShell external help files have been authored by hand or using complex tool chains and rendered as MAML XML for use as console help.
MAML is cumbersome to edit by hand, and common tools and editors don't provide good support for working with it.
Markdown is a very easy markup language which became a standard for writing documentation.
We will take a look at existing big projects that are using it (like Azure and PowerShell-Docs) and some smaller projects (like PSReadLine). We will go through a (very easy!) bootstrap process for using platyPS in an existing project. We will also cover how to make sure that documentation is up to date and even add tests to your CI pipeline to make sure that documentation is always updated.
In the second part of the talk, we will take a deep dive into platyPS internals. We will talk about markdown schema, quirks of PowerShell help engine and tool limitations. We will also cover advanced topics, like combining few different versions of your module help into a single markdown document.
Every part of the talk will be accompanied by hands on live demos.
Raspberry Pis, Windows IoT, dot net core, scripted TCP solutions, this session has it all! Learn how set up a TCP server using pure PowerShell on your favorite credit-card sized computer.
DSC has been letting you down, not delivering on the Cattle vs Pet, and making it hard to scale and manage? The Lack of tooling forces you to consider other solutions such as Chef and Puppet? Attend this session to discover an opinionated approach to building DSC Configuration, with Tools!
With a handful of techniques tucked away in your tool belt your PowerShell code will be running faster than ever. Buckle up for a demo heavy session that can’t drop below 50 mph. When every second counts, you can’t sit around waiting for your script to finish.
Asking for a specific data type as input can be very unintuitive and limiting for the user. Accepting anything and parsing in script however is hard to maintain. Enter Parameter Classes, introducing a flexible data adapter that can dynamically convert input as part of the parameter binding process.
In this session you will learn about the basics of Pester, and most importantly how to get started. My personal experience on how I got started will be discussed as well as my demonstrations of how to write tests as I progress through simple examples to more "real life" Pester tests.
Jenkins is a tool that have multiple uses but this talk will aim to show and explain how to build a pipeline in Jenkins to run a pester and script analyzer checks on a container
Orchestrating Tasks across Hybrid Environments using PowerShell and Python
When you don't have expensive deployment tools PowerShell can be used as a down and dirty way to automating OS deployments. We will explore creating a PowerShell enabled WinPE image and the ins and outs of the WindowsImageTools module
Giving developers control of application provisioning through Desired State Configuration and Octopus Deploy. Learn how a DevOps team created a solution that gave developers control over their application provisioning by defining a json document. This talk will demonstrate how to use an opensource PowerShell module InvokeDSC with Octopus Deploy to create such a solution.
As automators, there are many benefits to be gained by utilizing a build/release pipeline outside of the dev team. Join me as I show you just a few of the possibilities these powerful tools provide us
Giving everyone, local administrator or domain administrator privileges is a really bad idea. Even the best of admins makes mistakes which can have unexpected consequences. With JEA we can truly follow the model of least privilege access giving admins the rights they need to do their job.
No matter how big or small your environment is, giving every administrator unnecessary elevated privileges can result in data loss, or theft due to mistakes or rogue administration. Now with Just Enough Administration (JEA) we can truly follow the model of least privilege access and give admins, helpdesk technicians, developers (the list goes on) the rights they need to do their job, without bugging you, but still maintaining security best practices.
We will not only go over how to configure JEA but will also show you how to properly configure and deploy it to an already existing infrastructure (without using DSC) but using remote PowerShell commands and GPO’s
This session helps SharePoint admins understand the "Dev" in DevOps & understand the CD approach & give them practical guidance they can implement immediately.
Cloud and Datacenter Management MVP Will Anderson takes you through configuring Microsoft's Operations Management Suite alerts to trigger Azure Automation runbooks to remediate issues in your environment.
Got DSC resources? Regardless of your answer, if you're interested in creating DSC resources, this is the session for you! Learn how to create a MOF based DSC resource and then recreate it as a Class based DSC resource along with learning what the pros and cons are for each of these options.
PowerShell Team: Inventory Your Server Environment and Detect Change at Scale
PowerShell makes it ridiculously easy to work with data in any number of formats. You can import a CSV file and export it back out as JSON with a single command. But should you? What is the best data format and what are some of the gotchas? This session will provide plenty of demonstrations showing you how to effectively use different data formats in your PowerShell scripting
When creating a fully-automated Active Directory Certificate Services deployment many people hit the roadblock of creating a custom template, like the one for DSC credential encryption or the CMS cmdlets. Let's smash through that roadblock with PowerShell!
PowerShell Team: Manage Your Server Updates with Minimal Administrative Overhead
Learn how to write and manage complex DSC configurations. Make them reusable and bullet proof with advanced techniques in hierarchical configuration data. Transform the data structure into an easy to edit database.
Introducing Jenkins, your open source automation server/butler. Learn how to create a complete CI pipeline using Jenkins jobs. Watch as a commit to your DSC GIT repository triggers a run of Pester unit tests, a sandbox environment build as an integration test, and then cleans up the mess.
PSScriptAnalyzer is great. You use it to check all your code to make sure it follows PowerShell best practices, right? In this session, I'll show you how to take your PSScriptAnalyzer skills to the next level by showing you how to write your own custom rules, and make PSSA check your code for them.
Data in, data out, right? PowerShell has a wealth of features that help to shape the inputs and outputs we use. But, what happens when we pull the trigger on a mass change and we forgot a key detail? Brad Sterkenburg discusses how we fail fast, but also fail well, all while we keep moving forward.
Build a web interface for any PowerShell script in 60 seconds. WebJEA parses the script for description, parameters, and validation, and then dynamically builds a form to take input and display formatted output. Control access with AD groups and deliver self-service fast.
Have you ever dreamed of writing a script so advanced it can make backups of itself, completely transform to its environment, or even code by itself in a different language? If so you've come to the right place, in this talk we will be discussing Meta Programming and how to do it with PowerShell.
When creating your PS modules, have you ever wondered what to do with the binary bits so they donâ€™t clog up your Git repo? In this demo, learn how to create a CI/CD build in VSTS by taking advantage of VSTS package management to store binaries outside Git and to act as your own private PS Gallery.
Eat your vegetables, floss, and write unit tests for your code. Sure, you should, but where do you start? What's too much, or not enough? Let's go through some existing code step by step, build the tests, and call out the decisions along the way.
Creating a Domain Specific Language can often address specific problem domains better then generic coding or scripting alone. Join me as I break down what it takes to create a DSL in Powershell and show you how to approach common design patterns
You've all used scripblocks but have you stopped to think about what they are and what they do. In this session we'll dive into the depths of script blocks - what they are; what they do and what other things you can accomplish with them. At the end of the demo heavy session you'll have a better appreciation of this part of PowerShell and more tools in your PowerShell tool box.
This session will be a deep dive into the steps necessary to develop, package and distribute a cross platform binary PowerShell module that runs on Windows PowerShell and PowerShell Core.
PowerShell Team: Using PowerShell From a Browser to Manage Cloud Resources
Security and availability are good defensive reasons to curate public packages into a private repository, but there are many positive reasons as well! We will cover the benefits of a dedicated, private repository, as well as enabling secure, global reach and an analysis of repository options.
Chat is not where you put cat gifs anymore. This talk will detail the social and technical benefits of adopting ChatOps in your organization using PoshBot, a PowerShell-based bot framework. Provide more value to your business and put your conversations to work using PowerShell.
Find out how you can (and should) treat your documentation as UX. Mike Lombardi will walk you through continuous integration and delivery of the three types (and many forms) of docs and show you tools and real-world examples while helping you improve the experience of people using your modules.
This will be a tour like session showing PowerShell Core in both Windows and Linux. Also, at the same time working with Windows 10 Bash bring examples of PowerShell Core cross-platform.
Have you often sat staring off at all the other languages having fun scaffolding their projects with tools like Yeoman, dotnet CLI, or Visual Studio wishing you had something that cool in PowerShell? Wait no longer! With Plaster you can scaffold scripts, functions modules, anything!!!
PowerShell Team: Managing Server State using Configuration as Code