Best Practices für die Bereitstellung von Timer jobs in der Server-Farm-Umgebungen mit mehreren WFE

Es sieht aus wie Sie brauchen ein farm-scoped feature, dass einen Dienst installiert, der läuft diesen job. Hier ist, wie ich es gemacht habe (mit code, geschrieben von einem Kollegen, um ehrlich zu sein, aber er ist nicht SO).

Erstellen feature.xml Datei mit einem feature-event-receiver.

<Feature
  Id="..."
  Title="..."
  Description="..."
  Scope="Farm"
  Version="1.0.0.0"
  Hidden="FALSE"
  ReceiverAssembly="XXX.FarmService, Version=1.0.0.0, Culture=neutral, PublicKeyToken=xxx"
  ReceiverClass="XXX.FarmService.XXXFarmFeatureEventReceiver"
  xmlns="http://schemas.microsoft.com/sharepoint/">
</Feature>

Innerhalb des Ereignis-Empfänger:

public override void OnFeatureActivated(SPFeatureReceiverProperties properties)
    {
        try
        {
            SPFarm farm = SPFarm.Local;

            //Get Service, if it already exists
            JobService myService = null; //JobService is a subclass of SPService
            foreach (SPService service in farm.Services)
            {
                if (String.Compare(service.Name, JobService.XXXServiceName, true) == 0)
                {
                    myService = (service as JobService);
                    break;
                    }
                }

                if (cegService == null)
                {
                    //Create service
                    myService = new JobService(farm);
                    myService.Update();

                    //Create service instances
                    JobServiceInstance myServiceInstance; //JobServiceInstance is a subclas of SPServiceInstance
                    foreach (SPServer server in farm.Servers)
                    {
                        myServiceInstance = new JobServiceInstance(server, myService);
                        myServiceInstance.Update();
                    }
                }

                //Dayly schedule 
                SPDailySchedule schedule = new SPDailySchedule();
                schedule.BeginHour = 1;
                schedule.EndHour = 1;
                schedule.BeginMinute = 0;
                schedule.EndMinute = 59;

                //Our own job; JobCheckDocDates is a subclass of SPJobDefinition
                JobCheckDocDates newJob = new JobCheckDocDates(cegService, null, SPJobLockType.Job);
                newJob.Schedule = schedule;
                newJob.Update();
                myService.JobDefinitions.Add(newJob);
                myService.Update();
            }
            catch (Exception e)
            {
                Logger.Error("[" + properties.Feature.Definition.DisplayName + "] Error during feature activation", e);
            }
        }        

Dies schafft einen service auf jedem server in der farm.

Einige weitere details, auf die Unterklassen:

public class JobCheckDocDates: Common.BaseJob
{
    ///<summary>
    ///The job name
    ///</summary>
    public static string JobName = "XXX job";

    ///<summary>
    ///Constructor
    ///</summary>
    public JobCheckDocDates() : base() { }

    ///<summary>
    ///Constructor
    ///</summary>
    ///<param name="service"></param>
    ///<param name="server"></param>
    ///<param name="lockType"></param>
    public JobCheckDocDates(SPService service, SPServer server, SPJobLockType lockType)
            : base(JobName, service, server, lockType) { }

...

und natürlich die Execute-Methode.

public class JobService : SPService 
{
    public static string XXXServiceName = "XXX Service";

    public override string DisplayName
    {
        get
        {
            return XXXServiceName;
        }
    }

    public override string TypeName
    {
        get
        {
            return "XXX Service Type";
        }
    }

    /* An empty public constructor required for serialization. */
    public JobService() { }

    public JobService(SPFarm farm)
          : base(XXXServiceName, farm)
    {         
    }
}


    public class JobServiceInstance : SPServiceInstance
    {
        ///<summary>
        ///Eos Service Instance Name
        ///</summary>
        public static string XXXServiceInstanceName = "XXXServiceInstance";

        ///<summary>
        ///Manage Link
        ///</summary>
        private SPActionLink _manageLink;

        ///<summary>
        ///Provision Link
        ///</summary>
        private SPActionLink _provisionLink;

        ///<summary>
        ///Unprovision Link
        ///</summary>
        private SPActionLink _unprovisionLink;

        ///<summary>
        ///Roles
        ///</summary>
        private ICollection<string> _roles;

        ///<summary>
        ///Manage Link
        ///</summary>
        public override SPActionLink ManageLink
        {
            get
            {
                if (_manageLink == null)
                {
                    _manageLink = new SPActionLink(SPActionLinkType.None);
                }
                return _manageLink;
            }
        }

        ///<summary>
        ///Provision Link
        ///</summary>
        public override SPActionLink ProvisionLink
        {
            get
            {
                if (_provisionLink == null)
                {
                    _provisionLink = new SPActionLink(SPActionLinkType.ObjectModel);
                }
                return _provisionLink;
            }
        }

        ///<summary>
        ///Unprovision Link
        ///</summary>
        public override SPActionLink UnprovisionLink
        {
            get
            {
                if (_unprovisionLink == null)
                {
                    _unprovisionLink = new SPActionLink(SPActionLinkType.ObjectModel);
                }
                return _unprovisionLink;
            }
        }

        ///<summary>
        ///Roles
        ///</summary>
        public override ICollection<string> Roles
        {
            get
            {
                if (_roles == null)
                {
                    _roles = new string[1] { "Custom" };
                }
                return _roles;
            }
        }

        ///<summary>
        ///Empty constructor
        ///</summary>
        public JobServiceInstance() : base() { }

        ///<summary>
        ///Constructor
        ///</summary>
        ///<param name="server">The server</param>
        ///<param name="service">The Eos service</param>
        public JobServiceInstance(SPServer server, JobService service)
            : base(XXXServiceInstanceName, server, service)
        {
        }

Nun, in der Central Admin, gehen Sie zu Operationen /Dienste auf dem server. Wählen Sie den gewünschten server, und starten Sie den Dienst.

Zur Beantwortung Ihrer Fragen:
1. Implementieren Sie die Lösung nur einmal, unabhängig von einem WFE.
2. Wie die feature -, farm-scoped, es sollte aktiviert werden, in der zentralen Verwaltung.
3. Die SPJobLockType ist SPJobLockType.Job

Dies ist nicht genau das, was du dir vorgestellt hast, aber es hat den Vorteil, dass Sie leicht entscheiden, wo der Auftrag ausgeführt wird, auch lange nachdem Sie das feature installieren (z.B. wenn ein server überlastet ist mit anderen Sachen).

Den OnFeatureActivated Methode könnte klüger sein, und überprüfen Sie für jeden server, wenn der service vorhanden ist, und fügen Sie es, wenn nötig. Aber es ist einfacher zu entfernen, den Dienst von jedem service, der in OnFeatureDeactivated. Also, wenn Sie neue Server hinzufügen, deaktivieren, reaktivieren Sie die Funktion.