Mengembangkan Templat Aturan untuk Modul Penulisan Ulang URL

oleh Ruslan Yakushev

Panduan ini akan memandu Anda melalui cara mengembangkan templat aturan untuk modul Penulisan Ulang URL. Anda akan membuat templat aturan yang dapat digunakan untuk menghasilkan aturan penulisan ulang yang memberlakukan penggunaan domain tertentu untuk situs web.

Gambaran Umum Templat

Templat aturan Nama Domain Kanonis dapat digunakan untuk menyederhanakan pembuatan aturan penulisan ulang yang digunakan untuk menerapkan nama domain kanonis untuk situs web. Pengguna dapat memilih templat ini dari dialog "Tambahkan aturan":

Cuplikan layar dialog Tambahkan aturan dengan

Kemudian pengguna dapat memberikan nama domain yang ingin mereka gunakan:

Cuplikan layar

Setelah itu templat akan menghasilkan aturan penulisan ulang seperti di bawah ini:

Cuplikan layar panel Edit Aturan dengan bagian untuk Nama domain, URL, Kondisi, dan Tindakan.

Prasyarat

Sebelum melanjutkan panduan ini, disarankan untuk membiasakan diri dengan konsep dasar ekstensibilitas Manajer IIS dengan menyelesaikan tugas dalam artikel "Cara membuat modul Manajer IIS sederhana".

Proyek VS2008 untuk templat aturan

Proyek Visual Studio 2008 lengkap untuk templat aturan ini tersedia untuk diunduh di sini.

Menerapkan templat aturan

Untuk mendukung manajemen jarak jauh, semua komponen UI Manajer IIS diimplementasikan dengan mengikuti pola desain tertentu. Implementasi modul terdiri dari bagian-bagian berikut:

Antarmuka pengguna sisi klien dan proksi layanan
Layanan sisi server untuk mengelola konfigurasi IIS

Semua implementasi spesifik antarmuka pengguna berada di sisi klien, yang mungkin merupakan komputer klien jarak jauh. Semua fungsionalitas yang benar-benar membuat perubahan pada konfigurasi IIS diimplementasikan sebagai layanan di sisi server, sehingga memastikan bahwa ia memiliki akses ke semua API konfigurasi server. Kontrol sisi klien berinteraksi dengan layanan melalui proksi layanan.

Ini adalah praktik yang baik untuk menerapkan templat aturan dengan mengikuti pola yang sama, sehingga templat berfungsi saat pengguna membuat aturan melalui IIS Remote Manager. Bagian berikut ini menjelaskan cara menerapkan layanan templat aturan dan klien.

Menerapkan antarmuka pengguna sisi klien

Membuat model

Pertama, Anda harus membuat modul, adalah titik masuk utama di klien untuk semua objek ekstensibilitas. Untuk melakukannya:

Buat dan konfigurasikan proyek Visual Studio dengan mengikuti langkah-langkah yang dijelaskan dalam tugas 1 dan 2 dari artikel "Cara membuat modul Manajer IIS sederhana". Beri nama proyek sebagai "CanonicalDomainTemplateClient".
Pilih Tambahkan Referensi dari menu Proyek dan tambahkan referensi ke Microsoft.Web.Management.dll terletak di \Windows\System32\inetsrv:
Pilih Tambahkan Referensi lagi dan tambahkan referensi ke Microsoft.Web.Management.Rewrite.Client.dll yang terletak di \Program Files\Reference Assemblies\Microsoft\IIS.
Pilih Tambahkan Referensi lagi dan tambahkan referensi ke System.Windows.Forms.dll
Pilih opsi Tambahkan Item Baru dari menu Proyek. Dalam kotak dialog Tambahkan Item Baru , pilih templat Kelas dan ketik CanonicalDomainModule.cs sebagai nama untuk file tersebut.
Ubah kode sehingga terlihat seperti di bawah ini:

using System;
using Microsoft.Web.Management.Server;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Iis.Rewrite;

