CI/CD

Ryan Dahlberg

## 1. Azure AD Admin Center

The Azure AD Admin Center is the primary interface for managing Azure Active Directory and related tasks. To check your active migrations:

1.  Navigate to the [Azure AD Admin Center]().

2.  Go to **Azure Active Directory** > **Azure AD Connect**.

    *   Here, you can view ongoing syncs or migrations associated with Azure AD Connect.

## 2. Azure AD Connect Health

Azure AD Connect Health provides deeper insights into the health and status of your directory synchronization and migrations:

1.  Open the Azure AD Admin Center.

2.  Navigate to **Azure Active Directory** > **Azure AD Connect** > **Azure AD Connect Health**.

    *   This dashboard highlights the health and performance of directory synchronization, including any issues that might be impacting active migrations.

## 3. Microsoft 365 Admin Center

If your migration involves Microsoft 365 services, such as Exchange or SharePoint, you can use the Microsoft 365 Admin Center:

1.  Access the [Microsoft 365 Admin Center](https://admin.microsoft.com/).

2.  Go to **Setup** > **Data migration**.

    *   Here, you can see and manage migrations for services like Exchange, SharePoint, or OneDrive.

## 4. PowerShell

PowerShell offers a flexible way to monitor Azure AD migrations programmatically. Useful cmdlets include:

*   `Get-MsolUser` – Retrieve user details.

*   `Get-AzureADUser` – View user objects in Azure AD.

*   `Get-MsolDirSyncProvisioningError` – Identify provisioning errors related to directory synchronization.

### Example:

Run the following cmdlet to list directory synchronization errors:

```
Get-MsolDirSyncProvisioningError
```

This command helps identify issues that may be hindering your migration.

## Conclusion

Monitoring active Azure Active Directory migrations is essential for ensuring a smooth and efficient transition. By using tools such as the Azure AD Admin Center, Azure AD Connect Health, Microsoft 365 Admin Center, and PowerShell, you can stay informed and resolve issues promptly. Whether you’re managing syncs, migrating services, or troubleshooting errors, these resources provide the visibility and control you need.


Managing Azure Active Directory (AAD) migrations can be a critical task, especially when transitioning or integrating systems. To stay informed and in control of active migrations, you can use several tools and platforms provided by Microsoft. Here’s a detailed guide to finding and monitoring your active Azure AD migrations.

Viewing Active AAD Migrations

Managing synchronization between on-premises Active Directory (AD) and Entra ID (formerly Azure AD) is crucial for ensuring seamless user and group management across your hybrid environment. However, errors can arise, and troubleshooting them requires a systematic approach.

In this guide, we’ll cover common sync issues, their resolutions, and best practices to keep your synchronization process running smoothly.

## **Understanding Synchronization Challenges**

AD Connect is a vital tool that bridges your on-premises AD and Entra ID. However, issues like duplicate attributes, ImmutableID mismatches, or incorrect synchronization rules can disrupt this process. Identifying and resolving these errors quickly is essential to maintaining operational efficiency.

***

## **Common Sync Errors and How to Resolve Them**

### **1. Duplicate Attribute Errors**

Duplicate attributes can occur when multiple objects in AD have the same unique value (e.g., a UPN). These conflicts prevent successful synchronization.

**Resolution:**

1.  Use PowerShell to identify duplicates:
    ```powershell
    Get-ADObject -Filter {Attribute -eq "duplicate_value"} -Properties Attribute
    ```
2.  Adjust or remove duplicate values in AD.
3.  Trigger a delta sync:
    ```powershell
    Start-ADSyncSyncCycle -PolicyType Delta
    ```

***

### **2. ImmutableID Mismatch**

ImmutableID mismatches arise when an on-premises ObjectGUID does not align with the corresponding ImmutableID in Entra ID.

**Resolution:**

1.  Retrieve affected user details in Entra ID:
    ```powershell
    Get-AzureADUser -Filter "UserPrincipalName eq 'user@domain.com'" | Select-Object ObjectId, ImmutableId
    ```
2.  Clear and reset the ImmutableID:
    ```powershell
    Set-MsolUser -UserPrincipalName user@domain.com -ImmutableId "$null"
    Set-MsolUser -UserPrincipalName user@domain.com -ImmutableId [Base64 ObjectGUID]
    ```
3.  Re-run a delta sync:
    ```powershell
    Start-ADSyncSyncCycle -PolicyType Delta
    ```

***

### **3. Object Type Mismatch**

When an object in AD is incorrectly matched with a different object type in Entra ID, synchronization errors occur.

**Resolution:**

1.  Identify the mismatched object using:
    ```powershell
    Get-ADUser -Identity samAccountName
    Get-AzureADUser -ObjectId "AzureADObjectID"
    ```
2.  Correct the object type in AD or remove the incorrect object.
3.  Re-sync the directory.

***

## **Proactive Troubleshooting Steps**

While resolving specific errors is important, proactive management of your synchronization process can prevent issues from arising.

### **1. Check AD Connect Health**

*   Open the Synchronization Service Manager on the AD Connect server.
*   Review the status of recent sync cycles and logs for any errors.

### **2. Verify Synchronization Rules**

*   Use the Synchronization Rules Editor to ensure correct rules are applied for users, groups, and other object types.

### **3. Monitor Event Logs**

*   Review logs under "Applications and Services Logs > Directory Synchronization" in Event Viewer for warning signs.

***

## **PowerShell to the Rescue**

Here are a few key PowerShell commands to streamline your troubleshooting process:

*   **Force Full Synchronization:**
    ```powershell
    Start-ADSyncSyncCycle -PolicyType Initial
    ```

*   **Sync a Specific User:**
    ```powershell
    Start-ADSyncSyncCycle -PolicyType Delta
    ```

*   **Export Sync Errors to CSV:**
    ```powershell
    Get-ADSyncConnectorRunStatus -ConnectorType "Windows Azure Active Directory" | Export-Csv -Path "C:\SyncErrors.csv" -NoTypeInformation
    ```

***

## **Best Practices for Sync Management**

1.  **Maintain Proper Documentation:**\
    Keep logs of changes to AD Connect configurations, synchronization rules, and any troubleshooting actions.

2.  **Schedule Regular Health Checks:**\
    Periodically monitor synchronization status using the AD Connect Health tool to identify potential issues early.

3.  **Train Your Team:**\
    Ensure all system administrators are familiar with common errors and their resolutions.

***

## **Wrapping Up**

Synchronization between AD and Entra ID is a cornerstone of hybrid identity management. By understanding common errors and following best practices, you can minimize disruptions and maintain a reliable environment.


Learn how to troubleshoot and resolve common synchronization errors between on-premises Active Directory and Entra ID with practical tips, PowerShell scripts, and best practices.

Troubleshooting Sync Errors Between Active Directory and Entra ID: A Comprehensive Guide

When attempting to use the `wipefs` command to wipe a partition or disk, you might encounter an error like this:

```
wipefs: error: /dev/nvme0n1p1: probing initialization failed: Device or resource busy
```

This error typically indicates that the device or partition is currently in use. This guide will walk you through troubleshooting and resolving the issue.

### Step 1: Check if the Partition is Mounted

A common reason for this error is that the partition is mounted. You can check this with:

```
lsblk
```

If `/dev/nvme0n1p1` is shown as mounted, unmount it using:

```
sudo umount /dev/nvme0n1p1
```

### Step 2: Check for LVM or RAID Usage

The partition might be part of an LVM (Logical Volume Manager) volume group or a RAID array. Verify this with the following commands:

```
sudo lvmdiskscan
sudo pvscan
sudo vgscan
sudo mdadm --detail --scan
```

If the partition is part of an LVM volume group, deactivate it:

```
sudo vgchange -an <volume_group_name>
```

### Step 3: Check for Swap Usage

The partition could be configured as swap space. Disable it with:

```
sudo swapoff /dev/nvme0n1p1
```

### Step 4: Kill Processes Using the Partition

To determine if any processes are using the partition, run:

```
sudo fuser -v /dev/nvme0n1p1
```

If necessary, kill the processes:

```
sudo fuser -k /dev/nvme0n1p1
```

### Step 5: Retry the Wipe

With the partition unmounted and processes terminated, reattempt the `wipefs` command:

```
sudo wipefs --all /dev/nvme0n1
```

### Step 6: Force a Wipe (If Necessary)

If you’re still encountering issues, you can force a wipe by writing zeros to the start of the disk. Be cautious, as this will irreversibly erase all data on the device:

```
sudo dd if=/dev/zero of=/dev/nvme0n1 bs=1M count=100
```

After completing this step, run `wipefs` again to clean up any remaining filesystem signatures:

```
sudo wipefs --all /dev/nvme0n1
```

### Conclusion

By following these steps, you should be able to resolve the "Device or resource busy" error and successfully wipe your NVMe drive or partition. Always ensure you understand the implications of each command, especially those that can lead to permanent data loss, like `dd` or `wipefs`. If you’re still experiencing issues, feel free to reach out or consult additional system logs for more information.


Resolving the "Error Wiping '/dev/nvme0n1'" Issue

Wipefs Error Nvme

A style guide for a website is a set of design standards that define the look, feel, and behavior of a digital product, ensuring consistency and cohesion across all pages and elements. It typically includes guidelines for colors, typography, spacing, buttons, icons, and imagery, as well as instructions on voice and tone for content.

# h1 Heading

## h2 Heading

### h3 Heading

#### h4 Heading

##### h5 Heading

###### h6 Heading

## Horizontal Rules

***

## Emphasis

**This is bold text**

**This is bold text**

*This is italic text*

*This is italic text*

~~Strikethrough~~

## Blockquotes

> Blockquotes can also be nested...
>
> > ...by using additional greater-than signs right next to each other...
> >
> > > ...or with spaces between arrows.

## Lists

Unordered

*   Lorem ipsum dolor sit amet
*   Consectetur adipiscing elit
*   Integer molestie lorem at massa

Ordered

1.  Lorem ipsum dolor sit amet
2.  Consectetur adipiscing elit
3.  Integer molestie lorem at massa

## Code

Inline `code`

Block code

```
npm install netlify-cli -g
```

Syntax highlighting

```js
var foo = function (bar) {
  return bar++;
};

console.log(foo(5));
```

## Tables

| Option | Description                                                               |
| ------ | ------------------------------------------------------------------------- |
| data   | path to data files to supply the data that will be passed into templates. |
| engine | engine to be used for processing templates. Handlebars is the default.    |
| ext    | extension to be used for dest files.                                      |

Right aligned columns

| Option |                                                               Description |
| -----: | ------------------------------------------------------------------------: |
|   data | path to data files to supply the data that will be passed into templates. |
| engine |    engine to be used for processing templates. Handlebars is the default. |
|    ext |                                      extension to be used for dest files. |

## Links

*   [Next.js on Netlify](https://docs.netlify.com/frameworks/next-js/overview/)
*   [Use Visual Editor with Next.js](https://docs.netlify.com/visual-editor/frameworks/next/)

## Image

Recommended image orientation is horizontal. You can adjust the image component to your needs in `components/CustomImage.js`.

![Image alt text](/images/random-image.jpeg "Image Title")


A style guide for a website is a set of design standards that define the look, feel, and behavior of a digital product, ensuring consistency and cohesion across all pages and elements.

Next.js Blog Theme Style Guide


**This is an example post. There's another one [here](/posts/example-post-1).**

Combining **Next.js** and **Netlify** offers a powerful solution for building and deploying modern web applications with ease. Next.js, known for its versatility in handling both static and dynamic content, is a favorite for developers who need a React-based framework that supports server-side rendering, static site generation, and API routes—all essential for dynamic, SEO-friendly sites.

Pairing this with Netlify’s streamlined deployment workflow, continuous integration, and serverless functions provides a smooth, fast, and secure development-to-deployment process. Netlify’s built-in features for **automatic deployment** from Git, **CDN distribution**, and **edge functions** mean Next.js apps can scale easily while maintaining high performance.

For UI designers and developers, this combo enables rapid iteration, easier A/B testing, and optimized performance without the DevOps overhead. Plus, the ability to leverage **dynamic routing and API integrations** means more control over design and functionality.

## Additional resources

- [Next.js on Netlify](https://docs.netlify.com/frameworks/next-js/overview/)
- [Use Visual Editor with Next.js](https://docs.netlify.com/visual-editor/frameworks/next/)

Consider that for a moment: everything we see around us is assumed to have had a cause and is contingent upon.

Next.js and Netlify - The Perfect Duo for Modern Web Development


If you're using **Next.js** and **Netlify**, you’re tapping into a powerhouse combination for fast, reliable, and scalable web applications. 

**This is an example post. There's another one [here](/posts/example-post-1).**

Here’s why they work so well together:

1. **Seamless Deployment**: With Netlify’s Git-based deployment, pushing updates to a Next.js site is automatic and effortless. Every change pushed to GitHub or GitLab triggers a fresh build and deploys your site without any manual effort, perfect for fast-paced projects.

2. **Static and Dynamic Content Flexibility**: Next.js shines by allowing both static generation (SSG) and server-side rendering (SSR), and Netlify makes deploying either easy. Static content is globally cached on Netlify’s CDN, making your site lightning-fast, while Netlify Functions handle any server-side needs with zero configuration.

3. **Serverless Functions**: Netlify’s serverless functions work beautifully with Next.js API routes, enabling dynamic features (like forms, authentication, and data fetching) without additional servers. This lets you build interactive, backend-supported sites with just front-end code.

4. **Edge Caching and CDNs**: Next.js’s pages are distributed across Netlify’s global CDN, ensuring that your users get a fast experience no matter where they are. This setup optimizes load times and enhances site performance.

5. **Developer-Friendly Workflow**: Both Next.js and Netlify focus on a developer-friendly experience. Local development, previews, and rollbacks are simple, so you can focus on building a better user experience without worrying about the infrastructure.

For anyone building with Next.js, deploying on Netlify means you get the best of **speed, reliability, and ease**—all the ingredients needed to create high-performing, user-friendly web apps!

## Additional resources

- [Next.js on Netlify](https://docs.netlify.com/frameworks/next-js/overview/)
- [Use Visual Editor with Next.js](https://docs.netlify.com/visual-editor/frameworks/next/)

If you're using Next.js and Netlify, you’re tapping into a powerhouse combination for fast, reliable, and scalable web applications.

Why Next.js Works Great with Netlify


Mental models are frameworks people create in their minds to understand how something should work. They’re the expectations users carry with them when they encounter a new app, website, or product. For example, a user expects that clicking on a logo will take them back to the homepage, or that clicking a shopping cart icon will show them a list of items they’ve added.

Mental models vary from user to user, depending on factors like cultural background, experience level, and personal habits. However, successful designs usually align with widely shared expectations, allowing for intuitive interactions.

This is an example post. There's another one [here](/posts/example-post).


Mental models for designers


In the evolving world of UI design, a tool that has remained a steadfast favorite among designers is [Sketch](https://www.sketch.com/). Since its inception in 2010, Sketch has consistently proven to be a powerful, intuitive, and efficient platform for creating stunning, functional user interfaces. While many competitors have entered the market, Sketch continues to offer unique features that keep it in the toolkits of solo designers and design teams alike. Here’s why Sketch is still the ultimate tool for UI designers.

**This is an example post. There's another one [here](/posts/example-post-1).**

## User-Friendly Interface

Sketch is celebrated for its clean, minimalistic interface that feels welcoming to beginners and intuitive for seasoned designers. Unlike other platforms that may overwhelm with too many options or complex panels, Sketch offers a streamlined workspace that allows designers to focus on what matters: crafting excellent UI.

## Vector-Based Design for Scalability

Vector-based design is essential in UI, where icons and graphics need to scale across various screen sizes. Sketch’s vector capabilities ensure that designs stay sharp and consistent, no matter the device or resolution. Designers can create everything from tiny icons to full-screen mockups without losing image quality.

## Symbols and Reusable Components

One of Sketch’s most beloved features is its Symbols feature, which lets designers create reusable components. This is a game-changer for maintaining consistency across projects, as elements like buttons, icons, and navigation bars can be updated once and reflected throughout the design. The ability to nest Symbols and create overrides adds even more flexibility, enabling designers to craft complex design systems with ease.

## Powerful Plugins and Integrations

Sketch’s extensive plugin library is unmatched, offering tools for everything from animations to code export. Tools like Anima, Stark, and Craft by InVision extend Sketch’s functionality, enabling designers to customize the tool to their workflow. The robust plugin ecosystem allows designers to stay in Sketch while integrating seamlessly with prototyping, developer handoff, and collaboration tools, making Sketch highly adaptable for varied design processes.

## Cloud Collaboration and Sharing

Collaboration is critical in modern design workflows, and Sketch’s Cloud feature makes it easy to share work with clients, teammates, and developers. The ability to upload designs to the cloud allows for real-time feedback and streamlined developer handoff. Sketch Cloud supports commenting, version control, and asset exporting, making remote collaboration a breeze.



While new design platforms continue to emerge, Sketch has held its ground as a go-to for UI designers, offering an impressive mix of simplicity, precision, and power.