Letysite.ru

IT Новости с интернет пространства
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Cors access control allow origin

Как работает заголовок Access-Control-Allow-Origin?

видимо, я совершенно неправильно понял его слова. Я подумал о чем-то подобном:—1—>

  1. клиент загружает код javascript MyCode.js от http://siteA —источник.
  2. заголовок ответа MyCode.Яш содержит Access-Control-Allow-Origin: http://siteB, что, как я думал, означало этот Микод.js было разрешено делать перекрестные ссылки на сайт B.
  3. клиент запускает некоторые функции Mycode в.js, которые в свою очередь делают запросы http://siteB, что должно быть хорошо, несмотря на запросы перекрестного происхождения.

одно точно — я все еще не понимаю, как я должен использовать этот заголовок.

У меня есть полный контроль сайт A и сайт B. Как включить код javascript, загруженный с сайта A, для доступа к ресурсам на сайте B с помощью этого заголовка?

Я не хочу использовать JSONP.

11 ответов

когда сайт A пытается получить контент с сайта B, сайт B может отправить Access-Control-Allow-Origin заголовок ответа, чтобы сообщить браузеру, что содержимое этой страницы доступна в определенное происхождение. (An происхождения это домен, плюс схема и номер порта.) По умолчанию страницы сайта B имеют значение недоступно для любого другого источника; через Access-Control-Allow-Origin заголовок открывает дверь для доступа cross-origin специфическим запрашивая происхождением.

для каждого ресурса / страницы, которую сайт B хочет сделать доступной для сайта A, сайт B должен обслуживать свои страницы с заголовком ответа:

современные браузеры не будут блокировать междоменные запросы напрямую. Если сайт A запрашивает страницу с сайта B, браузер фактически получит запрошенную страницу на сетевом уровне и проверьте, разрешен ли сайт списка заголовков ответов A как разрешенный домен отправителя. Если сайт B не указал, что сайту A разрешен доступ к этой странице, браузер запустит XMLHttpRequest ‘ s error event и запретить данные ответа на запрос кода JavaScript.

не простые запросы

что происходит на сетевом уровне может быть немного сложнее, чем описано выше. Если запрос «не простой» запрос, браузер сначала отправляет запрос параметров» preflight » без данных, чтобы убедитесь, что сервер примет запрос. Запрос не является простым, когда либо (или оба):

  • использование HTTP-глагола, отличного от GET или POST (например, PUT, DELETE)
  • используя не простой заголовков запроса; только простые запросы заголовки:
    • Accept
    • Accept-Language
    • Content-Language
    • Content-Type (это просто, только когда его значение application/x-www-form-urlencoded , multipart/form-data , или text/plain )

если сервер отвечает на параметры preflight с соответствующими заголовками ответов ( Access-Control-Allow-Headers для не простых заголовков, Access-Control-Allow-Methods для не-простых глаголов), которые соответствуют не-простому глаголу и / или не-простым заголовкам, затем браузер отправляет фактический запрос.

предположим, что сайт A хочет отправить запрос PUT для /somePage С не-простой Content-Type стоимостью application/json , браузер сначала отправит предполетный запрос:

отметим, что Access-Control-Request-Method и Access-Control-Request-Headers добавляются браузером автоматически; вам не нужно добавлять их. Эта опция preflight получает успешные заголовки ответов:

при отправке фактического запроса (после завершения предполетной подготовки) поведение идентично тому, как обрабатывается простой запрос. Другими словами, не простой запрос, префлайт которого успешен, обрабатывается так же, как простой запрос (т. е. сервер все равно должен отправить Access-Control-Allow-Origin снова для фактического ответа).

браузеры отправляют фактический запрос:

и сервер отправляет обратно Access-Control-Allow-Origin так же, как и для простого запроса:

посмотреть понимание XMLHttpRequest над CORS для получения дополнительной информации о не простых запросах.

Совместное Использование Запросов Cross-Origin — CORS (A. K. A. Междоменный запрос AJAX)-это проблема, с которой может столкнуться большинство веб-разработчиков, в соответствии с политикой того же происхождения, браузеры ограничивают клиентский JavaScript в песочнице безопасности, обычно JS не может напрямую связываться с удаленным сервером из другого домена. В прошлом разработчики создали много сложных способов достижения междоменного запроса ресурсов, чаще всего используя следующие способы:

  1. использование Flash/Silverlight или на стороне сервера как «прокси» общаться с пульта дистанционного управления.
  2. JSON с прокладкой (JSONP).
  3. встраивает удаленный сервер в iframe и взаимодействует через фрагмент или окно.имя, refer здесь.