namespace CanonicalDomainTemplate
{
    internal class CanonicalDomainModule: Module
    {
        protected override void Initialize(IServiceProvider serviceProvider, ModuleInfo moduleInfo)
        {
            base.Initialize(serviceProvider, moduleInfo);

            IExtensibilityManager extensibilityManager = (IExtensibilityManager)GetService(typeof(IExtensibilityManager));

            extensibilityManager.RegisterExtension(typeof(RewriteTemplateFeature), new CanonicalDomainFeature(this)); 
        }
    }
}

Kode ini menginisialisasi instans baru dari CanonicalDomainFeature kelas, yang akan mengimplementasikan fungsionalitas templat aturan. Instans kelas ini digunakan untuk mendaftarkan ekstensi jenis RewriteTemplateFeature, yang merupakan jenis dari mana semua templat aturan diturunkan.

Membuat Fitur Templat Penulisan Ulang

Saat menentukan kelas yang mengimplementasikan templat aturan, Anda harus memperoleh kelas ini dari kelas RewriteTemplateFeature . Ini adalah kelas induk yang digunakan oleh semua templat aturan Penulisan Ulang URL.

Pilih opsi Tambahkan Item Baru di Menu Proyek. Pilih templat Kelas dan ketik CanonicalDomainFeature.cs sebagai nama file.
Ubah kode sehingga terlihat seperti di bawah ini:

using System;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Iis.Rewrite;
using System.Windows.Forms;
using System.Collections;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainFeature: RewriteTemplateFeature
    {
        private const string FeatureTitle = "Canonical Domain Name";
        private const string FeatureDescription = "Creates a rewrite rule for enforcing canonical domain name for your web site";

        public CanonicalDomainFeature(Module module)
            : base(module, FeatureTitle, FeatureDescription, Resource.domain_icon16, Resource.domain_icon32)
        {
        }

        public override void Run()
        {
            CanonicalDomainModuleServiceProxy serviceProxy = 
                 (CanonicalDomainModuleServiceProxy)Connection.CreateProxy(this.Module, 
                                                                           typeof(CanonicalDomainModuleServiceProxy));
            CanonicalDomainForm form = new CanonicalDomainForm(serviceProxy);
            form.StartPosition = FormStartPosition.CenterParent;
            if (form.ShowDialog() == DialogResult.OK)
            {
                Navigate(GetPageType("Rewrite"));
            }
        }

        /// <summary>
        /// Returns the main page for the specified module
        /// </summary>
        private Type GetPageType(string moduleName)
        {
            IControlPanel controlPanel = (IControlPanel)GetService(typeof(IControlPanel));
            Module module = (Module)Connection.Modules[moduleName];

            if (module != null)
            {
                ICollection pageInfos = controlPanel.GetPages(module);

                foreach (ModulePageInfo pageInfo in pageInfos)
                {
                    if (pageInfo.IsEnabled && !pageInfo.PageType.IsAssignableFrom(typeof(IModuleChildPage)))
                    {
                        return pageInfo.PageType;
                    }
                }
            }

            return null;
        }
    }
}

Kode melakukan hal berikut:

Menentukan nama dan judul untuk templat aturan
Meneruskan nama, judul, dan ikon ke konstruktor kelas dasar sehingga digunakan saat dialog "Tambahkan aturan" menampilkan semua templat aturan terdaftar
Menentukan metode Run() yang digunakan untuk merender antarmuka pengguna templat, yaitu dialog modal berbasis WinForm CanonicalDomainForm. Jika tombol OK diklik dalam dialog, halaman UI utama modul Penulisan Ulang URL disegarkan dengan memanggil metode Navigate().
Terakhir, ini mendefinisikan fungsi pembantu GetPageType yang digunakan untuk mendapatkan halaman utama untuk modul yang ditentukan.

Menentukan proksi layanan

Agar klien jarak jauh dapat memanggil layanan, perlu menyediakan proksi layanan. Untuk melakukannya, tambahkan file lain ke proyek Anda yang disebut CanonicalDomainModuleServiceProxy.cs dan ubah kode di dalamnya untuk melihat seperti di bawah ini:

using System;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Server;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainModuleServiceProxy : ModuleServiceProxy
    {

        public void GenerateRule(string domainName)
        {
            Invoke("GenerateRule", domainName);
        }
    }
}

