跳到主要內容

12.DRF-節流

Django rest framework源碼分析（3）----節流


添加節流


自定義節流的方法



  • 限制60s內只能訪問3次


（1）API文件夾下面新建throttle.py，代碼如下：


# utils/throttle.py
 
 from rest_framework.throttling import BaseThrottle
 import time
 VISIT_RECORD = {}   #保存訪問記錄
 
 class VisitThrottle(BaseThrottle):
     '''60s內只能訪問3次'''
     def __init__(self):
         self.history = None   #初始化訪問記錄
 
     def allow_request(self,request,view):
         #獲取用戶ip (get_ident)
         remote_addr = self.get_ident(request)
         ctime = time.time()
         #如果當前IP不在訪問記錄裏面，就添加到記錄
         if remote_addr not in VISIT_RECORD:
             VISIT_RECORD[remote_addr] = [ctime,]     #鍵值對的形式保存
             return True    #True表示可以訪問
         #獲取當前ip的歷史訪問記錄
         history = VISIT_RECORD.get(remote_addr)
         #初始化訪問記錄
         self.history = history
 
         #如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
         #只要為True，就一直循環刪除最早的一次訪問記錄
         while history and history[-1] < ctime - 60:
             history.pop()
         #如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
         if len(history) < 3:
             history.insert(0,ctime)
             return True
 
     def wait(self):
         '''還需要等多久才能訪問'''
         ctime = time.time()
         return 60 - (ctime - self.history[-1])

（2）settings中全局配置節流


#全局
 REST_FRAMEWORK = {
     #節流
     "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.VisitThrottle'],
 }

（3）現在訪問auth看看結果：



  • 60s內訪問次數超過三次，會限制訪問

  • 提示剩餘多少時間可以訪問



接着訪問



節流源碼分析


（1）dispatch


def dispatch(self, request, *args, **kwargs):
     """
     `.dispatch()` is pretty much the same as Django's regular dispatch,
     but with extra hooks for startup, finalize, and exception handling.
     """
     self.args = args
     self.kwargs = kwargs
     #對原始request進行加工，豐富了一些功能
     #Request(
     #     request,
     #     parsers=self.get_parsers(),
     #     authenticators=self.get_authenticators(),
     #     negotiator=self.get_content_negotiator(),
     #     parser_context=parser_context
     # )
     #request(原始request,[BasicAuthentications對象，])
     #獲取原生request,request._request
     #獲取認證類的對象，request.authticators
     #1.封裝request
     request = self.initialize_request(request, *args, **kwargs)
     self.request = request
     self.headers = self.default_response_headers  # deprecate?
 
     try:
         #2.認證
         self.initial(request, *args, **kwargs)
 
         # Get the appropriate handler method
         if request.method.lower() in self.http_method_names:
             handler = getattr(self, request.method.lower(),
                                   self.http_method_not_allowed)
         else:
             handler = self.http_method_not_allowed
 
         response = handler(request, *args, **kwargs)
 
     except Exception as exc:
         response = self.handle_exception(exc)
 
     self.response = self.finalize_response(request, response, *args, **kwargs)
     return self.response

（2）initial


def initial(self, request, *args, **kwargs):
     """
     Runs anything that needs to occur prior to calling the method handler.
     """
     self.format_kwarg = self.get_format_suffix(**kwargs)
 
     # Perform content negotiation and store the accepted info on the request
     neg = self.perform_content_negotiation(request)
     request.accepted_renderer, request.accepted_media_type = neg
 
     # Determine the API version, if versioning is in use.
     version, scheme = self.determine_version(request, *args, **kwargs)
     request.version, request.versioning_scheme = version, scheme
 
     # Ensure that the incoming request is permitted
     #4.實現認證
     self.perform_authentication(request)
     #5.權限判斷
     self.check_permissions(request)
     #6.控制訪問頻率
     self.check_throttles(request)

（3）check_throttles


裏面有個allow_request


def check_throttles(self, request):
     """
     Check if request should be throttled.
     Raises an appropriate exception if the request is throttled.
     """
     for throttle in self.get_throttles():
         if not throttle.allow_request(request, self):
             self.throttled(request, throttle.wait())

（4）get_throttles


def get_throttles(self):
     """
     Instantiates and returns the list of throttles that this view uses.
     """
     return [throttle() for throttle in self.throttle_classes]

（5）thtottle_classes