эти сложные способы имеют более или менее некоторые проблемы, например, JSONP может привести к дыре в безопасности, если разработчики просто «eval» его, и #3 выше, хотя он работает, оба домена должны строить строгий контракт между собой, это ни гибкий и элегантный IMHO:)

W3C ввела совместное использование ресурсов (CORS) в качестве стандартного решения для обеспечения безопасного, гибкого и рекомендуемого стандартного способа решения этой проблемы.

Механизм

С высокого уровня мы можем просто считать, что CORS-это контракт между клиентским AJAX-вызовом из домена A и страницей, размещенной в домене B, типичным запросом/ответом Кросс-происхождения будет:

запрос AJAX DomainA заголовки

заголовки ответов DomainB

синие части, отмеченные выше, были ядровыми фактами, заголовок запроса» Origin «указывает, откуда исходит запрос кросс-происхождения или запрос предполетной подготовки», заголовок ответа «Access-Control-Allow-Origin» указывает, что эта страница разрешает удаленный запрос от DomainA (если значение * указывает, разрешает удаленные запросы из любого домена).

как я уже упоминал выше, W3 рекомендуемый браузер для реализации «предварительный запрос » перед отправкой фактически перекрестного HTTP-запроса, в двух словах это HTTP OPTIONS запрос:

если Foo.aspx поддерживает параметры http-глагола, он может возвращать ответ, как показано ниже:

только если ответ содержит «Access-Control-Allow-Origin» и его значение » * » или содержит домен, который отправил запрос CORS, удовлетворяя этому условию mandtory браузер будет отправьте фактический Междоменный запрос и кэшируйте результат в «Предварительный Результат-Кэш«.

Я написал в блоге о CORS три года назад:AJAX перекрестный HTTP-запрос

Кросдоменные запросы на примере шрифтов и заголовок Access-Control-Allow-Origin

В файл .htaccess в каталоге, в котором находятся файлы шрифтов добавим следующие директивы (при отсутствии .htaccess его нужно создать):

Header set Access-Control-Allow-Origin «*»

При запросе файлов с расширением ttf, otf, eot или woff веб-сервер Apache (чаще всего используется он и передавать информацию путем указания директив .htaccess можно только ему) будет добавлять необходимый заголовок.

Header set Access-Control-Allow-Origin «*»

Заголовок предполагает, что шрифты может получать любой из сайтов в Интернете, можно ограничить доступ непосредственно указав имя ресурса. Несколько адресов при этом указать нельзя.

Access-Control-Allow-Origin: http://www.mysite.com
На стороне, на которой планируем использовать шрифты в файле CSS пропишем полные к ним пути

Это может выглядеть так:

@font-face <
font-family: ‘AudiNormal’;
src: url(‘http://www.mysite.com/css/fonts/League_Gothic.eot?’) format(‘eot’),
url(‘http://www.mysite.com/css/fonts/League_Gothic.woff’) format(‘woff’),
url(‘http://www.mysite.com/css/fonts/League_Gothic.ttf’) format(‘truetype’),
url(‘http://www.mysite.com/css/fonts/League_Gothic.svg’)

Или так (для каждого шрифта задаются определенные опции):

Читать еще:  Ide dma transfer access

@font-face <
font-family: «AudiNormal»;
font-style: normal;
font-weight: normal;
src: url(‘http://www.mysite.com/style/auditype-normal.ttf’);
>
@font-face <
font-family: «AudiBold»;
font-style: normal;
font-weight: normal;
src: url(‘http://www.mysite.com/style/auditype-bold.ttf’);
>
@font-face <
font-family: «AudiExtNormal»;
font-style: normal;
font-weight: normal;
src: url(‘http://www.mysite.com/style/auditype-extendednormal.ttf’);
>
@font-face <
font-family: «AudiExtBold»;
font-style: normal;
font-weight: normal;
src: url(‘http://www.mysite.com/style/auditype-extendedbold.ttf’);
>

Схема с официального сайта Mozilla, объясняющая принципы работы CORS


Обширную информацию по теме можно найти на официальном сайте Mozilla и на сайтах других популярных браузеров.

Заголовок cors access control allow origin

CORS — Cross-Origin Resource Sharing

curl -I http://www.mysite.com/style/auditype-extendednormal.ttf

HTTP/1.1 200 OK
Server: nginx
Date: Thu, 27 Jul 2017 08:54:38 GMT
Content-Length: 326620
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Wed, 26 Jul 2017 12:46:15 GMT
ETag: «21c6399-4fbdc-55537d562407a»
Accept-Ranges: bytes
Access-Control-Allow-Origin: *

Заголовок, как видно, добавился, но используя curl -I запрос отправляется методом HEAD, чтобы же работали кросдоменные запросы тот же заголовок должен отдаваться в ответ на запрос методом GET

Обратимся к тому же шрифты используя curl, но отправим запрос в этот раз методом GET

curl -i -H «Accept: application/json» «Content-Type: application/json» -X GET http://mysite.com/style/auditype-extendednormal.ttf | head

Чтобы заголовок отдавался корректно необходимо чтобы был активирован mod_headers в Apache

Он активируется командой

После активации модуля веб-сервер необходимо перезагрузить

Access control allow origin может задаваться в конфигурации Apache, но обычно это делается через файл .htaccess способом приведенным в первой части данного материала

XMLHttpRequest: кросс-доменные запросы

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

Более новая информация по этой теме находится на странице https://learn.javascript.ru/fetch-crossorigin.

Обычно запрос XMLHttpRequest может делать запрос только в рамках текущего сайта. При попытке использовать другой домен/порт/протокол – браузер выдаёт ошибку.

Существует современный стандарт XMLHttpRequest, он ещё в состоянии черновика, но предусматривает кросс-доменные запросы и многое другое.

Большинство возможностей этого стандарта уже поддерживаются всеми браузерами, но увы, не в IE9-.

Впрочем, частично кросс-доменные запросы поддерживаются, начиная с IE8, только вместо XMLHttpRequest нужно использовать объект XDomainRequest.

Кросс-доменные запросы

Разберём кросс-доменные запросы на примере кода:

  1. Мы создаём XMLHttpRequest и проверяем, поддерживает ли он событие onload . Если нет, то это старый XMLHttpRequest , значит это IE8,9, и используем XDomainRequest .
  2. Запрос на другой домен отсылается просто указанием соответствующего URL в open . Он обязательно должен быть асинхронным, в остальном – никаких особенностей.

Контроль безопасности

Кросс-доменные запросы проходят специальный контроль безопасности, цель которого – не дать злым хакерам™ завоевать интернет.

Серьёзно. Разработчики стандарта предусмотрели все заслоны, чтобы «злой хакер» не смог, воспользовавшись новым стандартом, сделать что-то принципиально отличное от того, что и так мог раньше и, таким образом, «сломать» какой-нибудь сервер, работающий по-старому стандарту и не ожидающий ничего принципиально нового.

Давайте, на минуточку, вообразим, что появился стандарт, который даёт, без ограничений, возможность делать любой странице HTTP-запросы куда угодно, какие угодно.

Как сможет этим воспользоваться злой хакер?

Он сделает свой сайт, например http://evilhacker.com и заманит туда посетителя (а может посетитель попадёт на «злонамеренную» страницу и по ошибке – не так важно).

Когда посетитель зайдёт на http://evilhacker.com , он автоматически запустит JS-скрипт на странице. Этот скрипт сделает HTTP-запрос на почтовый сервер, к примеру, http://gmail.com . А ведь обычно HTTP-запросы идут с куками посетителя и другими авторизующими заголовками.

Поэтому хакер сможет написать на http://evilhacker.com код, который, сделав GET-запрос на http://gmail.com , получит информацию из почтового ящика посетителя. Проанализирует её, сделает ещё пачку POST-запросов для отправки писем от имени посетителя. Затем настанет очередь онлайн-банка и так далее.

Спецификация CORS налагает специальные ограничения на запросы, которые призваны не допустить подобного апокалипсиса.

Запросы в ней делятся на два вида.

Простыми считаются запросы, если они удовлетворяют следующим двум условиям:

  1. Простой метод: GET, POST или HEAD
  2. Простые заголовки – только из списка:
  • Accept
  • Accept-Language
  • Content-Language
  • Content-Type со значением application/x-www-form-urlencoded , multipart/form-data или text/plain .

«Непростыми» считаются все остальные, например, запрос с методом PUT или с заголовком Authorization не подходит под ограничения выше.

Принципиальная разница между ними заключается в том, что «простой» запрос можно сформировать и отправить на сервер и без XMLHttpRequest, например при помощи HTML-формы.

То есть, злой хакер на странице http://evilhacker.com и до появления CORS мог отправить произвольный GET-запрос куда угодно. Например, если создать и добавить в документ элемент

Комментарии

  • Если вам кажется, что в статье что-то не так — вместо комментария напишите на GitHub.
  • Для одной строки кода используйте тег , для нескольких строк кода — тег

, если больше 10 строк — ссылку на песочницу (plnkr, JSBin, codepen…)

  • Если что-то непонятно в статье — пишите, что именно и с какого места.
  • 3 Ways to Fix the CORS Error — and How the Access-Control-Allow-Origin Header Works

    The Cors Error

    Seen this before? Seeing it right now?

    When working with APIs in your application code, honestly, this bug creeps up more often than it should. And every time, the reaction is the same:

    Fix one: install the Allow-Control-Allow-Origin plugin

    The quickest fix you can make is to install the moesif CORS extension . Once installed, click it in your browser to activate the extension. Make sure the icon’s label goes from “off”:

    Then refresh your application, and your API requests should now work!

    But the plugin fix is deceiving

    The plugin definitely addresses the issue. However, this fix only applies to your own machine. In local development, it’s fine to have a plugin installed that can help you get past the error.

    But once you publish your application, you can’t expect your users to install the plugin too. It wouldn’t be the wisest business decision…

    There’s gotta be better solutions. To get there, let’s answer a couple questions:

    Why was the CORS error there in the first place?

    The error stems from a security mechanism that browsers implement called the same-origin policy.

    The same-origin policy fights one of the most common cyber attacks out there: cross-site request forgery. In this maneuver, a malicious website attempts to take advantage of the browser’s cookie storage system.

    Читать еще:  Oauth access token

    For every HTTP request to a domain, the browser attaches any HTTP cookies associated with that domain. This is especially useful for authentication, and setting sessions. For instance, it’s feasible that you would sign into a web app like facebook-clone.com. In this case, your browser would store a relevant session cookie for the facebook-clone.com domain:

    And this is great! The session cookie gets stored. And every time you re-visit the facebook-clone.com tab, and click around the app, you don’t have to sign in again. Instead, the API will recognize the stored session cookie upon further HTTP requests.

    The only trouble is that the browser automatically includes any relevant cookies stored for a domain when another request is made to that exact domain. Therefore, a scenario like this can happen. Say you clicked on a particularly trick popup add, opening evil-site.com.

    The evil site also has the ability send a request to facebook-clone.com/api. Since the request is going to the facebook-clone.com domain, the browser includes the relevant cookies. Evil-site sends the session cookie, and gains authenticated access to facebook-clone. Your account has been successfully hacked with a cross-site request forgery attack.

    Luckily, in this situation, like a hawk ready to strike, the browser will step in and prevent the malicious code from making an API request like this. It will stop evil-site and say “Blocked by the same-origin policy. ️”

    How does the same-origin policy work under the hood?

    Under the hood, the browser checks if the origins of the web application and the server match. Above, the origins were simplified to the frontend application and backend server domains. But really, the origin is the combination of the protocol, host, and port. For example, in https://www,facebook-clone.com, the protocol is https://, the host is www.facebook-clone.com, and the hidden port number is 443 (the port number typically used for https).

    To conduct the same-origin check, the browser accompanies all requests with a special request that sends the domain information receiving server. For example, for an app running on localhost:3000, the special request format looks like this:

    Reacting to this special request, the server sends back a response header. This header contains an Access-Control-Allow-Origin key, to specify which origins can access the server’s resources. The key will have one of two values:

    One: the server can be really strict, and specify that only one origin can access it:

    Two: the server can let the gates go wide open, and specify the wildcard value to allow all domains to access its resources:

    Once the browser receives this header information back, it compares the frontend domain with the Access-Control-Allow-Origin value from the server. If the frontend domain does not match the value, the browser raises the red flag and blocks the API request with the CORS policy error.

    Did the plugin “fix” it?

    In short, no. The access-control-allow-origin plugin essentially turns off the browser’s same-origin policy. For every request, it will add the Access-Control-Allow-Origin: * header to the response. It tricks the browser, and overrides the CORS header that the server has in place with the open wildcard value.

    Now, it’s fine to leave this plugin on in local development. It’s possible that you already know that the server specifies the Access-Control-Allow-Origin header as the published frontend domain for your app. Then by all means, use the plugin in development to allow the localhost domain to make requests within the browser.

    But if you’re consuming another API, the plugin hasn’t “fixed” the issue. As mentioned before, you wouldn’t want to demand that your users install a plugin to access your code.

    Fix two: send your request to a proxy

    You can’t ask your users to trick their browsers by installing a plugin that applies an header in the frontend. But you can control the backend address that the web app’s API requests are going to.

    The cors-anywhere server is a proxy that adds CORS headers to a request. A proxy acts as an intermediary between a client and server. In this case, the cors-anywhere proxy server operates in between the frontend web app making the request, and the server that responds with data. Similar to the Allow-control-allow-origin plugin, it adds the more open Access-Control-Allow-Origin: * header to the response.

    It works like this. Say your frontend is trying to make a GET request to:

    But this api does not have a Access-Control-Allow-Origin value in place that permits the web application domain to access it. So instead, send your GET request to:

    The proxy server receives the https://joke-api-strict-cors.appspot.com/jokes/random from the url above. Then it makes the request to get that server’s response. And finally, the proxy applies the Access-Control-Allow-Origin: * to that original response.

    This solution is great because it works in both development and production. In summary, you’re taking advantage of the fact that the same origin policy is only implemented in browser-to-server communication. Which means it doesn’t have to be enforced in server-to-server communication!

    The one downside of the cors-anywhere proxy is that can often take a while to receive a response. The latency is high enough to make your applications appear a bit sluggish.

    This brings us to a final, even better approach.

    Fix three: build your own proxy

    The fix I recommend in situations like this, is to build your own proxy! Exactly like the previous solution, you’re utilizing the fact that the same origin policy is not enforced within server-to-server communication. In addition, you eliminate the latency concern. You don’t need to share the cors-anywhere proxy with other consumers, and you can dedicate as many resources as you need to your own servers.

    Here’s some quick Node.js code that uses the express web framework to create a proxy server around the same https://joke-api-strict-cors.appspot.com/ from above:

    Читать еще:  Access control allow

    How does this work? The proxy uses express middleware to apply a Access-Control-Allow-Origin: * header to every response from the server. At its own jokes/random GET endpoint, the proxy requests a random joke from another server. The same-origin policy doesn’t step in to block the request, even though the domains are different. After all, this is a server-to-server request. Finally, the proxy creates a response to the original requester (an app on the browser) consisting of the resulting data and the middleware-applied Access-Control-Allow-Origin: * header.

    Conclusion

    The CORS error can be the bane of the frontend developer. But once you understand the underlying same-origin policy behind the error, and how it fights the malicious cross-site request forgery attack, it becomes a little more bearable.

    Ultimately, with these fixes, you’ll never have to break a sweat over seeing that red CORS error in your browser console logs again. Instead, in its face, you’ll whip out the plugin or a proxy, and exclaim:

    Fetch и CORS. Пример на ReactJS и другие

    Йо-йо! Недавно я столкнулся с задачей — создать сайт на котором отображаются бонусы клиента. Бонусы я получаю с web-сервиса из 1С, он отдаёт мне json с данными, но предварительно там я должен авторизоваться.

    Для создания этого сайта я решил использовать reactjs. Сайт довольно простой и многого там не будет, но нужно сделать авторизацию. Авторизация происходила с помощью передачи заголовка Authorization примерно вот так:

    Но как только я сделать fetch и запросить данные я столкнулся с множеством проблем в том числе CORS. Я решил эти проблемы и теперь хочу поделиться своим опытом.

    Fetch и авторизация

    Чтобы fetch мог передавать данные для авторизации нужно явно «сказать» ему, что в нём передаются данные для авторизации с помощью credentials. Пример

    В этом случае всё пройдёт гладко и вы успешно пройдёте авторизацию.

    Fetch и CORS

    CORS сильно портит жизнь веб-мастеру, но зато защищает нас. Чтобы описать описать взаимодействие fecth и сервера в корсcдоменных запросах я приведу несколько примеров из спецификации fetch.

    Пример 1

    Скрипт на https: //foo.invalid/ хочет получить некоторые данные с https: //bar.invalid/. (Ни учетные данные, ни доступ к заголовку ответа не важны.)

    При этом будет использоваться протокол CORS, хотя он полностью прозрачен для разработчика из foo.invalid. Как часть протокола CORS, пользовательский агент будет включать заголовок Origin в запрос:

    Получив ответ от bar.invalid, пользовательский агент проверит заголовок ответа «Access-Control-Allow-Origin». Если его значение равно https: // foo.invalid или *, пользовательский агент вызовет успешный обратный (success) вызов. Если оно имеет какое-либо другое значение или отсутствует, пользовательский агент вызовет failure.

    Пример 2

    Разработчик foo.invalid вернулся и теперь хочет получить некоторые данные из bar.invalid, одновременно обращаясь к заголовку ответа.

    bar.invalid предоставляет правильный заголовок ответа Access-Control-Allow-Origin в соответствии с предыдущим примером. Значения hsts и csp будут зависеть от заголовка ответа «Access-Control-Expose-Headers». Например, если в ответ включены следующие заголовки

    тогда hsts будет нулевым, а csp будет «default-src ‘self», даже если ответ включает оба заголовка. Это связано с тем, что bar.invalid должен явно разделять каждый заголовок, перечисляя их имена в заголовке ответа Access-Control-Expose-Headers.

    В качестве альтернативы, если bar.invalid хочет совместно использовать все свои заголовки ответа, для запросов, которые не включают учетные данные, он может использовать ‘*’ в качестве значения для заголовка ответа Access-Control-Expose-Headers. Если бы запрос включал учетные данные, имена заголовков ответов должны были бы быть перечислены явно, и ‘*’ не мог бы использоваться.

    Пример 3. С передачей учётных данных (пароля)

    Разработчик foo.invalid извлекает некоторые данные из bar.invalid, включая учетные данные. На этот раз протокол CORS больше не прозрачен для разработчика, поскольку учетные данные требуют явного согласия:

    Это также делает все заголовки ответа Set-Cookie bar.invalid полностью функциональными (в противном случае они игнорируются).

    Пользовательский агент обязательно включит в запрос все соответствующие учетные данные. Это также повысит требования к ответу. Мало того, что bar.invalid нужно будет перечислить https: // foo.invalid в качестве значения для заголовка Access-Control-Allow-Origin (‘*’ не допускается, когда задействованы учетные данные), Access-Control-Allow-Credentials заголовок также должен присутствовать:

    Если ответ не включает эти два заголовка с этими значениями, будет вызван failure callback (в fetch). Однако любые заголовки ответа Set-Cookie будут соблюдены.

    CORS, Fetch и сервер

    Как мы уже поняли нам нужно задавать правильные заголовки для того, чтобы кросс-доменные запросы работали и мы имели доступ к контенту, который присылает сервер. Вот выжимка заголовков:

    HTTPS для ReactJS во время разработки

    Я использовал статью с medium, она довольно простая.

    GET преобразуется в OPTION

    Во время кросс-доменных запросов get-запрос преобразуется в option в том случае если вы передаёте заголовки и в fetch’е установлено . В таком случае появляется ошибка » 405 method not allowed».

    Options-запрос отправляется для того, чтобы браузер понял можно ли вообще передавать заголовки с этого домена и какие.

    В том случае если вы передаёте в get-запросе, например заголовок «Authorization» то должны отдать «пачку» заголовков:

    Когда fetch получит эти заголовки то автоматически отправит уже GET-запрос. Вы можете легко проверить это если посмотрите, например, в DevTools хрома (вкладка Network)

    В том случае если заголовки не будут переданы то в status code от сервера вы увидите «405 method not allowed». Так же вы увидите это если не перечислите нужный метод в «Access-Control-Allow-Methods»

    Если вы не понимаете, что такое fetch предлагаю прочитать мою статью «fetch в reactjs«, возможно так же вам понадобиться статья про router в react

    Надеюсь я сэкономил вам немного времени, ведь именно это основная цель моего сайта. Если вы хотите и дальше экономить своё время то обязательно подписывайтесь на обновления сайта с помощью push-уведомлений.

    Поддержи Xakplant

    Я давно хочу развить видеоверсию, но пока этого не получается из-за нехватки ресурсов. Сейчас я собираю деньги на новый компьютер и микрофон. Поддержи xaklant и ты увидишь полезные видео быстрее.

    Ссылка на основную публикацию
    Adblock
    detector