Implementasi layanan aktual untuk metode GenerateRule akan ditambahkan nanti.

Menerapkan dialog templat aturan

Sekarang, setelah semua kode pipa sisi klien IIS Manager selesai, bagian yang tersisa adalah merancang dan mengimplementasikan antarmuka pengguna yang sebenarnya untuk templat aturan. Untuk melakukannya, ikuti langkah-langkah berikut:

Pilih opsi Tambahkan Item Baru di menu proyek. Dalam dialog Tambahkan Item Baru, pilih "Formulir Windows" dan ketik nama CanonicalDomainForm.cs:
Gunakan desainer formulir jendela Visual Studio untuk menyusun kontrol pada formulir:
Beralih ke tampilan kode dan tambahkan anggota privat kelas yang akan berisi referensi ke proksi layanan:
```
private CanonicalDomainModuleServiceProxy _serviceProxy;
```

Di kelas yang sama ubah kode konstruktor seperti di bawah ini:

public CanonicalDomainForm(CanonicalDomainModuleServiceProxy serviceProxy)
{
   _serviceProxy = serviceProxy;
   InitializeComponent();
}

Di kelas yang sama tambahkan fungsi pembantu yang akan memanggil proksi layanan untuk menghasilkan aturan penulisan ulang dengan parameter yang ditentukan oleh pengguna:

private void GenerateRule(string domainName)
{
    try
    {
        _serviceProxy.GenerateRule(domainName);
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Tambahkan penanganan aktivitas saat tombol OK diklik. Dalam kode penanganan aktivitas, panggil fungsi pembantu GenerateRule, meneruskan konten kontrol TextBox sebagai parameter.
```
private void OnOkButtonClick(object sender, EventArgs e)
{
    GenerateRule(_DomainTextBox.Text);
}
```

Menerapkan layanan untuk templat aturan

Untuk menerapkan layanan, Anda harus membuat penyedia modul, yang merupakan titik masuk untuk pendaftaran modul di IIS Manager. Untuk melakukannya:

Buat dan konfigurasikan proyek Visual Studio lain dengan mengikuti langkah-langkah yang dijelaskan dalam tugas 1 dan 2 dari artikel "Cara membuat modul Manajer IIS sederhana". Beri nama proyek sebagai "CanonicalDomainTemplate".
Pilih Tambahkan Referensi dari menu Proyek dan tambahkan referensi ke rakitan berikut yang terletak di \Windows\System32\inetsrv:
1. Microsoft.Web.Administration.dll
2. Microsoft.Web.Management.dll
Pilih opsi Tambahkan Item Baru dari menu Proyek. Dalam kotak dialog Tambahkan Item Baru , pilih templat Kelas dan ketik CanonicalDomainModuleProvider.cs sebagai nama untuk file tersebut.
Ubah kode sehingga terlihat seperti di bawah ini (jangan lupa untuk mengganti PublicKeyToken dengan token kunci publik perakitan CanonicalDomainTemplate.Client.dll)

namespace CanonicalDomainTemplate
{
    internal sealed class CanonicalDomainModuleProvider : ModuleProvider
    {
        public override string FriendlyName
        {
            get
            {
                return Resource.ModuleFriendlyName;
            }
        }

        public override Type ServiceType
        {
            get {
                 return typeof(CanonicalDomainModuleService);
            }
        }

        public override ModuleDefinition GetModuleDefinition(IManagementContext context)
        {
            if (context != null && string.Compare(context.ClientUserInterfaceTechnology, 
            "System.Windows.Forms.Control", StringComparison.OrdinalIgnoreCase) != 0)
            {
                return null;
            }

            return new ModuleDefinition(Name, "CanonicalDomainTemplate.CanonicalDomainModule,
                                               CanonicalDomainTemplate.Client,Version=1.0.0.0,Culture=neutral,
                                               PublicKeyToken={your key}");
        }

        public override bool SupportsScope(ManagementScope scope)
        {
            return true;
        }
    }
}

Kode ini membuat ModuleProvider yang mendukung semua jenis koneksi (Server, Situs, dan Aplikasi) dan mendaftarkan modul sisi klien yang disebut CanonicalDomainModule. Juga mendaftarkan jenis layanan modul CanonicalDomainModuleService yang digunakan di sisi server untuk menghasilkan aturan penulisan ulang.

Untuk membuat layanan untuk templat aturan, ikuti langkah-langkah berikut:

Pilih opsi Tambahkan Item Baru di Menu Proyek. Pilih templat Kelas dan ketik CanonicalDomainModuleService.cs sebagai nama file.
Ubah kode sehingga terlihat seperti di bawah ini:

using System;
using System.Collections.Generic;
using Microsoft.Web.Management.Server;
using Microsoft.Web.Administration;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainModuleService : ModuleService
    {

        [ModuleServiceMethod]
        public void GenerateRule(string domainName)
        {
            string sectionPath = "system.webServer/rewrite/rules";
            
            if (ManagementUnit.ConfigurationPath.PathType == ConfigurationPathType.Server)
            {
                sectionPath = "system.webServer/rewrite/globalRules";
            }

            ConfigurationSection rulesSection = ManagementUnit.Configuration.GetSection(sectionPath);
            ConfigurationElementCollection rulesCollection = rulesSection.GetCollection();

            ConfigurationElement ruleElement = rulesCollection.CreateElement("rule");
            ruleElement["name"] = @"Canonical domain for " + domainName;
            ruleElement["patternSyntax"] = @"Wildcard";
            ruleElement["stopProcessing"] = true;

            ConfigurationElement matchElement = ruleElement.GetChildElement("match");
            matchElement["url"] = @"*";

            ConfigurationElement conditionsElement = ruleElement.GetChildElement("conditions");

            ConfigurationElementCollection conditionsCollection = conditionsElement.GetCollection();

            ConfigurationElement addElement = conditionsCollection.CreateElement("add");
            addElement["input"] = @"{HTTP_HOST}";
            addElement["negate"] = true;
            addElement["pattern"] = domainName;
            conditionsCollection.Add(addElement);

            ConfigurationElement actionElement = ruleElement.GetChildElement("action");
            actionElement["type"] = @"Redirect";
            actionElement["url"] = @"http://" + domainName + @"/{R:1}";
            actionElement["appendQueryString"] = true;
            rulesCollection.Add(ruleElement);

            ManagementUnit.Update();
        }
    }
}

Kode ini membuat aturan untuk pengalihan ke domain kanonis.

Tip

untuk mendapatkan kode dengan cepat untuk membuat aturan penulisan ulang menggunakan Editor Konfigurasi untuk IIS 7.0 ke atas, yang disertakan dalam Paket Administrasi untuk IIS. Lihat artikel ini untuk informasi selengkapnya tentang cara menghasilkan kode untuk pembuatan aturan penulisan ulang.

Mendaftarkan templat aturan dengan Manajer IIS

Setelah proyek templat aturan berhasil dikompilasi dan ditempatkan ke dalam Global Assembly Cache, Anda harus mendaftarkannya dengan Manajer IIS dengan menambahkan informasinya ke file administration.config.

Buka file administration.config yang terletak di \Windows\System32\inetsrv\config dan tambahkan baris berikut ke <bagian moduleProviders> . Pastikan untuk mengganti PublicKeyToken:

<add name="CanonicalDomainName" type="CanonicalDomainTemplate.CanonicalDomainModuleProvider, CanonicalDomainTemplate, Version=1.0.0.0, Culture=neutral, PublicKeyToken=e4e6d0bc8fe7a06a" />

Catatan

Dengan menambahkannya hanya ke daftar modulProviders, Anda mendaftarkan modul hanya untuk koneksi Server. Jika Anda ingin modul ini diaktifkan untuk koneksi Situs serta koneksi aplikasi, tambahkan ke daftar berikut:

<location path=".">
   <module> 
     <add name="CanonicalDomainName" />
   </module>
</location>

Setelah langkah-langkah ini selesai, Anda harus dapat melihat templat aturan "Nama Domain Kanonis" dalam dialog Tambahkan Aturan modul Penulisan Ulang URL.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2023-07-19