內置節流類


上面是寫的自定義節流，drf內置了很多節流的類，用起來比較方便。


（1）BaseThrottle



  • 自己要寫allow_request和wait方法

  • get_ident就是獲取ip


class BaseThrottle(object):
     """
     Rate throttling of requests.
     """
 
     def allow_request(self, request, view):
         """
         Return `True` if the request should be allowed, `False` otherwise.
         """
         raise NotImplementedError('.allow_request() must be overridden')
 
     def get_ident(self, request):
         """
         Identify the machine making the request by parsing HTTP_X_FORWARDED_FOR
         if present and number of proxies is > 0. If not use all of
         HTTP_X_FORWARDED_FOR if it is available, if not use REMOTE_ADDR.
         """
         xff = request.META.get('HTTP_X_FORWARDED_FOR')
         remote_addr = request.META.get('REMOTE_ADDR')
         num_proxies = api_settings.NUM_PROXIES
 
         if num_proxies is not None:
             if num_proxies == 0 or xff is None:
                 return remote_addr
             addrs = xff.split(',')
             client_addr = addrs[-min(num_proxies, len(addrs))]
             return client_addr.strip()
 
         return ''.join(xff.split()) if xff else remote_addr
 
     def wait(self):
         """
         Optionally, return a recommended number of seconds to wait before
         the next request.
         """
         return None

（2）SimpleRateThrottle


class SimpleRateThrottle(BaseThrottle):
     """
     A simple cache implementation, that only requires `.get_cache_key()`
     to be overridden.
 
     The rate (requests / seconds) is set by a `rate` attribute on the View
     class.  The attribute is a string of the form 'number_of_requests/period'.
 
     Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day')
 
     Previous request information used for throttling is stored in the cache.
     """
     cache = default_cache
     timer = time.time
     cache_format = 'throttle_%(scope)s_%(ident)s'
     scope = None   #這個值自定義，寫什麼都可以
     THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES
 
     def __init__(self):
         if not getattr(self, 'rate', None):
             self.rate = self.get_rate()
         self.num_requests, self.duration = self.parse_rate(self.rate)
 
     def get_cache_key(self, request, view):
         """
         Should return a unique cache-key which can be used for throttling.
         Must be overridden.
 
         May return `None` if the request should not be throttled.
         """
         raise NotImplementedError('.get_cache_key() must be overridden')
 
     def get_rate(self):
         """
         Determine the string representation of the allowed request rate.
         """
         if not getattr(self, 'scope', None):
             msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
                    self.__class__.__name__)
             raise ImproperlyConfigured(msg)
 
         try:
             return self.THROTTLE_RATES[self.scope]
         except KeyError:
             msg = "No default throttle rate set for '%s' scope" % self.scope
             raise ImproperlyConfigured(msg)
 
     def parse_rate(self, rate):
         """
         Given the request rate string, return a two tuple of:
         <allowed number of requests>, <period of time in seconds>
         """
         if rate is None:
             return (None, None)
         num, period = rate.split('/')
         num_requests = int(num)
         duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
         return (num_requests, duration)
 
     def allow_request(self, request, view):
         """
         Implement the check to see if the request should be throttled.
 
         On success calls `throttle_success`.
         On failure calls `throttle_failure`.
         """
         if self.rate is None:
             return True
 
         self.key = self.get_cache_key(request, view)
         if self.key is None:
             return True
 
         self.history = self.cache.get(self.key, [])
         self.now = self.timer()
 
         # Drop any requests from the history which have now passed the
         # throttle duration
         while self.history and self.history[-1] <= self.now - self.duration:
             self.history.pop()
         if len(self.history) >= self.num_requests:
             return self.throttle_failure()
         return self.throttle_success()
 
     def throttle_success(self):
         """
         Inserts the current request's timestamp along with the key
         into the cache.
         """
         self.history.insert(0, self.now)
         self.cache.set(self.key, self.history, self.duration)
         return True
 
     def throttle_failure(self):
         """
         Called when a request to the API has failed due to throttling.
         """
         return False
 
     def wait(self):
         """
         Returns the recommended next request time in seconds.
         """
         if self.history:
             remaining_duration = self.duration - (self.now - self.history[-1])
         else:
             remaining_duration = self.duration
 
         available_requests = self.num_requests - len(self.history) + 1
         if available_requests <= 0:
             return None
 
         return remaining_duration / float(available_requests)

