Utilisation de points de terminaison de service

Dernière modification : mardi 15 février 2011

S’applique à : SharePoint Foundation 2010

Dans cet article
Protocoles pris en charge
Définition des points de terminaison de service
Mise en place de plusieurs points de terminaison
Définition de points de terminaison dans du code de déploiement de service
Définition de points de terminaison dans la configuration du client
Définition de points de terminaison dans du code proxy

Toutes les communications avec le service WCF (Windows Communication Foundation) ont lieu par le biais de points de terminaison de service. Un point de terminaison de service spécifie un contrat qui indique les méthodes de la classe de service accessibles via le point de terminaison, et chaque point de terminaison peut exposer un ensemble différent de méthodes. En outre, un point de terminaison définit une liaison qui spécifie la façon dont un client communique avec le service et l’adresse réseau à laquelle réside le point de terminaison.

Protocoles pris en charge

L’Infrastructure des applications de service prend en charge tous les protocoles pris en charge par WCF ; toutefois, il est recommandé d’utiliser des protocoles http et https pour les points de terminaison de service :

• HTTP

• HTTPS

  Notes

  L’Infrastructure des applications de service installe et configure automatiquement un certificat SSL (Secure Sockets Layer) pour vos points de terminaison de service HTTPS. Bien que l’interface utilisateur de gestion des services Internet (IIS) n’affiche pas ce certificat, celui-ci est installé. Vous pouvez le vérifier en tapant la commande suivante depuis une invite de commandes :

  netsh http show sslcert ipport=0.0.0.0:32844

Définition des points de terminaison de service

Chaque point de terminaison pris en charge par votre application de service WCF doit être défini dans les paramètres web.config de l’application. Le protocole et l’adresse de chaque point de terminaison doivent être uniques. Par exemple, deux points de terminaison peuvent avoir la même adresse s’ils spécifient différents protocoles dans leurs liaisons respectives. Toutefois, si deux points de terminaison utilisent le même protocole, ils doivent spécifier des adresses différentes.

Utilisez une adresse de point de terminaison unique pour chaque point de terminaison afin que ces adresses ne dépendent pas du protocole de liaison. Spécifiez une adresse de point de terminaison relative à l’adresse de base configurée par l’Infrastructure des applications de service.

Par exemple, pour spécifier deux points de terminaison avec les adresses relatives « http » et « https », utilisez le code suivant.

<services>
    <service
        name="Microsoft.SharePoint.Test.SampleWebServiceApplication">
        <endpoint
          address="http"
          contract="Microsoft.SharePoint.Test.ISampleWebServiceContract"
          binding="customBinding"
          bindingConfiguration="SampleWebServiceHttpBinding" />
        <endpoint
          address="https"
          contract="Microsoft.SharePoint.Test.ISampleWebServiceContract"
          binding="customBinding"
          bindingConfiguration="SampleWebServiceHttpsBinding" />
      </service>
    </services>

Dans l’exemple précédent, si l’adresse de service de base est http://machine:8080/application/calculator.svc, les adresses des points de terminaison sont les suivantes :

http://machine:8080/application/calculator.svc/http

http://machine:8080/application/calculator.svc/https

Mise en place de plusieurs points de terminaison

Une application de service peut prendre en charge deux points de terminaison : un qui utilise une liaison optimisée pour les performances (configuration dans laquelle, par exemple, le trafic réseau entre le serveur Web frontal et le serveur d’applications réside sur un réseau local principal privé et n’a pas besoin d’être chiffré), et un autre qui utilise une liaison optimisée pour la sécurité (configuration dans laquelle le trafic réseau doit être chiffré). L’Infrastructure des applications de service fournit une interface utilisateur qui permet à un administrateur de batterie de choisir le point de terminaison le plus approprié pour la topologie de réseau. Les administrateurs peuvent gérer la sélection du point de terminaison à l’aide de l’option Publier de la page de gestion des applications de service du site Web Administration centrale ou du paramètre DefaultEndpoint de l’applet de commande Set-SPServiceApplicationWindows PowerShell.

Définition de points de terminaison dans du code de déploiement de service

Par défaut, une application de service Web possède un seul point de terminaison HTTP. S’il s’agit de la configuration souhaitée pour votre application de service, aucune modification n’est requise. Si vous souhaitez utiliser un protocole différent ou prendre en charge plusieurs points de terminaison, vous devez explicitement définir tous les points de terminaison que votre application de service prendra en charge.

Utilisez la méthode AddServiceEndpoint de SPIisWebServiceApplication, comme l’illustre l’exemple suivant.

// Construct your SPIisWebServiceApplication derived class as usual.
MyWebServiceApplication app = new MyWebServiceApplication(…);

// Commit the new application to the configuration database.
// NOTE: Update must be called before AddServiceEndpoint.

// The service application must be committed to the configuration database before endpoints can be added.
app.Update();

