Mercurial > hg > nginx-site
comparison xml/it/docs/http/server_names.xml @ 1018:19129672444e
Added italian translation.
Grazie a Angelo Papadia <angelo.papadia@gmail.com>!
author | Vladimir Homutov <vl@nginx.com> |
---|---|
date | Wed, 20 Nov 2013 14:36:40 +0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
1017:9f9a427a73eb | 1018:19129672444e |
---|---|
1 <!-- | |
2 Copyright (C) Igor Sysoev | |
3 Copyright (C) Nginx, Inc. | |
4 --> | |
5 | |
6 <!DOCTYPE article SYSTEM "../../../../dtd/article.dtd"> | |
7 | |
8 <article name="I nomi dei server" | |
9 link="/it/docs/http/server_names.html" | |
10 lang="it" | |
11 translator="Angelo Papadia" | |
12 rev="2" | |
13 author="Igor Sysoev" | |
14 editor="Brian Mercer"> | |
15 | |
16 | |
17 <section> | |
18 | |
19 <para> | |
20 I nomi dei server, definiti usando la direttiva | |
21 <link doc="ngx_http_core_module.xml" id="server_name"/>, | |
22 determinano quale blocco | |
23 <link doc="ngx_http_core_module.xml" id="server"/> | |
24 viene usato per una data richiesta (per approfondire vedi | |
25 "<link doc="request_processing.xml"/>”). | |
26 | |
27 I nomi possono essere definiti tramite una stringa determinata, | |
28 oppure con caratteri jolly, oppure ancora tramite espressioni regolari: | |
29 | |
30 <programlisting> | |
31 server { | |
32 listen 80; | |
33 server_name example.org www.example.org; | |
34 ... | |
35 } | |
36 | |
37 server { | |
38 listen 80; | |
39 server_name *.example.org; | |
40 ... | |
41 } | |
42 | |
43 server { | |
44 listen 80; | |
45 server_name mail.*; | |
46 ... | |
47 } | |
48 | |
49 server { | |
50 listen 80; | |
51 server_name ~^(?<user>.+)\.example\.net$; | |
52 ... | |
53 } | |
54 </programlisting> | |
55 </para> | |
56 | |
57 <para> | |
58 Nel corso della ricerca di un server virtuale name-based, se il nome corrisponde | |
59 a piu' di una delle definizioni, ad esempio sia a nomi definiti tramite | |
60 caratteri jolly che a nomi definiti tramite espressioni regolari, verra' scelta | |
61 la prima variante individuata, secondo il seguente ordine di precedenza decrescente: | |
62 <list type="enum"> | |
63 | |
64 <listitem> | |
65 nome esatto | |
66 </listitem> | |
67 | |
68 <listitem> | |
69 fra quelli definiti con caratteri jolly, il piu' lungo nome che comincia per | |
70 asterisco, ad esempio “<literal>*.example.org</literal>” | |
71 </listitem> | |
72 | |
73 <listitem> | |
74 fra quelli definiti con caratteri jolly, il piu' lungo nome che termina per | |
75 asterisco, ad esempio “<literal>mail.*</literal>” | |
76 </listitem> | |
77 | |
78 <listitem> | |
79 fra quelli definiti come espressioni regolare, il primo corrispondente | |
80 (in base all'ordine con cui compaiono nel file di configurazione) | |
81 </listitem> | |
82 | |
83 </list> | |
84 </para> | |
85 | |
86 </section> | |
87 | |
88 | |
89 <section id="wildcard_names" | |
90 name="Nomi con caratteri jolly"> | |
91 | |
92 <para> | |
93 Un nome con caratteri jolly puo' contenere un asterisco solo all'inizio | |
94 o alla fine del nome, e solo accanto ad un punto; ad esempio, i nomi | |
95 “<literal>www.*.example.org</literal>” | |
96 e “<literal>w*.example.org</literal>” non sono validi (pero' e' | |
97 possibile definirli tramite espressioni regolari, per esempio in questo | |
98 caso “<literal>~^www\..+\.example\.org$</literal>” e | |
99 “<literal>~^w.*\.example\.org$</literal>”). | |
100 Un asterisco puo' corrispondere a piu' parti di un nome: | |
101 “<literal>*.example.org</literal>” corrisponde non solo a | |
102 <literal>www.example.org</literal> ma anche a | |
103 <literal>www.sub.example.org</literal>. | |
104 </para> | |
105 | |
106 <para> | |
107 E' possibile definire un nome speciale nella forma | |
108 “<literal>.example.org</literal>”, che corrisponde sia al nome esatto | |
109 “<literal>example.org</literal>” sia al nome con caratteri jolly | |
110 “<literal>*.example.org</literal>”. | |
111 </para> | |
112 | |
113 </section> | |
114 | |
115 | |
116 <section id="regex_names" | |
117 name="Nomi con espressioni regolari"> | |
118 | |
119 <para> | |
120 Le espressioni regolari usate da nginx sono compatibili con quelle usate | |
121 dal linguaggio di programmazione Perl (PCRE). | |
122 Per usare una espressione regolare, il nome del server deve iniziare con | |
123 il carattere tilde: | |
124 | |
125 <programlisting> | |
126 server_name ~^www\d+\.example\.net$; | |
127 </programlisting> | |
128 | |
129 altrimenti viene considerato e trattato come un nome esatto, oppure, | |
130 se l'espressione contiene un asterisco, come un nome con caratteri jolly | |
131 (e molto probabilmente come uno non valido). | |
132 E' importante non dimenticare i caratteri ancora “<literal>^</literal>” e | |
133 “<literal>$</literal>”: non sono necessari dal punto di vista sintattico, | |
134 ma lo sono da quello logico. | |
135 Si noti inoltre che i caratteri punto nei nomi di dominio sono definiti | |
136 facendoli precedere da “<literal>\</literal>”. | |
137 Una espressione regolare contenente i caratteri “<literal>{</literal>” e | |
138 “<literal>}</literal>”, deve essere racchiusa fra doppi apici: | |
139 | |
140 <programlisting> | |
141 server_name "~^(?<name>\w\d<b>{</b>1,3<b>}</b>+)\.example\.net$"; | |
142 </programlisting> | |
143 | |
144 altrimenti nginx non sara' in grado di avviarsi e mostrera' l'errore: | |
145 | |
146 <programlisting> | |
147 directive "server_name" is not terminated by ";" in ... | |
148 </programlisting> | |
149 | |
150 La sezione catturata di una espressione regolare che definisce un nome | |
151 puo' essere usata in seguito come una variabile: | |
152 | |
153 <programlisting> | |
154 server { | |
155 server_name ~^(www\.)?(<b>?<domain></b>.+)$; | |
156 | |
157 location / { | |
158 root /sites/<b>$domain</b>; | |
159 } | |
160 } | |
161 </programlisting> | |
162 | |
163 La libreria PCRE supporta sezioni catturate di nomi tramite la seguente sintassi: | |
164 | |
165 <table note="yes"> | |
166 | |
167 <tr> | |
168 <td><literal>?<<value>nome</value>></literal></td> | |
169 <td>Sintassi compatibile con Perl 5.10, supportata da PCRE-7.0 in poi</td> | |
170 </tr> | |
171 | |
172 <tr> | |
173 <td><literal>?'<value>nome</value>'</literal></td> | |
174 <td>Sintassi compatibile con Perl 5.10, supportata da PCRE-7.0 in poi</td> | |
175 </tr> | |
176 | |
177 <tr> | |
178 <td><literal>?P<<value>nome</value>></literal></td> | |
179 <td>Sintassi compatibile con Python, supportata da PCRE-4.0 in poi</td> | |
180 </tr> | |
181 | |
182 </table> | |
183 | |
184 Quando nginx non riesce ad avviarsi e mostra il seguente messaggio d'errore: | |
185 | |
186 <programlisting> | |
187 pcre_compile() failed: unrecognized character after (?< in ... | |
188 </programlisting> | |
189 | |
190 significa che la libreria PCRE e' troppo vecchia, per cui e' bene provare | |
191 ad usare invece la sintassi: | |
192 “<literal>?P<<value>name</value>></literal>”. | |
193 E' possibile riferirsi a sezioni catturate anche usando cifre: | |
194 | |
195 <programlisting> | |
196 server { | |
197 server_name ~^(www\.)?(.+)$; | |
198 | |
199 location / { | |
200 root /sites/<b>$2</b>; | |
201 } | |
202 } | |
203 </programlisting> | |
204 | |
205 Comunque, tale uso dovrebbe essere limitato ai casi piu' semplici (come | |
206 ad esempio quello appena mostrato), dato che i riferimenti con cifra | |
207 possono essere sovrascritti facilmente. | |
208 </para> | |
209 | |
210 | |
211 </section> | |
212 | |
213 | |
214 <section id="miscellaneous_names" | |
215 name="Nomi vari"> | |
216 | |
217 <para> | |
218 Alcuni nomi di server sono trattati in maniera speciale. | |
219 </para> | |
220 | |
221 <para> | |
222 Se si desidera che le richieste prive del campo <header>Host</header> | |
223 dell'header siano processato in un blocco | |
224 <link doc="ngx_http_core_module.xml" id="server"/> | |
225 che non e' quello di default, e' necessario specificare un nome vuoto: | |
226 | |
227 <programlisting> | |
228 server { | |
229 listen 80; | |
230 server_name example.org www.example.org ""; | |
231 ... | |
232 } | |
233 </programlisting> | |
234 </para> | |
235 | |
236 <para> | |
237 | |
238 Se in un blocco <link doc="ngx_http_core_module.xml" id="server"/> | |
239 non e' specificato alcun <link doc="ngx_http_core_module.xml" id="server_name"/>, | |
240 allora nginx usa il nome vuoto come nome del server. | |
241 <note> | |
242 sino alla versione 0.8.48, in questi casi nginx usava l'hostname della | |
243 macchina come nome del server. | |
244 </note> | |
245 </para> | |
246 | |
247 <para> | |
248 Se il nome del server e' definito come “<literal>$hostname</literal>” (0.9.4), | |
249 il nome del server effettivamente usato e' l'hostname della macchina. | |
250 </para> | |
251 | |
252 <para> | |
253 Se viene fatta una richiesta usando l'indirizzo IP invece di un nome di server, | |
254 il campo <header>Host</header> dell'header di richiesta conterra' l'indirizzo IP, | |
255 e la richiesta potra' essere processata usando l'indirizzo IP come nome del server: | |
256 | |
257 <programlisting> | |
258 server { | |
259 listen 80; | |
260 server_name example.org | |
261 www.example.org | |
262 "" | |
263 <b>192.168.1.1</b> | |
264 ; | |
265 ... | |
266 } | |
267 </programlisting> | |
268 </para> | |
269 | |
270 <para> | |
271 In molti esempi di configurazione di un server catch-all e' spesso possibile | |
272 notare l'uso di uno strano nome | |
273 “<literal>_</literal>”: | |
274 | |
275 <programlisting> | |
276 server { | |
277 listen 80 default_server; | |
278 server_name _; | |
279 return 444; | |
280 } | |
281 </programlisting> | |
282 | |
283 Tale nome non ha niente di speciale, si tratta di un nome qualsiasi, | |
284 scelto piu' o meno a caso fra quelli non validi come nome di dominio. | |
285 Altri esempi di nomi non validi che sono talvolta pure usati sono | |
286 “<literal>--</literal>” e “<literal>!@#</literal>”. | |
287 </para> | |
288 | |
289 <para> | |
290 Sino alla versione 0.6.25 nginx supportava il nome speciale | |
291 “<literal>*</literal>”, che e' stato spesso interpretato erroneamente | |
292 come un nome, non valido, per un server catch-all. | |
293 In effetti, non si e' mai trattato di un nome per un server catch-all o | |
294 di un nome con caratteri jolly: piuttosto, serviva a fornire la funzionalita' | |
295 attualmente affidata alla direttiva | |
296 <link doc="ngx_http_core_module.xml" id="server_name_in_redirect"/>. | |
297 Il nome speciale “<literal>*</literal>” e' attualmente sconsigliato, | |
298 ed e' considerato preferibile l'uso della direttiva | |
299 <link doc="ngx_http_core_module.xml" id="server_name_in_redirect"/>. | |
300 Si noti che non c'e' alcun modo di specificare un nome catch-all o un | |
301 server di default usando la direttiva | |
302 <link doc="ngx_http_core_module.xml" id="server_name"/>: | |
303 si tratta di una proprieta' della direttiva | |
304 <link doc="ngx_http_core_module.xml" id="listen"/> | |
305 e non della direttiva | |
306 <link doc="ngx_http_core_module.xml" id="server_name"/> | |
307 Si faccia riferimento anche a | |
308 “<link doc="request_processing.xml"/>”. | |
309 E' possibile definire server in ascolto sulle porte *:80 e *:8080, | |
310 e specificare che uno e' quello di default per la porta *:8080, | |
311 mentre l'altro e' quello di default per la porta *:80: | |
312 | |
313 <programlisting> | |
314 server { | |
315 listen 80; | |
316 listen 8080 default_server; | |
317 server_name example.net; | |
318 ... | |
319 } | |
320 | |
321 server { | |
322 listen 80 default_server; | |
323 listen 8080; | |
324 server_name example.org; | |
325 ... | |
326 } | |
327 </programlisting> | |
328 </para> | |
329 | |
330 | |
331 </section> | |
332 | |
333 | |
334 <section id="optimization" | |
335 name="Ottimizzazione"> | |
336 | |
337 <para> | |
338 I nomi esatti, i nomi con caratteri jolly che iniziano per asterisco, | |
339 ed i nomi con caratteri jolly che terminano per asterisco, | |
340 sono registrati in tre tabelle di hash collegate alle porte in ascolto. | |
341 Le dimensioni delle tabelle sono ottimizzate in fase di configurazione, | |
342 in maniera tale che i nomi possano essere recuperati con il minimo numero | |
343 di miss alla cache della CPU. | |
344 Dettagli su come configurare le tabelle di hash sono forniti in un | |
345 <link doc="../hash.xml">documento</link> apposito. | |
346 </para> | |
347 | |
348 <para> | |
349 La prima tabella di hash consultata e' quella dei nomi esatti; | |
350 se non si trova il nome ricercato, si prosegue nella tabella di hash | |
351 dei nomi con caratteri jolly che iniziano per asterisco; | |
352 in caso di ulteriore riscontro negativo, si passa alla tabella di hash | |
353 dei nomi con caratteri jolly che finiscono per asterisco. | |
354 </para> | |
355 | |
356 <para> | |
357 La ricerca in una tabella di hash per nomi con caratteri jolly e' piu' lenta | |
358 della ricerca nella tabella relativa ai nomi esatti, dato che i nomi sono ricercati | |
359 per parti del dominio. | |
360 Si noti che il formato speciale “<literal>.example.org</literal>” e' salvato in una | |
361 tabella di hash di nomi con caratteri jolly, e non in quella dei nomi esatti. | |
362 </para> | |
363 | |
364 <para> | |
365 Le espressioni regolari sono testate in sequenza, per cui sono il metodo piu' | |
366 lento e sono non scalabili. | |
367 </para> | |
368 | |
369 <para> | |
370 Per queste ragioni, se possibile e' sempre meglio usare nomi esatti. | |
371 Ad esempio, se i nomi di server richiesti piu' di frequente sono | |
372 <literal>example.org</literal> e <literal>www.example.org</literal>, | |
373 e' piu' efficiente definirli in maniera esplicita: | |
374 | |
375 <programlisting> | |
376 server { | |
377 listen 80; | |
378 server_name example.org www.example.org *.example.org; | |
379 ... | |
380 } | |
381 </programlisting> | |
382 | |
383 che usare il formato piu' semplice: | |
384 | |
385 <programlisting> | |
386 server { | |
387 listen 80; | |
388 server_name .example.org; | |
389 ... | |
390 } | |
391 </programlisting> | |
392 </para> | |
393 | |
394 <para> | |
395 Se il numero di nomi di server definiti e' molto grande, | |
396 oppure se sono stati definiti nomi di server decisamente lunghi, | |
397 per la messa a punto e' possibile che sia necessario utilizzare | |
398 le direttive del livello <i>http</i> | |
399 <link doc="ngx_http_core_module.xml" id="server_names_hash_max_size"/> | |
400 e <link doc="ngx_http_core_module.xml" id="server_names_hash_bucket_size"/>. | |
401 Il valore di default della direttiva | |
402 <link doc="ngx_http_core_module.xml" id="server_names_hash_bucket_size"/> | |
403 puo' essere pari a 32 o 64, oppure ad un altro valore, in base alla | |
404 dimensione della linea di cache della CPU. | |
405 Se il valore di default e' 32 ed il nome del server e' definito come | |
406 “<literal>too.long.server.name.example.org</literal>”, allora nginx non potra' | |
407 partire e sara' mostrato il seguente messaggio d'errore: | |
408 | |
409 <programlisting> | |
410 could not build the server_names_hash, | |
411 you should increase server_names_hash_bucket_size: 32 | |
412 </programlisting> | |
413 | |
414 In tal caso, il valore della direttiva dovrebbe essere aumentata sino alla | |
415 successiva potenza di due: | |
416 | |
417 <programlisting> | |
418 http { | |
419 server_names_hash_bucket_size 64; | |
420 ... | |
421 </programlisting> | |
422 | |
423 Se sono stati definiti molti nomi di server, potrebbe comparire un altro | |
424 messaggio di errore: | |
425 | |
426 <programlisting> | |
427 could not build the server_names_hash, | |
428 you should increase either server_names_hash_max_size: 512 | |
429 or server_names_hash_bucket_size: 32 | |
430 </programlisting> | |
431 | |
432 In tal caso, si provi prima a impostare | |
433 <link doc="ngx_http_core_module.xml" id="server_names_hash_max_size"/> | |
434 ad un numero prossimo al numero dei nomi di server. | |
435 Solo nel caso in cui cio' non risultasse sufficiente, oppure se il tempo di avvio | |
436 di nginx fosse inaccetabilmente alto, si provi ad incrementare | |
437 <link doc="ngx_http_core_module.xml" id="server_names_hash_bucket_size"/>. | |
438 </para> | |
439 | |
440 <para> | |
441 Se su una data porta in ascolto c'e' un unico server, allora nginx saltera' del tutto | |
442 la verifica dei nomi dei server (e non costituira' le tabelle di hash per la porta | |
443 in questione). | |
444 C'e' una eccezione: se un nome di server e' una espressione regolare con | |
445 sezioni catturate, allora nginx dovra' svolgere l'espressione regolare per recuperare | |
446 le sezioni catturate. | |
447 </para> | |
448 | |
449 </section> | |
450 | |
451 | |
452 <section id="compatibility" | |
453 name="Compatibilita'"> | |
454 | |
455 <para> | |
456 <list type="bullet"> | |
457 | |
458 <listitem> | |
459 Il nome di server speciale “<literal>$hostname</literal>” e' supportato | |
460 dalla versione 0.9.4 in poi. | |
461 </listitem> | |
462 | |
463 <listitem> | |
464 Il nome vuoto “” e' il valore di default per il nome dei server | |
465 dalla versione 0.8.48 in poi. | |
466 </listitem> | |
467 | |
468 <listitem> | |
469 Il riferimento tramite nome a sezioni catturate in un nome di server definito | |
470 tramite espressione regolare e' supportato dalla versione 0.8.25 in poi. | |
471 </listitem> | |
472 | |
473 <listitem> | |
474 Le sezioni catturate in un nome di server definito tramite espressione regolare | |
475 sono supportate dalla versione 0.7.40 in poi. | |
476 </listitem> | |
477 | |
478 <listitem> | |
479 Il nome di server vuoto “” e' supportato | |
480 dalla versione 0.7.12 in poi. | |
481 </listitem> | |
482 | |
483 <listitem> | |
484 La definizione di nomi di server e di espressioni regolari tramite caratteri jolly | |
485 e' supportata dalla versione 0.6.25 in poi. | |
486 </listitem> | |
487 | |
488 <listitem> | |
489 La definizione di nomi di server tramite espressioni regolari e' supportata | |
490 dalla versione 0.6.7 in poi. | |
491 </listitem> | |
492 | |
493 <listitem> | |
494 Il formato con caratteri jolly <literal>example.*</literal> e' supportato | |
495 dalla versione 0.6.0 in poi. | |
496 </listitem> | |
497 | |
498 <listitem> | |
499 Il formato speciale <literal>.example.org</literal> e' supportato | |
500 dalla versione 0.3.18 in poi. | |
501 </listitem> | |
502 | |
503 <listitem> | |
504 Il formato con caratteri jolly <literal>*.example.org</literal> e' supportato | |
505 dalla versione 0.1.13 in poi. | |
506 </listitem> | |
507 | |
508 </list> | |
509 </para> | |
510 | |
511 </section> | |
512 | |
513 </article> |