我們可以通過繼承SimpleRateThrottle類，來實現節流，會更加的簡單，因為SimpleRateThrottle裏面都幫我們寫好了


（1）throttle.py


from rest_framework.throttling import SimpleRateThrottle
 
 class VisitThrottle(SimpleRateThrottle):
     '''匿名用戶60s只能訪問三次（根據ip）'''
     scope = 'NBA'   #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
 
     def get_cache_key(self, request, view):
         #通過ip限制節流
         return self.get_ident(request)
 
 class UserThrottle(SimpleRateThrottle):
     '''登錄用戶60s可以訪問10次'''
     scope = 'NBAUser'    #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
 
     def get_cache_key(self, request, view):
         return request.user.username

（2）settings.py


#全局
 REST_FRAMEWORK = {
     #節流
     "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
     "DEFAULT_THROTTLE_RATES":{
         'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
         'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
     }
 }

（3）views.py


局部配置方法


class AuthView(APIView):
     .
     .    
     .
     # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
     throttle_classes = [VisitThrottle,]　 　.    .
 

# views.py
 from django.shortcuts import render,HttpResponse
 from django.http import JsonResponse
 from rest_framework.views import APIView
 from API import models
 from rest_framework.request import Request
 from rest_framework import exceptions
 from rest_framework.authentication import BaseAuthentication
 from API.utils.permission import SVIPPremission,MyPremission
 from API.utils.throttle import  VisitThrottle
 
 ORDER_DICT = {
     1:{
         'name':'apple',
         'price':15
     },
     2:{
         'name':'dog',
         'price':100
     }
 }
 
 def md5(user):
     import hashlib
     import time
     #當前時間，相當於生成一個隨機的字符串
     ctime = str(time.time())
     m = hashlib.md5(bytes(user,encoding='utf-8'))
     m.update(bytes(ctime,encoding='utf-8'))
     return m.hexdigest()
 
 
 class AuthView(APIView):
     '''用於用戶登錄驗證'''
 
     authentication_classes = []      #裏面為空，代表不需要認證
     permission_classes = []          #不裏面為空，代表不需要權限
     # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
     throttle_classes = [VisitThrottle,]
 
     def post(self,request,*args,**kwargs):
         ret = {'code':1000,'msg':None}
         try:
             user = request._request.POST.get('username')
             pwd = request._request.POST.get('password')
             obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
             if not obj:
                 ret['code'] = 1001
                 ret['msg'] = '用戶名或密碼錯誤'
             #為用戶創建token
             token = md5(user)
             #存在就更新，不存在就創建
             models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
             ret['token'] = token
         except Exception as e:
             ret['code'] = 1002
             ret['msg'] = '請求異常'
         return JsonResponse(ret)
 
 
 class OrderView(APIView):
     '''
     訂單相關業務(只有SVIP用戶才能看)
     '''
 
     def get(self,request,*args,**kwargs):
         self.dispatch
         #request.user
         #request.auth
         ret = {'code':1000,'msg':None,'data':None}
         try:
             ret['data'] = ORDER_DICT
         except Exception as e:
             pass
         return JsonResponse(ret)
 
 
 class UserInfoView(APIView):
     '''
        訂單相關業務(普通用戶和VIP用戶可以看)
        '''
     permission_classes = [MyPremission,]    #不用全局的權限配置的話，這裏就要寫自己的局部權限
     def get(self,request,*args,**kwargs):
 
         print(request.user)
         return HttpResponse('用戶信息')

說明：



  • API.utils.throttle.UserThrottle 這個是全局配置（根據ip限制，10/m）

  • DEFAULT_THROTTLE_RATES --->>>設置訪問頻率的

  • throttle_classes = [VisitThrottle,] --->>>局部配置（不適用settings裏面默認的全局配置）


總結


基本使用



  • 創建類，繼承BaseThrottle, 實現：allow_request ，wait

  • 創建類，繼承SimpleRateThrottle, 實現： get_cache_key， scope='NBA' (配置文件中的key)


全局


   #節流
     "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
     "DEFAULT_THROTTLE_RATES":{
         'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
         'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
     }
 }

局部


throttle_classes = [VisitThrottle,]

所有代碼


認證、權限和節流