// Add the endpoints supported by the application.
// NOTE: AddServiceEndpoint should be called before app.Provision, because app.Provision will provision 
// the default HTTP endpoint if no endpoints are explicitly added to the application.
// NOTE: The default endpoint name is always "http"
app.AddServiceEndpoint("", SPIisWebServiceBindingType.Http);

// Add an alternate HTTPS endpoint.
app.AddServiceEndpoint("secure", SPIisWebServiceBindingType.Https);

Le point de terminaison portant le nom « http » est utilisé comme point de terminaison par défaut pour l’application de service. Un nom de point de terminaison de service doit être unique, même si vos adresses de point de terminaison ne le sont pas. Si deux points de terminaison se situent à la même adresse relative, vous devez utiliser le troisième paramètre facultatif d’AddServiceEndpoint pour spécifier l’adresse relative. Par défaut, le troisième paramètre est défini sur le nom du point de terminaison.

L’exemple suivant montre comment définir deux points de terminaison à la même adresse de service de base, le premier utilisant le protocole HTTP, le second le protocole HTTPS. Le point de terminaison https se situe à l’adresse de service de base "".

app.AddServiceEndpoint("", SPIisWebServiceBindingType.Http); 
// The default endpoint.
app.AddServiceEndpoint("https", SPIisWebServiceBindingType.Https, ""); 

Définition de points de terminaison dans la configuration du client

Chaque point de terminaison doit également être défini dans la configuration du client. Créez un fichier client.config avec des liaisons qui correspondent au fichier web.config associé à votre application de service. Chaque point de terminaison client doit posséder une valeur d’attribut name unique afin de pouvoir être référencé à partir du code proxy qui lira le fichier de configuration, comme l’illustre l’exemple suivant.

Les noms des configurations de point de terminaison dans cet exemple ont été choisis afin qu’ils correspondent aux adresses relatives des points de terminaison de service, bien que cela ne soit pas nécessaire.

<configuration>
  <system.serviceModel>
    <client>
      <endpoint
        name="http"
        contract="Microsoft.SharePoint.Test.ISampleWebServiceContract"
        binding="customBinding"
        bindingConfiguration="SampleWebServiceHttpBinding" />
      <endpoint
        name="https"
        contract="Microsoft.SharePoint.Test.ISampleWebServiceContract"
        binding="customBinding"
        bindingConfiguration="SampleWebServiceHttpsBinding" />
    </client>

Définition de points de terminaison dans du code proxy

Votre code proxy doit créer une fabrique de canaux à l’aide de la configuration de point de terminaison appropriée. La configuration de point de terminaison est identifiée par le nom (l’attribut name de l’élément de configuration de client endpoint). Pour déterminer le nom de la configuration de point de terminaison, examinez l’URI de point de terminaison avant de créer un canal et comparez l’adresse relative aux adresses de point de terminaison connues. Le code utilisé pour la mise en cache de la fabrique de canaux cliente est illustré dans l’exemple suivant. Si vos adresses de point de terminaison ne sont différenciées que par le protocole, utilisez le modèle URI dans votre comparaison.

private string m_EndpointConfigurationName;
private ChannelFactory<ISampleWebServiceContract> m_ChannelFactory;
private object m_ChannelFactoryLock = new object();

À présent, obtenez le nom de la configuration de point de terminaison pour une adresse de point de terminaison donnée.<param name="address">The endpoint address.</param>

GetEndpointConfigurationName retourne le nom de la configuration de point de terminaison. Le nom de point de terminaison retourné doit correspondre à celui des éléments de point de terminaison dans le fichier client.config.

private string GetEndpointConfigurationName(Uri address)
{
    if (null == address)
    {
        throw new ArgumentNullException("address");
    }
    if (address.Scheme == Uri.UriSchemeHttp)
    {
        return "http";
    }

    if (address.Scheme == Uri.UriSchemeHttps)
    {
        return "https";
    }
    return String.Empty;
}
private ISampleWebServiceContract GetChannel(Uri address)
{
    // Create an endpoint address for the service.
    EndpointAddress endpointAddress = new EndpointAddress(address); 

    // Get the endpoint configuration name.
    string endpointConfigurationName = GetEndpointConfigurationName(address); 
    // Check for a cached channel factory for the endpoint configuration.
    if ((null == m_ChannelFactory) || 
    (endpointConfigurationName != m_EndpointConfigurationName))
    {
        lock (m_ChannelFactoryLock)
        {
            if ((null == m_ChannelFactory) || 
               (endpointConfigurationName != m_EndpointConfigurationName))
            {

                // Create a channel factory
                // endpoint configuration name.
                m_ChannelFactory = 
                CreateChannelFactory<ISampleWebServiceContract>
                (endpointConfigurationName);
                // Store the current endpoint configuration name.
                m_EndpointConfigurationName = endpointConfigurationName;
            }
        }
    }
    // Create a channel from the channel factory.
    return m_ChannelFactory.CreateChannel(endpointAddress);
}

Voir aussi

Concepts

Création de services Web d’Infrastructure des applications de service