MiniCon 2023

PSConfEU MiniCon 2023 - Designing Beautiful APIs with Azure PowerShell Functions - Chrissy LeMaire

In this episode, we delve into the world of API design, exploring its beauty and value. The main speaker begins by expressing their excitement about AI and how it has ...clicked for them when they started using GPT-4. They discuss the importance of APIs, both in web structure and PowerShell, and break down the benefits of building an API, such as increased functionality and scalability. They introduce Azure PowerShell functions as a way to build an API using existing PowerShell skills, explaining the key components and providing examples. The main speaker then explores the structure and naming conventions of APIs, emphasizing best practices and principles. They touch on safety considerations and the use of HTTP methods in API development. The main speaker also discusses documentation tools for APIs, highlighting Azure API Management as their preferred choice. Moving on to the demo, they explain the creation and structure of an API using Azure functions, as well as the use of dev containers and workflows in GitHub. They discuss testing functions with Pester and the importance of file organization and the gitignore file. The main speaker touches on the host.json and local.settings.json files, as well as the configuration of profiles for handling confirmations and exceptions. They cover managing required modules and dive into API routes, mentioning the use of API gateways and dynamic route structuring. Throughout the conversation, the main speaker shares insights, personal experiences, and recommendations, including following API expert David Mori and recommending the PowerShell podcast. They also showcase the amusing and impressive capabilities of OpenAI, including a cat that raps and curses. The main speaker concludes by inviting questions and expressing their availability.

Chapters:
00:00:00 PSConfEU 2023 - Designing Beautiful APIs with Azure PowerShell Functions - Chrissy LeMaire
00:00:05 Introduction and Book Deal Announcement
00:02:01 Speaker's Background and Transition to Belgium
00:04:19 Importance of Documentation and Examples in API building
00:06:28 Reasons to Build an API: Expanded Functionality, Scale, Firewall-Friendly
00:09:07 Community Building and Collaboration through APIs
00:11:01 Introduction to Azure PowerShell functions and its benefits
00:15:32 Understanding Azure Function app structure and equivalents in PowerShell
00:17:31 The beauty of API structure and development
00:20:44 Generating IDs in the API for efficiency
00:23:34 Tools for auto-documentation in APIs
00:27:27 Creating Azure Functions on the web and command line
00:29:53 Introduction to VS Code and its important features
00:30:43 Testing Functions with Pester and Docker
00:32:50 Explanation of local.settings.json and PowerShell ENV
00:34:07 Parameters and Output Binding in Coding
00:34:58 Informative Error Handling and Function Setup
00:36:51 Exploring Dynamic Routes in API Gateway
00:37:58 Introduction to a PM's Method on Azure SQL Team
00:40:29 Choosing ID format and options for Spotify APIShow More

PSConfEU MiniCon 2023 - Designing Beautiful APIs with Azure PowerShell Functions - Chrissy LeMaire

In this episode, we delve into the world of API design, exploring its ...

PSConfEU MiniCon 2023 - WinGet and DSC Configuring Windows - Demitrius Nelon

In this episode, I, Demetrius Nealon, a product manager at Microsoft, ...

In this episode, I, Demetrius Nealon, a product manager at Microsoft, discuss the topics of DSC (Desired State Configuration) and Winget. I delve into the challenges faced when setting up ...environments, such as outdated instructions and a lack of expertise. To tackle these issues, we utilize PowerShell's DSC and introduce the WinGit configuration. We explore the YAML format implemented in Winget configuration for enhanced performance and parallel processing.

Moving forward, we provide a hands-on demonstration, starting with showcasing the addition of seconds on the clock, aligning the taskbar, enabling dark mode, and displaying file extensions. We proceed to install Git through the Windows Package Manager and clone the Winget CLI project, utilizing PowerShell DSC commands for automation. I emphasize the availability of scripts and samples for Winget configurations, while also providing an overview of the Windows Sandbox, including customization options and the Windows Sandbox DSC resource.

Throughout the demonstration, we encounter several issues, such as path errors and compatibility challenges with PowerShell 7. However, we assure listeners that efforts are being made to address these problems. We discuss the process of bootstrapping Chocolaty using Winget and delve into the concept of idempotency in DSC resources. Furthermore, I reveal plans to introduce a configuration export feature, enabling users to retrieve configurations for installed packages and Windows settings.

We touch on the integration of Winget with Intune and our collaboration with the Intune team to push configurations to devices. Additionally, we explore the potential for Azure integration and the application of Winget on Windows Server. I provide updates on upcoming features, including comparisons of configurations, and highlight our partnerships with the DSC community.

As the episode draws to a close, I stress the significance of feedback and the importance of deepening partnerships. I offer apologies for any technical difficulties encountered and assure listeners that further assistance is available.