# MyProject/urls.py
 
 from django.contrib import admin
 from django.urls import path
 from API.views import AuthView,OrderView,UserInfoView
 
 urlpatterns = [
     path('admin/', admin.site.urls),
     path('api/v1/auth/',AuthView.as_view()),
     path('api/v1/order/',OrderView.as_view()),
     path('api/v1/info/',UserInfoView.as_view()),
 ]
 

#全局 settings.py
 REST_FRAMEWORK = {
     #認證
     "DEFAULT_AUTHENTICATION_CLASSES":['API.utils.auth.Authentication',],
     #權限
     "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPermission'],
     #節流
     "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
     "DEFAULT_THROTTLE_RATES":{
         'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
         'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
     }
 }
 

# API/models.py
 
 
 from django.db import models
 
 class UserInfo(models.Model):
     USER_TYPE = (
         (1,'普通用戶'),
         (2,'VIP'),
         (3,'SVIP')
     )
 
     user_type = models.IntegerField(choices=USER_TYPE)
     username = models.CharField(max_length=32)
     password = models.CharField(max_length=64)
 
 class UserToken(models.Model):
     user = models.OneToOneField(UserInfo,on_delete=models.CASCADE)
     token = models.CharField(max_length=64)
 

# API/views.py
 
 from django.shortcuts import render,HttpResponse
 from django.http import JsonResponse
 from rest_framework.views import APIView
 from API import models
 from rest_framework.request import Request
 from rest_framework import exceptions
 from rest_framework.authentication import BaseAuthentication
 from API.utils.permission import SVIPPermission,MyPermission
 from API.utils.throttle import  VisitThrottle
 
 ORDER_DICT = {
     1:{
         'name':'apple',
         'price':15
     },
     2:{
         'name':'dog',
         'price':100
     }
 }
 
 def md5(user):
     import hashlib
     import time
     #當前時間，相當於生成一個隨機的字符串
     ctime = str(time.time())
     m = hashlib.md5(bytes(user,encoding='utf-8'))
     m.update(bytes(ctime,encoding='utf-8'))
     return m.hexdigest()
 
 
 class AuthView(APIView):
     '''用於用戶登錄驗證'''
 
     authentication_classes = []      #裏面為空，代表不需要認證
     permission_classes = []          #不裏面為空，代表不需要權限
     # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
     throttle_classes = [VisitThrottle,]
 
     def post(self,request,*args,**kwargs):
         ret = {'code':1000,'msg':None}
         try:
             user = request._request.POST.get('username')
             pwd = request._request.POST.get('password')
             obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
             if not obj:
                 ret['code'] = 1001
                 ret['msg'] = '用戶名或密碼錯誤'
             #為用戶創建token
             token = md5(user)
             #存在就更新，不存在就創建
             models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
             ret['token'] = token
         except Exception as e:
             ret['code'] = 1002
             ret['msg'] = '請求異常'
         return JsonResponse(ret)
 
 
 class OrderView(APIView):
     '''
     訂單相關業務(只有SVIP用戶才能看)
     '''
 
     def get(self,request,*args,**kwargs):
         self.dispatch
         #request.user
         #request.auth
         ret = {'code':1000,'msg':None,'data':None}
         try:
             ret['data'] = ORDER_DICT
         except Exception as e:
             pass
         return JsonResponse(ret)
 
 
 class UserInfoView(APIView):
     '''
        訂單相關業務(普通用戶和VIP用戶可以看)
        '''
     permission_classes = [MyPermission,]    #不用全局的權限配置的話，這裏就要寫自己的局部權限
     def get(self,request,*args,**kwargs):
 
         print(request.user)
         return HttpResponse('用戶信息')
 

# API/utils/auth/py
 
 from rest_framework import exceptions
 from API import models
 from rest_framework.authentication import BaseAuthentication
 
 
 class Authentication(BaseAuthentication):
     '''用於用戶登錄驗證'''
     def authenticate(self,request):
         token = request._request.GET.get('token')
         token_obj = models.UserToken.objects.filter(token=token).first()
         if not token_obj:
             raise exceptions.AuthenticationFailed('用戶認證失敗')
         #在rest framework內部會將這兩個字段賦值給request，以供後續操作使用
         return (token_obj.user,token_obj)
 
     def authenticate_header(self, request):
         pass
 

