Adding Shared Mailbox to Outlook Streamlined Process Guide

Published

add shared mailbox to outlook - Kesimpulan
Table of Contents

Efficiently integrating a shared mailbox into Outlook enhances team collaboration and streamlines communication workflows. Whether managing client accounts, departmental resources, or project-specific inboxes, proper setup ensures seamless access while maintaining security and compliance. This guide provides a structured approach to adding shared mailboxes across Outlook Desktop, Mac, and Web, alongside troubleshooting and automation techniques tailored for administrators and end-users.

Shared mailboxes serve as centralized repositories for collective email management, reducing redundancy and improving response times. However, misconfigurations or permission errors can disrupt productivity. By following systematic steps—from manual addition to PowerShell automation—organizations can optimize shared mailbox functionality while mitigating common pitfalls. The following sections break down procedural workflows, error resolutions, and best practices to ensure a smooth implementation.

Step-by-Step Guide to Adding a Shared Mailbox to Outlook

Adding a shared mailbox to Outlook streamlines collaboration by allowing multiple users to access a centralized email account. This process varies depending on the Outlook version—Desktop (Windows), Mac, or Web (OWA)—and requires appropriate permissions from an Exchange administrator. Below are detailed procedures for each platform, along with a comparative table for clarity.

Manual Method: Adding a Shared Mailbox via Exchange Admin Center (Outlook Desktop - Windows)

To manually add a shared mailbox in Outlook for Windows, users must first ensure they have the necessary permissions (e.g., Full Access or Send As). The Exchange Admin Center (EAC) is the primary tool for assigning these permissions before the mailbox can be accessed in Outlook.