Chapters:
00:00:00 PSConfEU MiniCon - WinGet and DSC Configuring Windows - Demitrius Nelon
00:00:06 Introduction to DSC and Winget at Microsoft
00:03:20 Finding and using PowerShell DSC resources
00:06:05 Introducing assertions for machine state validation
00:08:21 Overview of configurations and future plans
00:09:35 Regular winget command vs PowerShell for system configuration.
00:12:00 Challenges with enabling Windows Sandbox and future vision.
00:15:21 Copying files and executing the bootstrap script in the sandbox.
00:15:58 Setting up Windows Sandbox and logon script
00:16:59 Introduction to the Sandbox and its ephemeral nature
00:19:31 Installing and configuring Git
00:20:01 Setting up PowerShell gallery for the first module trust.
00:22:37 Testing configurations and encouraging more DSC resources.
00:23:43 Introducing the Wingate Query and Issue Tracking System
00:29:45 Request for sample availability and current tool usage
00:32:11 Challenges with conflicting dependencies and compare behavior
00:34:21 Installation of Visual Studio in progress
00:36:57 Azure Integration and AVD Image Templates
00:47:39 Demos and Performance Enhancements
00:49:44 Stable Features and Experimental Releases
00:51:35 Fun with Respawn and Camera Mishap ApologyShow More

PSConfEU MiniCon 2023 - Collaborate through git. Getting started. - Gael Colas

In this part of the conversation, I explain the process of ...

In this part of the conversation, I explain the process of incorporating changes from one branch into another using the "pull" command. By default, Git adds the changes after our ...own commits. However, if we configure the "pull" command to use rebase, it sets aside our commits, pulls the changes, and then re-applies our commits at the end. This ensures that only our changes are left.

I emphasize the importance of everyone working on the project having a local copy and sharing their changes against a remote repository, such as GitHub. We protect the main branch by not allowing direct pushes and instead require pull requests. This approach ensures knowledge sharing and understanding of the changes being made.

When someone else has made changes to the main branch that we do not have in our local branch, we use the "pull rebase" command to incorporate those changes. This sets aside our recent commits, pulls the missing commits, and then re-applies our changes onto our branch. However, since the commit IDs will not be the same, we need to force push our branch to the remote repository. This can be done using the "push force" command, or preferably "push force with lease" to avoid overwriting other changes made by colleagues.

Once our branch is up to date with the main branch, we can create a pull request to merge our changes into the main branch. This pull request will only include the difference between the two commits we made on our branch.

Chapters:
00:00:00 PSConfEU MiniCon 2023 - Collaborate through git. Getting started. - Gael Colas
00:00:14 Introduction and Overview of the Event
00:03:32 Challenges in Team Alignment and Collaboration with Git
00:08:51 Different History and the Problem of Merging
00:11:05 Challenges of Using Branches for Releases
00:17:50 Explaining the process of rebasing and setting aside work
00:18:42 Introduction to the Builtiverse and Change Event Timeline
00:20:11 Changes Made on Merge to Main
00:20:31 Git pull and Git pull rebase origin main explained
00:22:47 Force versus force with lease when pushing changes
00:25:42 Confusion with Git and the "Z" Key
00:27:07 Technical Difficulties with Screen Sharing
00:27:32 Understanding the Concept of Timelines and Branching
00:29:35 Merging Branches: The Tricky Mix and the Importance of Rebasing
00:31:21 Configuring Git Pull for Branch Changes
00:32:45 Making changes and pushing to remote GitHub
00:34:44 Pull rebase and force push for adding commitsShow More

PSConfEU MiniCon 2023 - From PowerShellGet to PSResourceGet: the breaking changes - Sydney Smith

Hello everyone, in today's session, we discussed the differences and ...

Hello everyone, in today's session, we discussed the differences and breaking changes in PS Resource Get and PowerShell Get. We started by introducing PS Resource Get, which is a rewrite ...of PowerShell Get and allows you to interact with the PowerShell gallery and other repositories. We explained that PowerShell Get v3 is now known as PS Resource Get and still exists as a compatibility layer.

We then delved into the breaking changes in PowerShell Get and PS Resource Get. One major change is the new module name, which is now "Install PS Resource" instead of "Install Module". We also made changes to the version parameter, combining minimum, maximum, and required versions into a single version string. We added a temporary path parameter and a Trust Repository switch for specifying repository trust. The "Allow Clobber" command was changed to "No Clobber" for module installations, and we introduced the option to skip dependency checks during installation.

Furthermore, we expanded repository support to include various repositories such as NuGet.org, NuGet.Server feeds, Azure Artifact v2 and v3, GitHub packages, Artifactory v2 and v3 feeds, mygit.org, and file share base repositories. We also introduced credential persistence, which allows users to specify credentials at registration time for the PS repository. This feature is integrated with the secret management module.

Moving on, we discussed some potential additions and changes in PowerShell 7.5, including credential persistence and required resources and required resource file support. We provided an example of what the hash table for required resources looks like and addressed questions and concerns from the chat.

We then talked about the transition from PowerShell Get to PS Resource Get, comparing the commandlet interfaces and demonstrating how to register different repository types. We also highlighted comprehensive documentation and a blog post that cover these topics in detail.

In the next part of the lecture, we discussed the PowerShell Gallery and psResourceRepository. We explained the properties that need to be specified when registering a repository, such as name, URI, and trust status. We introduced the concept of repository priorities and demonstrated how they work. We also talked about credential info and how it can be specified at registration time.