# utils/permission.py
 
 from rest_framework.permissions import BasePermission
 
 class SVIPPermission(BasePermission):
     message = "必須是SVIP才能訪問"
     def has_permission(self,request,view):
         if request.user.user_type != 3:
             return False
         return True
 
 
 class MyPermission(BasePermission):
     def has_permission(self,request,view):
         if request.user.user_type == 3:
             return False
         return True
 

# utils/throttle.py
 #
 # from rest_framework.throttling import BaseThrottle
 # import time
 # VISIT_RECORD = {}   #保存訪問記錄
 #
 # class VisitThrottle(BaseThrottle):
 #     '''60s內只能訪問3次'''
 #     def __init__(self):
 #         self.history = None   #初始化訪問記錄
 #
 #     def allow_request(self,request,view):
 #         #獲取用戶ip (get_ident)
 #         remote_addr = self.get_ident(request)
 #         ctime = time.time()
 #         #如果當前IP不在訪問記錄裏面，就添加到記錄
 #         if remote_addr not in VISIT_RECORD:
 #             VISIT_RECORD[remote_addr] = [ctime,]     #鍵值對的形式保存
 #             return True    #True表示可以訪問
 #         #獲取當前ip的歷史訪問記錄
 #         history = VISIT_RECORD.get(remote_addr)
 #         #初始化訪問記錄
 #         self.history = history
 #
 #         #如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
 #         #只要為True，就一直循環刪除最早的一次訪問記錄
 #         while history and history[-1] < ctime - 60:
 #             history.pop()
 #         #如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
 #         if len(history) < 3:
 #             history.insert(0,ctime)
 #             return True
 #
 #     def wait(self):
 #         '''還需要等多久才能訪問'''
 #         ctime = time.time()
 #         return 60 - (ctime - self.history[-1])
 
 from rest_framework.throttling import SimpleRateThrottle
 
 class VisitThrottle(SimpleRateThrottle):
     '''匿名用戶60s只能訪問三次（根據ip）'''
     scope = 'NBA'   #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
 
     def get_cache_key(self, request, view):
         #通過ip限制節流
         return self.get_ident(request)
 
 class UserThrottle(SimpleRateThrottle):
     '''登錄用戶60s可以訪問10次'''
     scope = 'NBAUser'    #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
 
     def get_cache_key(self, request, view):
         return request.user.username
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】



※教你寫出一流的銷售文案?



※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益



※回頭車貨運收費標準



※別再煩惱如何寫文案,掌握八大原則!



※超省錢租車方案



※產品缺大量曝光嗎?你需要的是一流包裝設計!


Orignal From: 12.DRF-節流

留言

張貼留言

這個網誌中的熱門文章

強強聯手!攜手打造雲林縣Web3.0 領地方品牌進軍元宇宙

中華電信攜手國內最大Potato Media Web3.0社群共享平台，及品牌醫生果俐文創三方結合，透過經濟部「CBMP智慧雲遊跨域串連計畫」，協助品牌數位轉型，帶動品牌體驗情境、新商業模組升級與行動支付應用，第一站選在雲林縣當地原生消費品牌，打造社群消費循環，探索近期最夯的元宇宙新玩法。 Potato Media執行長顏宏霖表示，在CBMP計畫協助下，加上站內Web3.0資源，將快速協助雲林縣當地品牌升級轉型，幫助店家創造品牌價值，包含黑矸仔醬油、四代目麥芽酥、玉津烘焙坊、禪屋米胖工坊、YuDS沐耳飲、莫蒂精品巧克力、維野納複合式餐飲、頂雲咖啡、媽祖埔豆腐張、玉山碾米廠等，另外嘉義市麥麵、名香茗茶也等不及跨縣市加入，結合Potato Media站內活動，打造雲林專屬限定NFT道具與頭框，發行雲林扭蛋，體驗全新元宇宙新世界。 左起雲林縣計畫處處長李明岳、果俐文創執行長-陳郁涵、雲林縣議員周秀月、中華電信雲林營運處總經理張肇家、Potato Media執行長顏宏霖、LINE禮物代表睿鼎數位、12CMTaiwan行銷總監楊涵柔。(圖/由Potato Media提供) 此次Potato Media平台合作內容是店家會員註冊活動：首次註冊可得100積分 + 一顆扭蛋，店家推薦文章介紹，可領取店家消費優惠券，站內扭蛋禮物抽獎活動，獎項豐富：雲林限定禮品、雲林意象限定NFT道具與頭框，雲林幣扭一下APP政令大聲公獎勵活動，另外各種雲林美食伴手禮、住宿旅遊的店家，都可以使用行動支付或上LINE禮物平台實際體驗消費。 推薦評價好的 iphone維修 中心 擁有專業的維修技術團隊，同時聘請資深iphone手機維修專家，現場說明手機問題，快速修理，沒修好不收錢 產品缺大量曝光嗎?你需要的是一流 包裝設計 窩窩觸角包含自媒體、自有平台及其他國家營銷業務等，多角化經營並具有國際觀的永續理念。 雲林縣副縣長謝淑亞強調，此次計畫和Potato Media 合作，Potato Media 是一個在 2021 年 4 月正式發布的「區塊鏈 Web3.0 共享社群平台」，創作者和使用者都可以透過互動的機制，例如對文章點讚、留言與轉發分享，來獲取相對應比例的加密貨幣CFO（Potato Media 平台上的原生加密貨幣），跟Facebook、Instagram、YouTu...
張貼留言
閱讀完整內容

