fcl-web/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Contents
2	2
3	3		* 1 Qu'est ce que fpWeb ?
4	4		* 2 Utilisation de fpWeb avec Lazarus
5	5		* 2.1 Installation du paquet Lazarus fpWeb weblaz
6	6		* 2.2 Création d'une application CGI
7	7		* 2.3 Déploiement d'une application CGI
8	8		* 2.4 Formatage du HTML and lecture des champs de requête
9	9		* 2.5 Lecture des données GET
10	10		* 2.6 Lecture des données POST
11	11		* 2.7 Lecture des données binaire POST
12	12		* 3 Modules spécialisés
13	13		* 4 Utiliser de multiples modules
14	14		* 5 Utilisation des actions
15	15		* 6 Utilisation des patrons HTML
16	16		* 7 Conseils & résolution de problèmes
17	17		* 7.1 Envoi des codes de retour
18	18		* 7.2 Envoi de données binaires
19	19		* 7.3 Erreur: "Could not determine HTTP module for request"
20	20		* 7.4 Erreur: "response code 500 Internal Server error when trying to handle DELETE method"
21	21		* 7.5 fpWeb/FCGI et Apache 2.4 (mode mod_proxy_fcgi)
22	22		* 7.6 fpWeb/FCGI et nginx
23	23		* 8 Notes
24	24		* 9 Voir aussi
25	25
26	26		## Qu'est ce que fpWeb ?
27	27
28	28		fpWeb peut être utilisé pour construire des applications Web serveur. Une application serveur Web peut être l'une des suivantes:
29	29
30	30		* Application CGI.
31	31		* Application FastCGI.
32	32		* Module Apache.
33	33		* Serveur HTTP(s) autonome utilisant les composants Free Pascal HTTP server.
34	34		* Serveur HTTP(s) autonome utilisant libmicrohttp de GNU.
35	35		* Application Windows SysHTTP.
36	36
37	37		Dans tous les cas, le modèle de développement est le même : Vous enregistrez des gestionnaires (handlers) pour un ensemble d'URL (appelées routes) auxquels votre application saura répondre. Ensuite vous incorporez ces routes dans l'un des environnements du dessus : Ceci signifie que vous choisissez l'objet application que vous allez utilisez.
38	38
39	39		Dans l'EDI Lazarus, vous avez le choix des applications quand vous commencez un nouveau projet. Il est possible de changer le type d'application une fois que l'application a été démarrée, cela se limite souvent au changement de nom d'une unité dans la clause `uses` du projet.
40	40
41	41		Il est possible de prendre en charge de multiples environnement dans un unique exécutable, au prix de quelques efforts supplémentaires. fpWeb offre aussi du support non conventionnel pour un serveur de base de données REST ou pour des mécanismes JSON RPC 2.0. Ceux-ci sont construits en haut de la structure du dessus. Le [[Brook for Free Pascal/fr\|cadre d'application Brook]] est aussi construit en haut de l'architecture exposée au dessus. Plus d'informations sur le sujet peut être trouvé dans [[fpWeb Tutorial]].
42	42
43	43		## Utilisation de fpWeb avec Lazarus
44	44
45	45		### Installation du paquet Lazarus fpWeb weblaz
46	46
47	47		The first step to do is installing the package which comes in the path lazarus/components/fpweb/weblaz.lpk. As usual with design-time packages, you'll have to rebuild Lazarus.
48	48
49	49		### Création d'une application CGI
50	50
51	51		Après que le paquet `weblaz` ait été installé, une très simple application Web CGI qui affiche une page HTML peut être créée en allant dans le menu Lazarus "Fichier" -> "Nouveau...". Dans la liste des applications possibles, sélectionnez "CGI Application" comme dans l'image ci-dessous, qui va créer un fichier de projet CGI principal et un Web module fpweb.
52	52
53	53		[![New cgi.PNG](/wiki-images/e/ec/New_cgi.PNG)](</File:New_cgi.PNG>)
54	54
55	55		Le TFPWebModule vous permet de manipuler des propriétés et des événements utilisant l'inspecteur d'objet.
56	56
57	57		Pour ajouter du code pour montrer la page, un gestionnaire de requête doit être ajouté. Pour faire ceci, double-cliquer sur la propriété `OnRequest` dans l'inspecteur d'objet, comme dans l'image qui suit:
58	58
59	59		[![Webmodule.PNG](/wiki-images/3/3d/Webmodule.PNG)](</File:Webmodule.PNG>)
60	60
61	61		Dans le gestionnaire d'événement, on doit écrire le code HTML qui sera affiché par le navigateur. Pour éviter de mélanger le Pascal et le HTML, cette page peut être chargée depuis le répertoire où se trouve l'exécutable CGI, en utilisant `AResponse.Contents.LoadFromFile()`.
62	62
63	63		Le type de la réponse doit être défini dans `AResponse.ContentType`. Pour les pages HTML, cela devrait avoir la valeur `'text/html;charset=utf-8'`.
64	64
65	65		Finalement, `Handled` devrait être défini à `True` pour indiquer que la requête a été traité avec succès (et retourne un code d'état '200 OK' au navigateur). Après l'ajout de ce code, le module Web devrait ressembler à ceci :
66	66		```
67	67		unit mainpage;
68	68
69	69		{$mode objfpc}{$H+}
70	70
71	71		interface
72	72
73	73		uses
74	74		Classes, SysUtils, FileUtil, HTTPDefs, websession, fpHTTP, fpWeb;
75	75
76	76		type
77	77
78	78		{ TFPWebModule1 }
79	79
80	80		TFPWebModule1 = class(TFPWebModule)
81	81		procedure DataModuleRequest(Sender: TObject; ARequest: TRequest;
82	82		AResponse: TResponse; var Handled: Boolean);
83	83		private
84	84		{ private declarations }
85	85		public
86	86		{ public declarations }
87	87		end;
88	88
89	89		var
90	90		FPWebModule1: TFPWebModule1;
91	91
92	92		implementation
93	93
94	94		{$R *.lfm}
95	95
96	96		{ TFPWebModule1 }
97	97
98	98		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
99	99		AResponse: TResponse; var Handled: Boolean);
100	100		begin
101	101		AResponse.ContentType := 'text/html;charset=utf-8';
102	102		AResponse.Contents.LoadFromFile(ExtractFilePath(ParamStr(0)) + 'mainpage.html');
103	103		Handled := True;
104	104		end;
105	105
106	106		begin
107	107		RegisterHTTPModule('TFPWebModule1', TFPWebModule1);
108	108		end.
109	109		```
110	110
111	111		### Déploiement d'une application CGI
112	112
113	113		Cette section suppose que le serveur Web Apache est utilisé. Bien sûr, d'autres serveurs Web qui supportent CGI (nginx, cherokee) peuvent aussi être utilisé.
114	114
115	115		Apache peut être téléchargé [ici](<http://httpd.apache.org/download.cgi>) ou installé en utilisant le gestionnaire de paquets de votre distribution.
116	116
117	117		L'installation par défaut d'Apache traitera tous les fichiers dans son répertoire cgi-bin comme des programmes CGI, afin que l'utilisateur ne puisse pas accéder aux fichiers HTML simples qui y sont placés. Ce répertoire peut être défini dans le fichier `httpd.conf` dans la section suivante :
118	118		```
119	119		#
120	120		# ScriptAlias: This controls which directories contain server scripts.
121	121		# ScriptAliases are essentially the same as Aliases, except that
122	122		# documents in the target directory are treated as applications and
123	123		# run by the server when requested rather than as documents sent to the
124	124		# client. The same rules about trailing "/" apply to ScriptAlias
125	125		# directives as to Alias.
126	126		#
127	127		ScriptAlias /cgi-bin/ "C:/Program Files/Apache Software Foundation/Apache2.2/cgi-bin/"
128	128		```
129	129
130	130		Si vous placez un exécutable appelé "mywebpage.cgi" dans ce répertoire, alors la page peut être accédée comme `<http://localhost/cgi-bin/mywebpage.cgi>` (ou à distance avec l'adresse IP correspondante ou le nom de domaine).
131	131
132	132		fcl-web avec Lazarus sur Windows produit des fichiers .exe. Pour qu'Apache serve ces fichiers, vous devez ajouter ceci:
133	133		```
134	134		AddHandler cgi-script .exe
135	135		```
136	136
137	137		Et pour servir vos exécutables depuis un autre répertoire, vous ajoutez ceci :
138	138		```
139	139		ScriptAlias /bin/ "C:/lazarus_projects/test-fclweb/bin/"
140	140		<Directory "C:/lazarus_projects/test-fclweb/bin/">
141	141		AllowOverride None
142	142		Options None
143	143		Order allow,deny
144	144		Allow from all
145	145		</Directory>
146	146		```
147	147
148	148		### Formatage du HTML and lecture des champs de requête
149	149
150	150		L'exemple précédent montrait juste une simple page HTML. On pourrait désirer p.ex. :
151	151
152	152		* changer dynamiquement la sortie de la page HTML, et
153	153		* en lisant les variables que le navigateur a transmises à la page Web dans les champs de requête (par exemple dans les actions HTTP GET et HTTP POST).
154	154
155	155		Une solution simple pour le premier problème est l'utilisation de routine de format du Pascal standard et l'ajout des `%s` ou `%d` dans le fichier HTML aux places appropriées qui recevront les valeurs spécifiques.
156	156
157	157		### Lecture des données GET
158	158
159	159		Pour lire les variables GET, on peut utiliser `ARequest.QueryFields`, qui est un descendant de TStrings. Chaque variable sera dans une ligne séparée de la TStrings selon le format NomVariable=Valeur, de la même façon qu'elles sont montrées dans l'adresse de la page du navigateur. Pour accéder à une variable, on utilise `ARequest.QueryFields.Values[]` en passant le nom de la variable dans les crochets pour recevoir en retour sa valeur, au lieu d'analyser la chaîne manuellement (NdT: Explication superflue, classe de base du Pascal Objet).
160	160
161	161		Le code résultant :
162	162		```
163	163		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
164	164		AResponse: TResponse; var Handled: Boolean);
165	165		var
166	166		HexText, AsciiText: string;
167	167		begin
168	168		HexText := ARequest.QueryFields.Values['hex'];
169	169		AsciiText := HexToAnsii(HexText);
170	170
171	171		AResponse.ContentType := 'text/html;charset=utf-8';
172	172		AResponse.Contents.LoadFromFile(ExtractFilePath(ParamStr(0)) + 'mainpage.html');
173	173		AResponse.Contents.Text := Format(AResponse.Contents.Text,
174	174		[HexText, AsciiText]);
175	175		Handled := True;
176	176		end;
177	177		```
178	178
179	179		### Lecture des données POST
180	180
181	181		Les données soumises par des requêtes POST peuvent être obtenues de `TRequest.Content`. Il viendra sans les entêtes de requête - en d'autres mots, il contient le corps de la requête.
182	182
183	183		Les données de formulaire soumises peuvent être accédées en utilisant `TRequest.ContentFields` qui est le contenu analysé comme des champs séparés par & et décodés. Par exemple, l'ensemble suivant de valeurs de formulaire :
184	184		```
185	185		login: dfg 345&&
186	186		login_senha: ====
187	187		email: dfg
188	188		```
189	189
190	190		Sera décodé en 'APPLICATION/X-WWW-FORM-URLENCODED' comme ceci (voir [wikipedia POST (HTTP)](<http://en.wikipedia.org/wiki/POST_%28HTTP%29>)):
191	191		```
192	192		login=dfg+345%26%26&login_senha=%3D%3D%3D%3D&email=dfg
193	193		```
194	194
195	195		Et sera disponible dans `TRequest.ContentFields` via l'index de ligne ou en utilisant la propriété `Values`, ce qui est plus pertinent :
196	196		```
197	197		TRequest.ContentFields[0]: login=dfg 345&&
198	198		TRequest.ContentFields[1]: login_senha=====
199	199		TRequest.ContentFields[2]: email=dfg
200	200		TRequest.ContentFields.Values['email']: dfg
201	201		```
202	202
203	203		En cas d'utilisation d'autres types MIME que 'MULTIPART/FORM-DATA' et 'APPLICATION/X-WWW-FORM-URLENCODED' (les types supportés par les formulaires HTML) :
204	204
205	205		* le contenu est uniquement disponible dans `TRequest.Content` et non pas `TRequest.ContentFields`.
206	206		* l'usage de ces types MIME lève un exception pour FPC 2.4.2 (corrigé dans FPC 2.5+).
207	207
208	208		Remarquez que HTTP POST peut aussi envoyer des champs de requête (dans l'URL), p.ex. `<http://server/bla?question=how>`, et qui sont accédés par `TRequest.QueryFields` comme expliqué dans la section précédente.
209	209		```
210	210		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
211	211		AResponse: TResponse; var Handled: Boolean);
212	212		var
213	213		lData: String;
214	214		begin
215	215		lData := ARequest.Content;
216	216		```
217	217
218	218		### Lecture des données binaire POST
219	219
220	220		Les fichiers téléchargés vers le serveur sont sauvés dans un emplacement temporaire avec un nom de fichier temporaire, pour conserver le fichier, vous devrez le déplacer vers un emplacement permanent.
221	221
222	222		Pour recevoir des données sur le serveur qui a été POSTé p.ex comme multipart/form-data, utilisez quelques chose comme ceci :
223	223		```
224	224		procedure TMainWebModule.TFPWebActions2Request(Sender: TObject;
225	225		ARequest: TRequest; AResponse: TResponse; var Handled: Boolean);
226	226		var
227	227		i: Integer;
228	228		begin
229	229		// Process all received files
230	230		for i := 0 to ARequest.Files.Count - 1 do
231	231		begin
232	232		// Doing something else than writeln is highly recommended ;)
233	233		writeln ('Received Filename: '+ARequest.Files[i].LocalFileName);
234	234		end;
235	235
236	236		Handled := true;
237	237		end;
238	238		```
239	239
240	240		Le client peut envoyer des données en utilisant p.ex. `FileFormPost`.
241	241
242	242		## Modules spécialisés
243	243
244	244		La classe `TFPWebModule` (utilisée dessous) est un simple exemple de module Web quii peut être utilisé pour toutes sortes de requêtes HTTP..
245	245
246	246		Toutefois, fpweb vient avec quelques modules spécialisés, qui réalisent des tâches spécialisés :
247	247
248	248		* La classe TSimpleFileModule dans l'unité _fpwebfile.pp_ peut etre utilisée pour envoyer des fichiers. Vous pointez vers un répertoire et elle fait le reste.
249	249		* La classe TFPHTMLModule dans l'unité _fphtml.pp_ peut être utlisé pour produire du HTML.
250	250		* La classe TProxyWebModule dans l'unité _fpwebproxy.pp_ est un proxy de transmission (forwarding proxy) prêt à l'emploi.
251	251		* La classe TFPWebProviderDataModule dans l'unité _fpwebdata.pp_ sert des données au format JSON qui peut être consommé par des magasins (stores) ExtJS.
252	252		* La classe TSQLDBRestModule dans l'unité _sqldbrestmodule.pp_ implémente un serveur full REST appuyé par SQLDB. Voir plus d'informations dans [[SQLDBRestBridge]].
253	253		* La classe TJSONRPCModule dans l'unité _webjsonrpc.pp_ implémente un service JSON-RPC.
254	254		* La classe TExtDirectModule dans l'unité _fpextdirect.pp_ implémente une variante Ext.Direct d'un service JSON-RPC.
255	255
256	256		## Utiliser de multiples modules
257	257
258	258		Si il y a un seul module dans l'application Web, toutes les requêtes seront redirigées vers ce module.
259	259
260	260		Comme votre application Web grossit, de multiples modules peuvent être utilisés. Un nouveau module peut être ajouté en choisissant "Fichier" -> "Nouveau..." et ensuite un des 'Module Web' ou 'Module Web HTML'.
261	261
262	262		FCL-web utilise l'URL pour déterminer comment une requête HTTP qui devrait être manipulé. Il doit donc savoir quels modules Web existent dans l'application. Pour ce faire, chaque module doit être enregistré.
263	263
264	264		Chaque module est enregistré avec fcl-web dans la section 'initialisation de l'unité dans lequel il est défini:
265	265		```
266	266		RegisterHTTPModule('location', TMyModule);
267	267		```
268	268
269	269		Le module sera alors invoqué si une URL de la forme
270	270		```
271	271		http://www.mysite.org/mycgi.cgi/location
272	272		```
273	273
274	274		ou
275	275		```
276	276		http://www.mysite.org/mycgi.cgi?module=location
277	277		```
278	278
279	279		est utilisée.
280	280
281	281		Si plusieurs modules sont présents, le nom du module doit apparaître dans l'URL, ou une erreur sera levée.
282	282
283	283		Ce comportement peut aussi être forcé pour les applications qui ont seulement un unique module en définissant la propriéte `AllowDefaultModule` de l'application à `False` :
284	284		```
285	285		Application.AllowDefaultModule := False;
286	286		```
287	287
288	288		Dans ce cas, l'application fcl-web requerra toujours le nom du module dans l'URL.
289	289
290	290		Le nom de la variable de requête qui détermine le nom du module (par défaut, c'est 'module') peut être défini dans la propriété `Application.ModuleVariable`. Le code suivant
291	291		```
292	292		Application.ModuleVariable := 'm';
293	293		```
294	294
295	295		assure que l'URL suivante est dirigée vers `TMyModule` :
296	296		```
297	297		http://www.mysite.org/mycgi.cgi?m=location
298	298		```
299	299
300	300		Si tout ceci n'est pas suffisant pour déterminer le module vers lequel la requête devrait être passée, l'événement `Application.OnGetModule` peut être utilisé. Il est du type `TGetModuleEvent` :
301	301		```
302	302		type
303	303		TGetModuleEvent = Procedure (Sender : TObject; ARequest : TRequest;
304	304		Var ModuleClass : TCustomHTTPModuleClass) of object;
305	305		```
306	306
307	307		La création d'un gestionnaire pour cet événement permet un contrôle fin sur le module qui est créé pour manipuler la requête : la requête (passée dans `ARequest`) peut être examinée et la variable `ModuleClass` doit être définie par la classe du module qui devrait manipuler la requête.
308	308
309	309		Si `ModuleClass` vaut `Nil` au retour, une erreur sera envoyée au navigateur.
310	310
311	311		## Utilisation des actions
312	312
313	313		Un module peut être utilisé pour grouper certaines sortes d'actions logiquement liées. Imaginez un module `TUserModule` qui est utilisé pour traiter la gestion utilisateur dans les pages Web. Il peut y avoir de multiples actions associées avec un utilisateur :
314	314
315	315		* Création
316	316		* Suppression
317	317		* Mise à jour
318	318		* Affichage
319	319
320	320		Ces différentes actions peuvent être maniée par le mêm module. On peut déterminer l'action depuis l'URL manuellement, comme dans :
321	321		```
322	322		http://mysite/mycgi.cgi/user?action=delete&id=12
323	323		```
324	324
325	325		Cela peut être automatisé.
326	326
327	327		Afin de rendre plus facile la distinction entre les diverses actions, le module a une propriété `actions` : c'est une collection, dans laquelle chaque article est associé avec une réponse différente à la requête. Les actions ont diverses propriétés :
328	328
329	329		`Name`
330	330		Le nom de l'action. L'URL sera examinée pour déterminer le nom de l'action.
331	331		`Content`
332	332		Une chaîne de caractères. Si définie, c'est envoyé vers le navigateur.
333	333		`Contents`
334	334		Une TStringList. c'est envoyé vers le navigateur.
335	335		`ContentProducer`
336	336		Si définie, the ContentProducer maniera la requête.
337	337		`Default`
338	338		Si définie à `True`, alors cette action est l'action par défaut. Ceci signifie que si FCL-Web ne peut pas déterminer le nom de l'action, cette action sera exécutée.
339	339		`Template`
340	340		Si définie, ce patron sera traité et les résultats envoyés vers le navigateur.
341	341
342	342		Il y a aussi quelques événements :
343	343
344	344		`BeforeRequest`
345	345		exécuté avant que la requête ne soit traitée. Peut être utilisé pour définir le 'Content' ou d'autres propriétés.
346	346		`AfterRequest`
347	347		exécuté après le traitement de la requête.
348	348		`OnRequest`
349	349		un gestionnaire d'événement pour manier la requête. Si défini, le gstionnaire est utilisé pour manier la requête.
350	350
351	351		Encore une fois, comme dans le cas de plusieurs modules, l'URL est utilisée pour déterminer quelle action exécuter. La partie juste après la partie module ("utilisateur" dans cet exemple) est utilisée:
352	352		```
353	353		http://mysite/mycgi.cgi/user/delete&id=12
354	354		```
355	355
356	356		exécutera l'action nommée 'delete'.
357	357
358	358		La propriété `ActionVar` du module peut être utilisée pour définir le nom de la variable de requête à utiliser. En affectant :
359	359		```
360	360		UserModule.ActionVar := 'a';
361	361		```
362	362
363	363		peut être utilisé pour changer l'URL du dessus en :
364	364		```
365	365		http://mysite/mycgi.cgi/user?a=delete&id=12
366	366		```
367	367
368	368		S'il y a seulement un module dans l'application, l'URL peut être raccourci en :
369	369		```
370	370		http://mysite/mycgi.cgi/delete&id=12
371	371		```
372	372
373	373		## Utilisation des patrons HTML
374	374
375	375		Pour de l'information au sujet des patrons (template), des étiquettes de patron (template tags) et des paramètres d'étiquettes de patron (template tag parameters) pour générer les pages de réponse, veuillez vous référer au fichier `fptemplate.txt` dans le répertoire FPC dans `/packages/fcl-base/texts/` (NdT : spécifique Linux)
376	376
377	377		Des projets d'exemple qui démontrent l'utilisation des patrons peuvent être trouvés sous le répertoire FPC dans `/packages/fcl-web/examples/fptemplate` (voir le README.txt dedans pour plus).
378	378
379	379		(Dans les versions antérieures, ces exemples se trouvaient dans le répertoire Lazarus dans `/components/fpweb/demo/fptemplate/`)
380	380
381	381		## Conseils & résolution de problèmes
382	382
383	383		### Envoi des codes de retour
384	384
385	385		Pour envoyer une réponse HTTP différente de 200 OK, utiliser `AResponse.Code` et `AResponse.CodeText`, p.ex. :
386	386		```
387	387		AResponse.Code := 404;
388	388		AResponse.CodeText := 'Document not found';
389	389		```
390	390
391	391		### Envoi de données binaires
392	392
393	393		Une approche qui semble marcher pour envoyer p.ex. un fichier tiff depuis le serveur Web vers le client - adapté de `$(fpcdirectory)\packages\fcl-web\examples\jsonrpc\demo1\wmdemo.pp` \- quelque chose comme ceci :
394	394		```
395	395		AResponse.ContentStream := TMemoryStream.Create;
396	396
397	397		try
398	398		AResponse.ContentStream.LoadFromFile('/tmp/sample.tiff');
399	399		AResponse.ContentType := 'image/tiff'; //or whatever MIME type you want to send
400	400		// to do: there is an fpweb example that gets the mime type from the file extension...
401	401		AResponse.ContentLength:=AResponse.ContentStream.Size; //apparently doesn't happen automatically?
402	402		AResponse.SendContent;
403	403		finally
404	404		AResponse.ContentStream.Free;
405	405		end;
406	406
407	407		Handled := true;
408	408		```
409	409
410	410		### Erreur: "Could not determine HTTP module for request"
411	411
412	412		Vous pouvez avoir de multiples modules et de multiples actions. Si vous spécifiez une URL avec un seul item, comme :
413	413		```
414	414		http://localhost/cgi-bin/somemodule
415	415		```
416	416
417	417		alors fpweb suppose que vous êtes en train de spécifier une action. Si vous n'avez pas défini un module par défaut, vous obtiendrez une "500 internal server error (Could not determine HTTP module for request)".
418	418
419	419		Vous pouvez modifier ce comportement pour permettre à fpweb de correspondre à un nom de module à la place en définissant la propriété `PreferModuleName` de l'application sur `True`.
420	420
421	421		### Erreur: "response code 500 Internal Server error when trying to handle DELETE method"
422	422
423	423		Dans FPC 2.6.2 et antérieur, fcl-web n'accepte pas la méthode DELETE et génère une erreur.
424	424
425	425		### fpWeb/FCGI et Apache 2.4 (mode mod_proxy_fcgi)
426	426
427	427		Quand vous voulez déployer une application FastCGI derrière un proxy inverse Apache 2.4+, vous avez besoin de la variable PATH_INFO dans les entêtes qui sont envoyés vai une socket au démon FastCGI.
428	428
429	429		1, Activer les modules suivants: setenvif_module, proxy_module et proxy_fcgi_module
430	430
431	431		(sur CentOS 7 modules sont définis dans le fichier `/etc/httpd/conf.modules.d/00-base.conf` et `/etc/httpd/conf.modules.d/00-proxy.conf)`.
432	432		```
433	433		LoadModule setenvif_module modules/mod_setenvif.so
434	434		LoadModule proxy_module modules/mod_proxy.so
435	435		LoadModule proxy_fcgi_module modules/mod_proxy_fcgi.so
436	436		```
437	437
438	438		2, Configuration du proxy inverse pour fpWeb/FCGI écoutant sur le port 9000.
439	439		$1 = module name
440	440		$2 = action name
441	441		```
442	442		SetEnvIf Request_URI . proxy-fcgi-pathinfo=full
443	443		ProxyPassMatch "/fcgi/(.)/(.)" "fcgi://127.0.0.1:9000/$1/$2"
444	444		```
445	445
446	446		### fpWeb/FCGI et nginx
447	447
448	448		Pour un routage correct, fcl-web requiert que la variable PATH_INFO dans les entêtes envoyés depuis nginx. Pour cela, vous devez diviser l'URL entière en nom d'application FastCGI et en partie information de chemin (path info) avec l'instruction de configuration _fastcgi_split_path_info_. L'instruction accepte une expression régulière et pose la seconde correspondance dans la variable de configuration _$fastcgi_path_info_. Cette variable peut être passée à votre application avec l'instruction _fastcgi_param_.
449	449
450	450		L'exemple de configuration suivante inclut un hôte virtuel complet pour nginx qui passe tout depuis _<http://myserver:8080/mycgiapp/>_ vers une application FastCGI externe.
451	451		```
452	452		server {
453	453
454	454		listen 8080;
455	455		listen [::]:8080;
456	456
457	457		server_name _;
458	458
459	459		root "/var/www";
460	460
461	461		location /mycgiap/ {
462	462		# setting up PATH_INFO
463	463		fastcgi_split_path_info ^(/mycgiapp/)(.*)$;
464	464		fastcgi_param PATH_INFO $fastcgi_path_info;
465	465
466	466		# other parameters
467	467		fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
468	468		fastcgi_param QUERY_STRING $query_string;
469	469		fastcgi_param REQUEST_METHOD $request_method;
470	470		fastcgi_param CONTENT_TYPE $content_type;
471	471		fastcgi_param CONTENT_LENGTH $content_length;
472	472		fastcgi_param SCRIPT_NAME $fastcgi_script_name;
473	473		fastcgi_param REQUEST_URI $request_uri;
474	474		fastcgi_param DOCUMENT_URI $document_uri;
475	475		fastcgi_param DOCUMENT_ROOT $document_root;
476	476		fastcgi_param SERVER_PROTOCOL $server_protocol;
477	477		fastcgi_param REQUEST_SCHEME $scheme;
478	478		fastcgi_param HTTPS $https if_not_empty;
479	479		fastcgi_param GATEWAY_INTERFACE CGI/1.1;
480	480		fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
481	481		fastcgi_param REMOTE_ADDR $remote_addr;
482	482		fastcgi_param REMOTE_PORT $remote_port;
483	483		fastcgi_param SERVER_ADDR $server_addr;
484	484		fastcgi_param SERVER_PORT $server_port;
485	485		fastcgi_param SERVER_NAME $server_name;
486	486
487	487		# pass requests to your FastCGI application
488	488		fastcgi_pass 127.0.0.1:9000;
489	489		}
490	490		}
491	491		```
492	492
493	493		## Notes
494	494
495	495		* L'unité cgiapp est dépréciée, veuillez utiliser fpcgi autant que possible.
496	496		* Les unités fastcgi, custfcgi et fpfcgi ne sont pas supportées sur Darwin en ce moment (Ndt: Qu'en est-il en 2020 ?), parce qu'il utilise un mécanisme qui différe de l'option MSG_NOSIGNAL pour recv() pour indiquer qu'aucun SIGPIPE ne doit être levé en cas de rupture de la connexion. Voir <http://lists.apple.com/archives/macnetworkprog/2002/Dec/msg00091.html> pour comment cela peut être fixé.
497	497		* Si vous déployez votre application et obtenez des erreurs comme "Error: No action name and no default action", vous devrez vous assurer qu'il y a une action affectée à l'URL, ou intercepter les actions non supportées avec une action marquée Default. Dans les deux cas, un gestionnaire d'événement `OnRequest` pour l'action qui définit `Handled:=true` devrait être utilisé.
498	498
499	499		## Voir aussi
500	500
501	501		* [[fpWeb Tutorial]]
502	502		* [[fphttpclient]] Partie de fcl-web qui peut être utilisé de manière autonome dans des applications clientes.
503	503		* _write me!_ fphttpserver Petit serveur Web autonome en Pascal Objet. Peut être utilisé pour servir des applications CGI fcl-web.
504	504		* [[CGI Web Programming/fr\|Débogage de CGI]] Information concernant le débogage des applications CGI.
505	505		* [Part of a tutorial by Leonardo Ramé that shows how to program an fcl-web CGI application; includes example of generating JSON content](<https://github.com/leonardorame/Ext4-MVC-Tutorial/wiki/Lazarus-Server>)
506	506
507	507		---
508		-	From the Free Pascal wiki, page "fcl-web/fr", as the Internet Archive kept it on 2025-01-22. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
	508	+	From the Free Pascal wiki, page "fcl-web/fr", as the Internet Archive kept it on 2025-01-22, last changed on 2020-05-01. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history