Tomcat derrière Apache à l'aide de ajp pour le Printemps de Démarrage de l'application

J'ai essayé de configurer le serveur web Apache avec un Ressort de Démarrage de l'app qui utilise Tomcat intégré. Avant le Printemps de Démarrage j'ai utilisé pour créer un ajp.fichier conf comme:

<VirtualHost *:80>
   ServerName localhost
   <Proxy *>
      AddDefaultCharset Off
      Order deny,allow
      Allow from all
   </Proxy>

   ProxyPass /app ajp://localhost:8009/app
   ProxyPassReverse /app ajp://localhost:8009/app

 </VirtualHost>

Et l'inclure dans le httpd.fichier conf comme

Include /opt/lampp/apache2/conf/ajp.conf

Et dans le Tomcat server.xml fichier, j'ai utilisé le configurer pour écouter sur le port 8009

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" connectionTimeout="5000"

Cette configuration fonctionne. Mais, maintenant avec Spring Boot je suis en train de réaliser quelque chose de similaire avec un tomcat intégré. J'ai lu Printemps De Démarrage De La Documentation ici et ajouté les possédants sur ma demande.fichier yml:

server:
    port: 8080
    tomcat:
        remote_ip_header: x-forwarded-for
        protocol_header: x-forwarded-proto

Mon ajp.fichier conf ressemble à ceci:

<VirtualHost *:80>
   ServerName localhost
   <Proxy *>
      AddDefaultCharset Off
      Order deny,allow
      Allow from all
   </Proxy>

   ProxyPass /app ajp://localhost:8009/
   ProxyPassReverse /app ajp://localhost:8009/

 </VirtualHost>

J'ai mon ressort de démarrage configuration de tomcat classe comme