要上網站行銷農產品，得經過市政府抽驗農藥殘留，檢驗合格才能上網行銷

台北網站設計      網頁設計公司     網站設計公司 食安五環為「源頭控管」、「重建生產管理履歷」、「提高查驗能力」、「加重生產者、廠商的責任」及「鼓勵、創造監督平臺」五大要環，除推動政府與市民消費者共同監督食品安全，更要從農場到餐桌，鏈結農村產業線，以網路社群為媒介，建立嘉義市農村網頁平台。活動現場介紹「農抵嘉」產銷網頁平台的內容，包含在地人文地產景，將景觀、產業、生態及文化等資訊整合、展現，更推廣在地農村農友優質、安全的農產品。要上「農抵嘉」網站行銷農產品，得經過市政府抽驗農藥殘留，檢驗合格才能上網行銷自己的農產品，嘉義市農友可以多利用，也提供店家採購管道。 「尚安心，農抵嘉」，透過「農抵嘉」產銷網頁平台，鏈結農村產業線並促進地產地消，從源頭管理食安，讓政府管理、民間參與，透過食安小教育，讓小朋友接觸農作物，與生產者互動，產生共鳴，一同攜手維護嘉義市的食安。記者會中也展示紅瓦厝社區所做的紅瓦窯烤，並有其他下埤花生等農產品，透過農場職人使「農特產品不只是農產品」，民眾可登入「農抵嘉」網頁http://chiayirural.com/index.asp瞭解更進一步的訊息。 網動廣告 參考資料:蕃新聞https://n.yam.com/Article/20171226529712 Orignal From: 要上網站行銷農產品，得經過市政府抽驗農藥殘留，檢驗合格才能上網行銷
張貼留言
閱讀完整內容

IEA：疫情衝擊能源需求 但再生能源呈創紀錄成長_台中搬家公司

※ 台中搬家公司 教你幾個打包小技巧,輕鬆整理裝箱! 還在煩惱搬家費用要多少哪？台中大展搬家線上試算搬家費用，從此不再擔心「物品怎麼計費」、「多少車才能裝完」 摘錄自2020年11月10日中央社報導 國際能源總署（IEA）報告今天（10日）指出，武漢肺炎（COVID-19）疫情可能衝擊能源需求，但電力部門再生能源繼續以創紀錄速度成長。 IEA執行董事比羅爾（Fatih Birol）表示：「在2025年，再生能源將成為全球最大發電來源，預計將提供1/3的全球電力，終結煤炭50年來作為最大電力供應來源的地位。」 ※推薦 台中搬家公司 優質服務,可到府估價 台中搬鋼琴,台中金庫搬運,中部廢棄物處理,南投縣搬家公司,好幫手搬家,西屯區搬家 IEA關於再生能源的年度報告估計，儘管受到疫情干擾，今年的再生能源新發電容量可望創紀錄，達將近200GW（GW為十億瓦）。 能源轉型 國際新聞 再生能源 疫情看氣候與能源 本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理 ※ 台中搬家公司 教你幾個打包小技巧,輕鬆整理裝箱! 還在煩惱搬家費用要多少哪？台中大展搬家線上試算搬家費用，從此不再擔心「物品怎麼計費」、「多少車才能裝完」 Orignal From: IEA：疫情衝擊能源需求 但再生能源呈創紀錄成長_台中搬家公司
張貼留言
閱讀完整內容