Prerequisites:

  • Administrative access to Exchange Admin Center (for permission assignment).
  • Shared mailbox name and Exchange Server details.
  • Outlook Desktop (Windows) version 2013 or later.

    • Steps:
    1. Assign Permissions via Exchange Admin Center

  • Open a web browser and navigate to the Exchange Admin Center (typically `https:///ecp`).
  • Log in with administrative credentials.
  • Navigate to Recipients > Shared.
  • Select the shared mailbox from the list, then click Edit (pencil icon).
  • Under Mailbox delegation, assign permissions:
  • Full Access: Grants read/write access to emails, calendars, and contacts (common for team mailboxes).
  • Send As: Allows users to send emails as the shared mailbox (requires additional configuration).
  • Click Save to apply changes.

    • 2. Add Shared Mailbox to Outlook Desktop

  • Open Outlook and go to File > Add Account.
  • Select Manually configure server settings or additional server types, then click Next.
  • Choose Exchange and enter the following:
  • Your Name: Display name for the shared mailbox.
  • Email Address: Full email address of the shared mailbox (e.g., `team@domain.com`).
  • User Name: Email address of the user with permissions (e.g., `admin@domain.com`).
  • Click More Settings, then:
  • Under Connection, select Connect to Microsoft Exchange using HTTP.
  • Under Microsoft Exchange Server, enter the Exchange Server address (e.g., `outlook.office365.com` or your on-premises server).
  • Under Use this type of signed-in info, select Username and password.
  • Click OK, then Next.
  • Enter the password for the account with shared mailbox permissions, then click Finish.
  • The shared mailbox will appear in the Account Settings under File > Account Settings.

    • Note: If the shared mailbox does not appear, restart Outlook or check permissions in the EAC.

    Adding a Shared Mailbox in Outlook for Mac

    Outlook for Mac supports shared mailboxes but requires manual configuration via Preferences or Autodiscover. Users must have Full Access or Send As permissions assigned in Exchange.

    Steps:
    1. Open Outlook for Mac and go to the Outlook menu > Preferences.
    2. Select Accounts, then click the + (Add Account) button.
    3. Choose Exchange and enter:

  • Email Address: Shared mailbox address (e.g., `shared@domain.com`).
  • User Name: Email of the user with permissions (e.g., `admin@domain.com`).
  • Password: Password for the account with permissions.
    • 4. Click Sign In.
    5. If prompted, select Configure manually (if Autodiscover fails) and enter:
  • Exchange Server: `outlook.office365.com` (or your on-premises server).
  • User Name: Same as above (e.g., `admin@domain.com`).
    • 6. Click Done to add the account.
    7. The shared mailbox will appear in the Accounts list. To access it:
  • Go to Mailbox > Add Shared Mailbox (if available in your version).
  • Alternatively, the mailbox may appear under On My Computer in the sidebar after syncing.

    • Troubleshooting:

  • If the mailbox doesn’t appear, ensure Full Access is granted in Exchange and restart Outlook.
  • For Send As permissions, additional steps may be required in Exchange (e.g., PowerShell commands).

    • Side-by-Side Comparison: Outlook Desktop vs. Outlook Web (OWA)

    Below is a structured comparison of the steps required to add a shared mailbox across Outlook Desktop (Windows/Mac) and Outlook Web (OWA).
    Action Outlook Desktop (Windows) Outlook for Mac Outlook Web (OWA)
    Permission Assignment
    1. Log in to Exchange Admin Center (EAC).
    2. Go to Recipients > Shared.
    3. Edit mailbox and assign Full Access or Send As.
    1. Same as Windows: Use EAC to assign permissions.
    2. No Mac-specific permission steps.
    1. Permissions must be assigned via EAC or PowerShell.
    2. OWA itself does not assign permissions.
    Adding Shared Mailbox
    1. File > Add Account > Manually configure.
    2. Select Exchange and enter mailbox details.
    3. Use More Settings > Microsoft Exchange Server for manual server entry.
    1. Outlook menu > Preferences > Accounts > Add Account.
    2. Select Exchange and enter credentials.
    3. Mailbox appears under On My Computer after sync.
    1. Open OWA (https://outlook.office.com).
    2. Click Settings (⚙) > View all Outlook settings > Mail > Accounts.
    3. Under Add a mail account, enter shared mailbox email and credentials.
    4. Mailbox appears in the left pane under Other mailboxes.
    Accessing the Mailbox
    1. Mailbox appears in the Account Settings list.
    2. Right-click the mailbox in the folder pane to Open.
    1. Mailbox syncs automatically after addition.
    2. Access via Mailbox > Shared or sidebar.
    1. Mailbox appears under Other mailboxes.
    2. Click to Open and interact with emails/calendar.
    Troubleshooting
    • Restart Outlook if mailbox doesn’t appear.
    • Verify permissions in EAC.
    • Check server address for on-premises setups.
    • Ensure Full Access is granted.
    • Update Outlook to the latest version.
    • Check for Autodiscover errors.
    • Clear browser cache if mailbox doesn’t load.
    • Use Incognito mode to test.
    • Verify

      Troubleshooting Common Errors When Adding a Shared Mailbox to Outlook

      Adding a shared mailbox to Outlook often encounters technical barriers due to misconfigurations, permission issues, or server-side limitations. Errors such as "Mailbox not found" or "Access denied" typically stem from incorrect Exchange permissions, outdated profiles, or connectivity problems. Below are five frequent errors, their root causes, and structured solutions to resolve them efficiently. A permissions verification checklist and error code breakdown are also provided to preempt issues during setup.

      Five Common Errors and Resolutions

      The following errors occur most frequently when attempting to add a shared mailbox to Outlook. Each error is paired with its likely cause, a step-by-step fix, and the tools or commands required for resolution.

      Permissions Verification Checklist for Exchange Server

      Before adding a shared mailbox, ensure the following prerequisites are met to avoid access-related errors. This checklist covers Exchange Admin Center (EAC) and Exchange Management Shell (EMS) validations.

      Importance of Pre-Verification:
      Misconfigured permissions account for 60% of shared mailbox access failures in enterprise environments. Validating roles, mailbox existence, and user permissions upfront reduces downtime during troubleshooting.

      Critical Roles for Shared Mailbox Access:
    • Mailbox Import Export (required for full access).
    • Recipient Management (to modify mailbox properties).
    • View-Only Configuration (for read-only access).
      1. Confirm Mailbox Existence in Exchange Admin Center (EAC):
        Navigate to Recipients > Mailboxes and verify the shared mailbox appears in the list. If missing, it may not have been created or migrated.
      2. Verify User Has ‘Mailbox Import Export’ Role:
        Run the following in Exchange Management Shell:
        Get-RoleGroupMember "Mailbox Import Export" | Where-Object { $_.Name -like "[UserName]" }
        If the user is absent, assign the role with:
        Add-RoleGroupMember "Mailbox Import Export" -Member "[UserName]"
      3. Check Mailbox Full Access Permissions:
        Use EMS to validate permissions:
        Get-MailboxPermission -Identity "[SharedMailbox]" | Where-Object { $_.User -like "[UserName]" -and $_.AccessRights -eq "FullAccess" }
        If permissions are missing, grant them via:
        Add-MailboxPermission -Identity "[SharedMailbox]" -User "[UserName]" -AccessRights FullAccess -InheritanceType All
      4. Validate Autodiscover Configuration:
        Ensure the user’s mailbox server supports Autodiscover. Test with:
        Test-OutlookWebServices -Identity "[UserName]" -MailboxPolicy "[PolicyName]"
      5. Review Proxy Settings for Shared Mailbox:
        Shared mailboxes require a primary SMTP address and proxy addresses configured in EAC. Use:
        Get-Mailbox -Identity "[SharedMailbox]" | Select EmailAddresses

      Detailed Error Code Breakdown and Resolution Commands

      Error codes in Outlook or Exchange Management Shell provide specific clues about underlying issues. Below is a table mapping common codes to their causes and solutions, including EMS commands for remediation.
      Note: Error codes often appear in Outlook’s Send/Receive log or EMS output. Cross-reference with the user’s mail profile and Exchange server status.
      Error Message/Code Likely Cause Recommended Solution Tools/Commands to Use
      0x8004010F ("Mailbox server unavailable") The Exchange server hosting the shared mailbox is offline, overloaded, or misconfigured. May also indicate a database availability group (DAG) issue.
      1. Verify server status via EAC (Servers > Servers).
      2. Check mailbox database health with:
      Get-MailboxDatabaseCopyStatus -Identity "[DatabaseName]" | Where-Object { $_.Status -ne "Mounted" }
      Restart the Microsoft Exchange Mailbox Assistant service on the affected server.
      0x8004011D ("The operation failed. The messaging interface has returned an unknown error.") Corrupted Outlook profile, missing MAPI dependencies, or RPC Client Access service issues.
      1. Repair Outlook profile via Control Panel > Mail > Show Profiles > Properties > Repair.
      2. Reinstall Microsoft Office updates, focusing on MAPI/CDO components.
      Get-Service -Name "MSExchangeRPC" | Restart-Service
      0x80040111 ("Mailbox not found") The shared mailbox does not exist in the Exchange organization, or the user lacks search permissions.
      1. Search for the mailbox in EMS:
      2. Grant Recipient Read permissions if the mailbox exists but is hidden.
      Search-Mailbox -Identity "[SharedMailbox]" -TargetMailbox "[AdminMailbox]" -TargetFolder "RecoverableItems" -LogOnly -LogLevel Full
      Add-RecipientPermission -Identity "[SharedMailbox]" -Trustee "[UserName]" -AccessRights RecipientRead
      0x80040102 ("Access denied") Insufficient Exchange permissions (e.g., missing Full Access or Send As rights).
      1. Use EMS to verify and assign permissions:
      2. Check Active Directory (AD) group memberships for the user.
      Set-Mailbox "[SharedMailbox]" -GrantSendOnBehalfTo "[UserName]"
      Get-ADUser "[UserName]" | Select-Object -ExpandProperty MemberOf
      Profile already exists (Outlook error) A duplicate Outlook profile for the shared mailbox conflicts with the existing one, often due to manual additions or O365 migration.
      1. Remove the duplicate profile via Control Panel > Mail > Show Profiles.
      2. Recreate the profile using the Auto Account Setup in Outlook.
      Remove-OutlookProfile -Name "[DuplicateProfileName]" -ErrorAction SilentlyContinue

      Table of Common Errors, Causes, and Solutions

      Below is a consolidated table for quick reference during troubleshooting. Each row includes the error message, root cause, step-by-step fix, and EMS/command-line tools to resolve the issue.
      Error Message Likely Cause Recommended Solution Tools/Commands to Use
      "Mailbox not found" in Outlook Shared mailbox does not exist in Exchange or user lacks Recipient Read permissions

      Automating Shared Mailbox Addition via PowerShell in Exchange Admin Center

      Automating the deployment of shared mailboxes across multiple users in Outlook reduces manual errors and accelerates administrative workflows. PowerShell scripts in the Exchange Admin Center (EAC) enable administrators to manage permissions, user assignments, and profile configurations at scale. This approach is particularly valuable in large organizations where manual configuration would be impractical. Below are two methods for automating shared mailbox access, along with best practices for secure execution and profile management.

      PowerShell Methods for Shared Mailbox Automation

      Two primary PowerShell approaches exist for assigning shared mailboxes to users: individual permission grants and bulk mailbox-user relationships. Each method serves distinct use cases, depending on whether granular control or mass deployment is required.

      Key considerations for automation include:

    • Method 1 (`Add-MailboxPermission`) is ideal for granting access to a single shared mailbox across multiple users with customizable permission levels.
    • Method 2 (`New-Mailbox` + `Add-MailboxUser`) is optimized for bulk setups where shared mailboxes are created and assigned in a single workflow, ensuring consistency in permissions.

      • Below is a comparative table of the two methods, including code snippets and recommended scenarios.

      Method Code Snippet Use Case Advantages Limitations
      Method 1: Add-MailboxPermission (Individual Grants) 
      $sharedMailbox = "SharedTeam@domain.com"
      
$users = @("user1@domain.com", "user2@domain.com", "user3@domain.com")
      foreach ($user in $users) {
      
    Add-MailboxPermission -Identity $sharedMailbox -User $user -AccessRights FullAccess -InheritanceType All
      
}
      		Assigning a single shared mailbox to multiple users with explicit permission levels (e.g., FullAccess, SendAs).
      • Fine-grained control over individual permissions.
      • Supports conditional logic (e.g., role-based access).
      • Works with existing shared mailboxes.
      • Slower for large user groups due to iterative execution.
      • Requires manual verification of permissions.
      Method 2: New-Mailbox + Add-MailboxUser (Bulk Setup) 
      Create shared mailbox (if new)
      
New-Mailbox -Name "SharedTeam" -OrganizationalUnit "OU=Shared,DC=domain,DC=com" -Shared -PrimarySmtpAddress "SharedTeam@domain.com"
      # Assign users in bulk
      
$users = @("user1@domain.com", "user2@domain.com", "user3@domain.com")
      
foreach ($user in $users) {
      
    Add-MailboxUser -Identity $user -MemberOf "SharedTeam"
      
}
      		Creating new shared mailboxes and assigning users in a single workflow, typically for organizational-wide deployments.
      • Efficient for mass deployments (e.g., department-wide shared inboxes).
      • Ensures consistent permission inheritance.
      • Supports automation in provisioning pipelines.
      • Less flexible for granular permission adjustments post-deployment.
      • Overwrites existing permissions if mailbox exists.

      Exporting and Importing Outlook Profiles for Shared Mailbox Deployment

      In large organizations, deploying shared mailboxes requires synchronizing Outlook profiles across user devices. PowerShell can automate the export and import of Outlook profiles (`.prf` or `.xml` files) to ensure shared mailboxes are pre-configured before user login. This method reduces end-user support requests and ensures consistency.

      Steps for profile automation:
      1. Export profiles from a reference machine using:
      ```powershell
      Export-OutlookProfile -ProfileName "ReferenceProfile" -Path "C:\Profiles\SharedMailboxProfile.prf"
      ```
      2. Deploy profiles via Group Policy, scripted logon, or Intune:
      ```powershell
      Copy-Item -Path "C:\Profiles\SharedMailboxProfile.prf" -Destination "\\Server\Profiles\$env:USERNAME.prf"
      ```
      3. Verify synchronization by checking Outlook’s `Outlook.exe /profile` command or registry entries under `HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Windows Messaging Subsystem\Profiles`.

      Best practices for profile management:

    • Use XML-based profiles for version control and scripted deployment.
    • Store profiles in a centralized network location with access controls.
    • Test profile deployment in a pilot group before full rollout.

      • Security Best Practices for PowerShell Scripting

      Automated scripts handling shared mailbox permissions must adhere to security protocols to prevent unauthorized access or data leaks. Below are critical safeguards for scripting in Exchange environments:
      • Use `-Credential` securely: Store credentials in Secure Strings or Credential Manager and avoid hardcoding passwords.
        Example:
        ```powershell
        $cred = Get-Credential -Message "Enter Exchange Admin Credentials"
        Connect-ExchangeOnline -Credential $cred
        ```
      • Audit script execution: Enable logging with `Start-Transcript` to track actions and errors.
        ```powershell
        Start-Transcript -Path "C:\Logs\MailboxAutomation.log" -Append

        Script execution

        Stop-Transcript
        ```
      • Restrict permissions: Use least-privilege accounts for scripts (e.g., `Organization Management` role for bulk operations).
      • Validate inputs: Sanitize user/mailbox names to prevent injection attacks (e.g., regex validation).
      • Encrypt sensitive data: Use Exchange Online PowerShell v2 with MFA and Azure Key Vault for credential storage.
      • Test in a sandbox: Deploy scripts in a non-production Exchange environment before organization-wide use.
      Additional considerations:
    • Monitor script activity via Exchange Admin Center audit logs or Microsoft Defender for Cloud Apps.
    • Document dependencies (e.g., required modules like `ExchangeOnlineManagement`).
    • Schedule scripts during low-usage periods to minimize impact on mail flow.

      • Configuring Shared Mailbox Settings in Outlook for Optimal Use

      Shared mailboxes in Microsoft 365 enhance collaboration by allowing multiple users to manage a single email account. Proper configuration ensures seamless access, reduced redundancy, and adherence to organizational workflows. Below are structured steps to customize settings in Outlook Desktop, Outlook Web (OWA), and Mobile Outlook, along with advanced configurations for signatures, permissions, and synchronization.

      Setting Default Reply/Forward Rules for Shared Mailboxes

      Default reply and forward rules streamline communication by automating responses and ensuring consistent routing. These settings apply to all users with access to the shared mailbox.

      Steps for Outlook Desktop:
      1. Open the shared mailbox in Outlook and navigate to File > Manage Rules & Alerts.
      2. Click New Rule and select Apply rule on messages I receive or Apply rule on messages I send.
      3. Configure conditions (e.g., sender domain, keywords) and actions (e.g., forward to a specific email, reply with a predefined template).
      4. Under Exceptions, specify scenarios where the rule should not apply (e.g., internal emails).
      5. Click Finish and test the rule by sending a test email to the shared mailbox.

      Steps for Outlook Web (OWA):
      1. Open the shared mailbox in OWA and go to Settings (gear icon) > View all Outlook settings > Mail > Rules.
      2. Click Add new rule and define criteria (e.g., "From specific people").
      3. Select actions such as Forward or Reply with a message.
      4. Use the Except if option to exclude specific senders or subjects.
      5. Save and verify the rule by sending a test email.

      Steps for Mobile Outlook (iOS/Android):
      Mobile Outlook does not support rule creation directly. Instead, use Exchange ActiveSync policies or PowerShell to enforce rules server-side. For manual overrides:

    • Forward critical emails to a personal account and set up filters there.
    • Use third-party apps like Flow (Microsoft Power Automate) to automate responses.
      • Best Practice: Avoid overly broad rules that may trigger unintended actions. Test rules with low-priority emails before applying them to high-volume shared mailboxes.

      Configuring Auto-Expanding Folders and Startup Preferences

      Auto-expanding folders improve navigation by keeping frequently accessed folders visible. This setting is particularly useful for shared mailboxes with hierarchical structures (e.g., departmental teams).

      Steps for Outlook Desktop:
      1. Right-click the folder (e.g., "Inbox") in the navigation pane and select Properties.
      2. Under the Folder Settings tab, check Show this folder at startup.
      3. For nested folders, repeat the process or use View Settings > Navigation Pane to enable Auto-expand folders.
      4. To prioritize folders, drag them to the top of the navigation pane.

      Steps for Outlook Web (OWA):
      1. Open the shared mailbox in OWA and click the three-dot menu (⋮) next to the folder name.
      2. Select Show in folder list and enable Auto-expand.
      3. Use the Pin to top option to keep critical folders visible.

      Steps for Mobile Outlook:
      Auto-expanding folders are not natively supported. Instead:

    • Pin frequently used folders to the home screen (if using the Outlook mobile app).
    • Use Favorites in OWA to create a shortcut-like experience on mobile devices.
      • Note: Auto-expanding folders may impact performance in shared mailboxes with large volumes of emails. Monitor sync times and adjust settings if delays occur.

      Enabling Shared Calendar Permissions and Delegate Access

      Shared calendars require granular permissions to control visibility and editing rights. Delegate access ensures authorized users can schedule meetings on behalf of the mailbox.

      Steps for Outlook Desktop:
      1. Open the shared mailbox calendar and right-click the calendar name in the navigation pane.
      2. Select Properties > Permissions.
      3. Click Add and enter the user’s email address or group name.
      4. Assign permissions:

    • Reviewer: View only.
    • Author: Create and modify items.
    • Non-editing Delegate: Send meetings on behalf of the mailbox (requires Send on behalf rights in Exchange).
      • 5. For Delegate Access, go to File > Account Settings > Delegate Access and add users with Send As or Send on Behalf permissions.

      Steps for Outlook Web (OWA):
      1. Open the shared calendar in OWA and click the three-dot menu (⋮) > Share.
      2. Enter the user’s email and select their permission level (e.g., Can view all details or Can edit).
      3. For delegate access, navigate to Settings > Calendar > Delegates and add users with Send meetings rights.

      Steps for Mobile Outlook:
      1. Open the shared calendar and tap the three-dot menu (⋮) > Share.
      2. Select the user and choose their permission level (limited to View or Edit).
      3. Delegate access requires manual configuration via Exchange Admin Center or PowerShell.

      Security Note: Restrict Send As permissions to trusted users to prevent unauthorized email sending. Use Send on Behalf for controlled delegation.

      Comparative Table: Outlook vs. OWA vs. Mobile Outlook Shared Mailbox Settings

      Below is a comparison of key shared mailbox settings across platforms. Differences in functionality may require workarounds or server-side configurations.
      Setting Outlook Desktop Outlook Web (OWA) Mobile Outlook (iOS/Android)
      Default Reply Templates Supported via Rules & Alerts (File > Manage Rules) Supported via Rules (Settings > Mail > Rules) Not supported; use Power Automate or third-party apps
      Auto-Expand Folders Yes (Folder Properties > Show at startup) Yes (Three-dot menu > Auto-expand) No; use Favorites or pinning
      Calendar Permissions Granular (Reviewer, Author, Delegate) Granular (View, Edit, Delegate) Limited (View/Edit only)
      Send on Behalf Rights Configured in Account Settings > Delegate Access Configured in Settings > Calendar > Delegates Not configurable; requires Exchange Admin Center
      Out-of-Office Replies Yes (File > Automatic Replies) Yes (Settings > Automatic replies) No; use mobile carrier settings or third-party apps
      Signature Customization Yes (File > Options > Mail > Signatures) Yes (Settings > Mail > Signatures) Limited (basic text only)
      Contact Sync Rules Managed via Exchange Rules or PowerShell Managed via Exchange Admin Center Automatic sync; conflicts resolved by last write

      Creating Shared Mailbox-Specific Signatures and Out-of-Office Replies

      Consistent signatures and out-of-office (OOF) replies maintain professionalism and reduce manual errors.

      Shared Mailbox Signatures:
      1. Outlook Desktop:

    • Go to File > Options > Mail > Signatures.
    • Create a new signature with the shared mailbox name, contact details, and legal disclaimers.
    • Set the signature as Default for replies/forwards and associate it with the shared mailbox account.

      • 2. Outlook Web (OWA):

    • Navigate to Settings > Mail > Compose and reply.
    • Under Email signature, click Edit signature and customize the text.
    • Ensure the signature is saved under the shared mailbox profile.

      • 3. Mobile Outlook:

    • Signatures are limited to plain text. Use a template stored in a shared document or third-party app like Gmail for Outlook.

      • Out-of-Office Replies

      Mastering the addition of shared mailboxes to Outlook transforms disjointed communication into a cohesive, efficient process. From manual setup to automated deployment via PowerShell, each method offers distinct advantages depending on organizational scale and technical expertise. By addressing common errors proactively and configuring settings for optimal usability, teams can leverage shared mailboxes to their fullest potential. Whether managing individual access or bulk deployments, adherence to security protocols and systematic troubleshooting ensures reliability and scalability in enterprise environments.

    add shared mailbox to outlook - Kesimpulan

    add shared mailbox to outlook - Kesimpulan

    Leave a Comment

    Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.