We briefly touched on the Microsoft PowerShell Secret Management module, which is dependent on credential persistence and provides a simple way to access secrets from different secret vaults. We mentioned the AZ Key Vault and Secret Store as examples of secret vaults.

Lastly, we demonstrated how to use Azure Key Vault to store credentials and access them for authentication. We also discussed the ability to save PS resource in a specific location using the "save PS resource" command and introduced the use of required resource files. We explained that these files allow for trusting specific installations without trusting the entire gallery. We concluded by mentioning the changes in package versioning and opening the floor for questions from the audience.

Chapters:
00:00:00 Introductions and session overview
00:02:32 Features and tabs in the PowerShell gallery for PS Resource Get
00:05:14 Transition from PowerShell Get v3 to PS Resource Get
00:08:01 Introduction to Breaking Changes and Module Name Change
00:10:20 Niche Parameters and Trust Repository Switch
00:14:19 Breaking Changes and Expanded Repository Support
00:15:08 Expanded Support for Various Repository Types
00:16:56 Required Resources and Required Resource File Support
00:18:42 Challenges with V3 and New Get Gallery Dependencies
00:19:49 Introduction to PowerShell module and command interface
00:22:41 Recommended blog post for detailed information and references
00:25:20 Examining properties of PSResourceRepositories and priorities
00:27:15 Module Registration and Muscle Memory Issues
00:28:30 Introduction to PowerShell Gantt and insta…Show More

PSConfEU MiniCon 2023 - DSCv3: Derusting the platform - Steve Lee

In this episode, I, Steve Lee, the Engineer Manager for PowerShell, ...

In this episode, I, Steve Lee, the Engineer Manager for PowerShell, OpenSSH on Windows, DSC, and other things, discuss the latest updates and future of Desired State Configuration (DSC) V3. ...I assume that the listeners have some experience with DSC, so I won't delve into the basics. DSC focuses on the resources side, making it easier to write resources while also supporting existing PowerShell script and class-based resources. We are transitioning from using MOF to using ARM templates, which allows for leveraging existing tooling. DSC is designed to be cross-platform, and I give a demo on my MacBook Pro. However, it's important to note that DSC is still in the alpha phase and not intended for production use. We work closely with partners within Microsoft, such as Azure machine config and Winget, to utilize DSC v3. Our roadmap includes reaching beta by the end of Q1 and aiming for general availability by mid-2024. Mikey is recognized for his excellent work in documenting V3 and improving the change log. We discuss different sections of the "get set and test" process, focusing on the new feature for input with tap completion options. We cover environmental variable input and its implementation in the example YAML file. We also mention the change from DSCv2 to DSCv3 in terms of the "underscore exists" property and touch on the "brew" resource and the "get UI" tool. We conclude with the discussion on the transition to correct versions for future releases, showcasing examples and explaining their states and uninstallation. I also explain the script structure and its usage in running commands, as well as the benefits of using YAML over JSON. We discuss the switch from DCX to Rust, the upcoming PR implementing expressions in ARM templates, and the PR optimizing PowerShell discovery. We call for action, urging users to provide feedback on the DC resource authoring side. We invite users to engage in resource development, explore configuration challenges, and suggest improvements. We are actively developing the project, with a beta version planned for the end of March or Q1 of the next year. We welcome comments and suggestions on GitHub and emphasize that we are working in collaboration with Ansible, Chef, and Puppet rather than competing with them. We acknowledge the challenges of collaboration in the DMTF and appreciate the effort put into documenting JSON schemas. For further inquiries, reach out to us on Twitter or open issues on GitHub. Thank you for attending this episode.

Chapters:
00:00:00 PSConfEU MiniCon 2023 - DSCv3: Derusting the platform - Steve Lee
00:00:21 Introducing PowerShell Engineer Manager and today's focus
00:02:42 Moving away from MOF to ARM for configuration syntax
00:03:28 Cross-platform Development with DEC
00:07:04 Working with Partners and Roadmap for the Future
00:13:51 Introduction to Sections for Get, Set, and Test
00:16:03 Setting Environment Variables for the New Process
00:19:12 Dependency on Assertion Group for OS Compatibility
00:20:43 Setting up the correct versions for future releases
00:26:11 Setting the environment for package management
00:28:33 Handling set command and installing/uninstalling packages
00:32:22 Developing Assertion Resources
00:34:52 DSC Written in Rust for Cross-Platform Accessibility
00:41:34 Introducing the current state of DCV
00:44:58 Call-to-Action: Join the Discussion on Design Elements
00:45:53 Introduction and Overview of the Project
00:47:00 Open for Questions and Discussions
00:47:20 DSC's Goal: Collaboration with Azure and Integration with Partners
00:47:45 DCv3: Writing Resources for VersatilityShow More

MiniCon 2023

PSConfEU MiniCon 2023 - Designing Beautiful APIs with Azure PowerShell Functions - Chrissy LeMaire

Contact info

Additional links