@Configuration
public class TomcatConfiguration {

private final Logger log = LoggerFactory.getLogger(TomcatConfiguration.class);

@Bean
public EmbeddedServletContainerFactory servletContainer() {
    TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();
    tomcat.addAdditionalTomcatConnectors(createConnector());
    tomcat.addContextValves(createRemoteIpValves());
    return tomcat;
}

private RemoteIpValve createRemoteIpValves(){
    RemoteIpValve remoteIpValve = new RemoteIpValve();
    remoteIpValve.setRemoteIpHeader("x-forwarded-for");
    remoteIpValve.setProtocolHeader("x-forwarded-protocol");
    return remoteIpValve;
}

private Connector createConnector() {
    Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
    Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
    connector.setScheme("ajp");
    connector.setProtocol("AJP/1.3");
    connector.setRedirectPort(8443);
    //connector.setSecure(true);
    connector.setPort(8009);
    return connector;
}

Sur mon apache journaux d'erreur que je vois:

AH01080: ajp_msg_check_header() got bad signature 4854
[proxy_ajp:error] [pid 24073] AH01031: ajp_ilink_receive() received bad header
[proxy_ajp:error] ajp_read_header: ajp_ilink_receive failed
[proxy_ajp:error] (120007)APR does not understand this error code: [client xx.xx.xx.xx:60916] AH00878: read response failed from (null) (*)

Pas sûr de ce qui se passe ici. J'ai beaucoup cherché en ligne, mais ne pouvait pas trouver une bonne documentation sur la façon de servir tomcat derrière apache avec le printemps de démarrage des applications. Finalement, je tiens à équilibrer la charge de plusieurs instances tomcat trop.

docs.printemps.io/autorepo/docs/spring-boot/1.0.0.RC4/api/org/... ou docs.printemps.io/spring-boot/docs/current/reference/html/... .
Pourquoi êtes-vous créer HTTP NIO connecteur? Vous devez créer connecteur AJP - new Connector("AJP/1.3").
vous m'a poussé vers la bonne direction. Lorsque j'ai utilisé org.apache.coyote.ajp.AjpProtocol connecteur, il a travaillé. Pas sûr, comment je fais c'est la meilleure façon de le faire. Mais, cela fonctionne maintenant. Merci une tonne!

OriginalL'auteur Nayan | 2014-11-21

Déduit les commentaires ci-dessus:

@Configuration
public class TomcatAjpConfig {

@Bean
@SuppressWarnings("static-method")
public EmbeddedServletContainerFactory servletContainer() {
    TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();
    tomcat.addAdditionalTomcatConnectors(createConnector());
    tomcat.addContextValves(createRemoteIpValves());
    return tomcat;
}

private static RemoteIpValve createRemoteIpValves() {
    RemoteIpValve remoteIpValve = new RemoteIpValve();
    remoteIpValve.setRemoteIpHeader("x-forwarded-for");
    remoteIpValve.setProtocolHeader("x-forwarded-proto");
    return remoteIpValve;
}

private static Connector createConnector() {
    Connector connector = new Connector("AJP/1.3");
    connector.setPort(8009);
    return connector;
}

}

OriginalL'auteur Tim

3

A eu un problème similaire mais avec HTTP-Proxy. Après un peu de débogage de Printemps de Démarrage 1.3 j'ai trouvé la solution suivante. Il devrait en être de même pour l'AJP Proxy.

1. Vous devez paramétrer les en-têtes sur votre proxy Apache:
```
<VirtualHost *:443>
    ServerName www.myapp.org
    ProxyPass /http://127.0.0.1:8080/
    RequestHeader set X-Forwarded-Proto https
    RequestHeader set X-Forwarded-Port 443
    ProxyPreserveHost On
    ... (SSL directives omitted for readability)
</VirtualHost>
```
2. Vous devez indiquer à votre Ressort de Démarrage de l'application à utiliser ces en-têtes. Donc, mettez la ligne suivante dans votre application.propriétés (ou tout autre lieu où le Printemps Bottes comprend propriétés):
```
server.use-forward-headers=true
```
Si vous faites ces deux choses correctement, tous les rediriger votre application envoie sera pas aller à http://127.0.0.1:8080/%5Bchemin d'accès] mais automatiquement à https://www.myapp.com/%5Bchemin d'accès]

Mise à jour 1. La documentation sur ce sujet est ici. Vous devriez le lire au moins être conscient de la propriété server.tomcat.internal-proxies qui définit la plage d'adresses IP pour les serveurs proxy qui peut être digne de confiance.

Petit plus; c'est ce Que je serais arrivé au. Tout fonctionne très bien, avec le problème mineur que lorsque j'utilise le printemps hateoas ControllerLinkBuilder.linkTo + methodOn mes liens générés commencer par https, mais aussi de contenir le numéro de port 443. Lorsque j'utilise BasicLinkBuilder le port n'est pas ajouté à l'URL. Des idées à ce sujet?
N'a jamais travaillé avec ces classes. Vous pouvez essayer de déboguer dans ContollerLinkBuilder et dans BasicLinkBuilder. Si ils ont une différence, vous pouvez poster un rapport de bug pour le Printemps, les gars. Ils réagissent très rapide.

OriginalL'auteur Igor Mukhin

Configurable via les propriétés ou les fichier yml.

@Configuration
@ConfigurationProperties(prefix = "tomcat")
public class TomcatConfiguration {
   private int ajpPort = 8009;

   private boolean ajpAllowTrace = false;
   private boolean ajpSecure = false;
   private String ajpScheme = "http";
   private boolean ajpEnabled;


  @Bean
  public EmbeddedServletContainerFactory servletContainer() {

    TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();
    if (isAjpEnabled()) {
        Connector ajpConnector = new Connector("AJP/1.3");
        ajpConnector.setProtocol("AJP/1.3");
        ajpConnector.setPort(getAjpPort());
        ajpConnector.setSecure(isAjpSecure());
        ajpConnector.setAllowTrace(isAjpAllowTrace());
        ajpConnector.setScheme(getAjpScheme());
        tomcat.addAdditionalTomcatConnectors(ajpConnector);
    }

    return tomcat;
    }
//... Get/Set
}

application.yml

tomcat:
  ajpEnabled: true
  ajpPort: 9009
  ...

OriginalL'auteur pdorgambide

Vous devez vous connecter pour publier un commentaire.